Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

If the code and the comments disagree, then both are probably wrong. -- Norm Schryer


devel / comp.theory / Software engineers of extreme technical competence [ halting problem proof refutation ] V2

SubjectAuthor
* Software engineers of extreme technical competence [ halting problemolcott
+- Software engineers of extreme technical competence [ haltingHoratio Cornholer
+* Software engineers of extreme technical competence [ haltingMr Flibble
|`* Software engineers of extreme technical competence [ strawmanolcott
| `- Software engineers of extreme technical competence [ strawmanRichard Damon
`* Software engineers of extreme technical competence [ haltingRichard Damon
 `* Software engineers of extreme technical competence [ strawmanolcott
  `- Software engineers of extreme technical competence [ strawmanRichard Damon

1
Software engineers of extreme technical competence [ halting problem proof refutation ] V2

<t8sffd$r78$1@dont-email.me>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=34689&group=comp.theory#34689

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Software engineers of extreme technical competence [ halting problem
proof refutation ] V2
Date: Tue, 21 Jun 2022 08:01:31 -0500
Organization: A noiseless patient Spider
Lines: 95
Message-ID: <t8sffd$r78$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Tue, 21 Jun 2022 13:01:33 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="902ccfb1fd856893813c6c9dde458665";
logging-data="27880"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19pxvOoaz/OyLZYwg9nwDej"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Cancel-Lock: sha1:3XKfRNFtr0oG/1hdTS9O2j15oks=
Content-Language: en-US
 by: olcott - Tue, 21 Jun 2022 13:01 UTC

#include <stdint.h>
typedef void (*ptr)();

void P(ptr x)
{ if (H(x, x))
HERE: goto HERE;
return;
}

int main()
{ Output("Input_Halts = ", H(P, P));
}

_P()
[00001352](01) 55 push ebp
[00001353](02) 8bec mov ebp,esp
[00001355](03) 8b4508 mov eax,[ebp+08]
[00001358](01) 50 push eax // push P
[00001359](03) 8b4d08 mov ecx,[ebp+08]
[0000135c](01) 51 push ecx // push P
[0000135d](05) e840feffff call 000011a2 // call H
[00001362](03) 83c408 add esp,+08
[00001365](02) 85c0 test eax,eax
[00001367](02) 7402 jz 0000136b
[00001369](02) ebfe jmp 00001369
[0000136b](01) 5d pop ebp
[0000136c](01) c3 ret
Size in bytes:(0027) [0000136c]

Every sufficiently competent software engineer can easily verify that
the complete and correct x86 emulation of the input to H(P,P) by H would
never reach the "ret" instruction of P.

#define JMP 0xEB // Simplifed OpCode for all forms of JMP
#define CALL 0xE8 // Simplifed OpCode for all forms of CALL
#define JCC 0x7F // Simplifed OpCode for all forms of Jump on Condition
#define RET 0xC3 // Simplifed OpCode for all forms of Return
#define PUSH 0x68 // Simplifed OpCode for all forms of PUSH

typedef struct Decoded
{ u32 Address;
u32 ESP; // Current value of ESP
u32 TOS; // Current value of Top of Stack
u32 NumBytes;
u32 Simplified_Opcode;
u32 Decode_Target;
} Decoded_Line_Of_Code;

Software engineers with extremely high technical competence will be able
to verify that H correctly determines (in a finite number of steps) that
its complete and correct x86 emulation of its input would never reach
the "ret" instruction of P on this criterion measure basis:

H knows its own machine address and on this basis:
(a) H recognizes that P is calling H with the same arguments that H was
called with at its machine address [0000135d]. The immecdiately
precdding pait of PUSH instructions

(b) There are no instructions in P that could possibly escape this
otherwise infinitely recursive emulation.

(c) H aborts its emulation of P before its call to H is invoked.

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
Begin Simulation Execution Trace Stored at:211e9e
....[000010d2][00211e8a][00211e8e] 55 push ebp
....[000010d3][00211e8a][00211e8e] 8bec mov ebp,esp
....[000010d5][00211e8a][00211e8e] 8b4508 mov eax,[ebp+08]
....[000010d8][00211e86][000010d2] 50 push eax // Push P
....[000010d9][00211e86][000010d2] 8b4d08 mov ecx,[ebp+08]
....[000010dc][00211e82][000010d2] 51 push ecx // Push P
....[000010dd][00211e7e][000010e2] e820feffff call 00000f02 // Call H
Infinitely Recursive Simulation Detected Simulation Stopped

Software engineers with extremely high technical competence could
translate the above criterion measure into working code on the basis of
an the execution_trace list of Decoded_Line_Of_Code of the x86 emulated
first seven instructions of P shown above. It is assumed that P has been
translated into x86 by the Microsoft C compiler, thus having the C
calling conventions.

https://docs.microsoft.com/en-us/cpp/cpp/cdecl?view=msvc-170

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

Re: Software engineers of extreme technical competence [ halting problem proof refutation ] V2

<t8sj24$8hv$2@gioia.aioe.org>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=34690&group=comp.theory#34690

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!42V55DPF/EHESwy7gmIc+w.user.46.165.242.75.POSTED!not-for-mail
From: midship...@navidad.net (Horatio Cornholer)
Newsgroups: comp.theory
Subject: Re: Software engineers of extreme technical competence [ halting
problem proof refutation ] V2
Date: Tue, 21 Jun 2022 07:02:44 -0700
Organization: Aioe.org NNTP Server
Message-ID: <t8sj24$8hv$2@gioia.aioe.org>
References: <t8sffd$r78$1@dont-email.me>
Reply-To: midshipman@navidad.net
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Info: gioia.aioe.org; logging-data="8767"; posting-host="42V55DPF/EHESwy7gmIc+w.user.gioia.aioe.org"; mail-complaints-to="abuse@aioe.org";
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
X-Notice: Filtered by postfilter v. 0.9.2
Content-Language: en-US
 by: Horatio Cornholer - Tue, 21 Jun 2022 14:02 UTC

On 6/21/2022 6:01 AM, olcott wrote:
> #include <stdint.h>
> typedef void (*ptr)();
>

Post it 152,853 more times you impotent blithering wankmaggot.

Re: Software engineers of extreme technical competence [ halting problem proof refutation ] V2

<20220621172410.00000972@reddwarf.jmc>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=34691&group=comp.theory#34691

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx05.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Software engineers of extreme technical competence [ halting
problem proof refutation ] V2
Message-ID: <20220621172410.00000972@reddwarf.jmc>
References: <t8sffd$r78$1@dont-email.me>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 123
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Tue, 21 Jun 2022 16:24:09 UTC
Date: Tue, 21 Jun 2022 17:24:10 +0100
X-Received-Bytes: 5061
 by: Mr Flibble - Tue, 21 Jun 2022 16:24 UTC

On Tue, 21 Jun 2022 08:01:31 -0500
olcott <polcott2@gmail.com> wrote:

> #include <stdint.h>
> typedef void (*ptr)();
>
> void P(ptr x)
> {
> if (H(x, x))
> HERE: goto HERE;
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", H(P, P));
> }
>
> _P()
> [00001352](01) 55 push ebp
> [00001353](02) 8bec mov ebp,esp
> [00001355](03) 8b4508 mov eax,[ebp+08]
> [00001358](01) 50 push eax // push P
> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> [0000135c](01) 51 push ecx // push P
> [0000135d](05) e840feffff call 000011a2 // call H
> [00001362](03) 83c408 add esp,+08
> [00001365](02) 85c0 test eax,eax
> [00001367](02) 7402 jz 0000136b
> [00001369](02) ebfe jmp 00001369
> [0000136b](01) 5d pop ebp
> [0000136c](01) c3 ret
> Size in bytes:(0027) [0000136c]
>
> Every sufficiently competent software engineer can easily verify that
> the complete and correct x86 emulation of the input to H(P,P) by H
> would never reach the "ret" instruction of P.
>
>
>
>
> #define JMP 0xEB // Simplifed OpCode for all forms of JMP
> #define CALL 0xE8 // Simplifed OpCode for all forms of CALL
> #define JCC 0x7F // Simplifed OpCode for all forms of Jump on
> Condition #define RET 0xC3 // Simplifed OpCode for all forms of
> Return #define PUSH 0x68 // Simplifed OpCode for all forms of PUSH
>
> typedef struct Decoded
> {
> u32 Address;
> u32 ESP; // Current value of ESP
> u32 TOS; // Current value of Top of Stack
> u32 NumBytes;
> u32 Simplified_Opcode;
> u32 Decode_Target;
> } Decoded_Line_Of_Code;
>
> Software engineers with extremely high technical competence will be
> able to verify that H correctly determines (in a finite number of
> steps) that its complete and correct x86 emulation of its input would
> never reach the "ret" instruction of P on this criterion measure
> basis:
>
> H knows its own machine address and on this basis:
> (a) H recognizes that P is calling H with the same arguments that H
> was called with at its machine address [0000135d]. The immecdiately
> precdding pait of PUSH instructions
>
> (b) There are no instructions in P that could possibly escape this
> otherwise infinitely recursive emulation.
>
> (c) H aborts its emulation of P before its call to H is invoked.
>
> machine stack stack machine assembly
> address address data code language
> ======== ======== ======== ========= =============
> Begin Simulation Execution Trace Stored at:211e9e
> ...[000010d2][00211e8a][00211e8e] 55 push ebp
> ...[000010d3][00211e8a][00211e8e] 8bec mov ebp,esp
> ...[000010d5][00211e8a][00211e8e] 8b4508 mov eax,[ebp+08]
> ...[000010d8][00211e86][000010d2] 50 push eax // Push P
> ...[000010d9][00211e86][000010d2] 8b4d08 mov ecx,[ebp+08]
> ...[000010dc][00211e82][000010d2] 51 push ecx // Push P
> ...[000010dd][00211e7e][000010e2] e820feffff call 00000f02 // Call H
> Infinitely Recursive Simulation Detected Simulation Stopped
>
> Software engineers with extremely high technical competence could
> translate the above criterion measure into working code on the basis
> of an the execution_trace list of Decoded_Line_Of_Code of the x86
> emulated first seven instructions of P shown above. It is assumed
> that P has been translated into x86 by the Microsoft C compiler, thus
> having the C calling conventions.
>
> https://docs.microsoft.com/en-us/cpp/cpp/cdecl?view=msvc-170
void Px(u32 x)
{ H(x, x);
return;
}

int main()
{ Output("Input_Halts = ", H((u32)Px, (u32)Px));
}

....[000013e8][00102357][00000000] 83c408 add esp,+08
....[000013eb][00102353][00000000] 50 push eax
....[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
....[000013f6][00102357][00000000] 83c408 add esp,+08
....[000013f9][00102357][00000000] 33c0 xor eax,eax
....[000013fb][0010235b][00100000] 5d pop ebp
....[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)

It gets the answer wrong, i.e. input has not been decided correctly.
QED.

/Flibble

Re: Software engineers of extreme technical competence [ halting problem proof refutation ] V2

<fErsK.5525$Me2.3759@fx47.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=34694&group=comp.theory#34694

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!peer03.ams4!peer.am4.highwinds-media.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx47.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.10.0
Subject: Re: Software engineers of extreme technical competence [ halting
problem proof refutation ] V2
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <t8sffd$r78$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <t8sffd$r78$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 112
Message-ID: <fErsK.5525$Me2.3759@fx47.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 21 Jun 2022 18:30:26 -0400
X-Received-Bytes: 5355
 by: Richard Damon - Tue, 21 Jun 2022 22:30 UTC

On 6/21/22 9:01 AM, olcott wrote:
> #include <stdint.h>
> typedef void (*ptr)();
>
> void P(ptr x)
> {
>   if (H(x, x))
>     HERE: goto HERE;
>   return;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H(P, P));
> }
>
> _P()
> [00001352](01) 55 push ebp
> [00001353](02) 8bec mov ebp,esp
> [00001355](03) 8b4508 mov eax,[ebp+08]
> [00001358](01) 50 push eax              // push P
> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> [0000135c](01) 51 push ecx              // push P
> [0000135d](05) e840feffff call 000011a2 // call H
> [00001362](03) 83c408 add esp,+08
> [00001365](02) 85c0 test eax,eax
> [00001367](02) 7402 jz 0000136b
> [00001369](02) ebfe jmp 00001369
> [0000136b](01) 5d pop ebp
> [0000136c](01) c3 ret
> Size in bytes:(0027) [0000136c]
>
> Every sufficiently competent software engineer can easily verify that
> the complete and correct x86 emulation of the input to H(P,P) by H would
> never reach the "ret" instruction of P.
>
>
>
>
> #define   JMP 0xEB // Simplifed OpCode for all forms of JMP
> #define  CALL 0xE8 // Simplifed OpCode for all forms of CALL
> #define   JCC 0x7F // Simplifed OpCode for all forms of Jump on Condition
> #define   RET 0xC3 // Simplifed OpCode for all forms of Return
> #define  PUSH 0x68 // Simplifed OpCode for all forms of PUSH
>
> typedef struct Decoded
> {
>   u32 Address;
>   u32 ESP;          // Current value of ESP
>   u32 TOS;          // Current value of Top of Stack
>   u32 NumBytes;
>   u32 Simplified_Opcode;
>   u32 Decode_Target;
> } Decoded_Line_Of_Code;
>
> Software engineers with extremely high technical competence will be able
> to verify that H correctly determines (in a finite number of steps) that
> its complete and correct x86 emulation of its input would never reach
> the "ret" instruction of P on this criterion measure basis:
>
> H knows its own machine address and on this basis:
> (a) H recognizes that P is calling H with the same arguments that H was
> called with at its machine address [0000135d]. The immecdiately
> precdding pait of PUSH instructions
>
> (b) There are no instructions in P that could possibly escape this
> otherwise infinitely recursive emulation.
>

And, what is your basis for THIS wording, the way you interpret it.

There IS an instruction in the PROGRAM P (which is what halting deciders
are supposed to be looking at), namely in the code for H that decides to
abort (or are you talkinga about the H that doesn't abort and thus fails
to answer?)

> (c) H aborts its emulation of P before its call to H is invoked.

And thus is WRONG.

>
>     machine   stack     stack     machine    assembly
>     address   address   data      code       language
>     ========  ========  ========  =========  =============
> Begin Simulation   Execution Trace Stored at:211e9e
> ...[000010d2][00211e8a][00211e8e] 55         push ebp
> ...[000010d3][00211e8a][00211e8e] 8bec       mov ebp,esp
> ...[000010d5][00211e8a][00211e8e] 8b4508     mov eax,[ebp+08]
> ...[000010d8][00211e86][000010d2] 50         push eax      // Push P
> ...[000010d9][00211e86][000010d2] 8b4d08     mov ecx,[ebp+08]
> ...[000010dc][00211e82][000010d2] 51         push ecx      // Push P
> ...[000010dd][00211e7e][000010e2] e820feffff call 00000f02 // Call H
> Infinitely Recursive Simulation Detected Simulation Stopped
>
> Software engineers with extremely high technical competence could
> translate the above criterion measure into working code on the basis of
> an the execution_trace list of Decoded_Line_Of_Code of the x86 emulated
> first seven instructions of P shown above. It is assumed that P has been
> translated into x86 by the Microsoft C compiler, thus having the C
> calling conventions.
>
> https://docs.microsoft.com/en-us/cpp/cpp/cdecl?view=msvc-170
>
>

Yes, you can code the above definition, and get the same broken decider.

H is WRONG, because H(P,P) is SUPPOSED to tell us if P(P) will halt or
not, but if H(P,P) returns 0, then P(P) will Halt, and thus H is wrong.

If H(P,P) doesn't return an answer, it fails to be a decider, and thus
also wrong.

Re: Software engineers of extreme technical competence [ strawman deception]

<SLOdnVtUhslI6y__nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=34697&group=comp.theory#34697

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 21 Jun 2022 20:56:37 -0500
Date: Tue, 21 Jun 2022 20:56:36 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Software engineers of extreme technical competence [ strawman
deception]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <t8sffd$r78$1@dont-email.me>
<20220621172410.00000972@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220621172410.00000972@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <SLOdnVtUhslI6y__nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 157
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Vs3Rjlf8YwXNF50aLt3+HKz+JTr8JbZp3sNuECgngNmldFKoZORkgBMHVTQ0Bq1Z0hxd72YTnD4qXo9!YsHdrqq8gpgG34u/zWOUO3m3B37iBN78WeBLfbTXAp335LVmrytL9VC8r3ns7peWWJovmZx3vaqo
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 7022
 by: olcott - Wed, 22 Jun 2022 01:56 UTC

On 6/21/2022 11:24 AM, Mr Flibble wrote:
> On Tue, 21 Jun 2022 08:01:31 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> #include <stdint.h>
>> typedef void (*ptr)();
>>
>> void P(ptr x)
>> {
>> if (H(x, x))
>> HERE: goto HERE;
>> return;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H(P, P));
>> }
>>
>> _P()
>> [00001352](01) 55 push ebp
>> [00001353](02) 8bec mov ebp,esp
>> [00001355](03) 8b4508 mov eax,[ebp+08]
>> [00001358](01) 50 push eax // push P
>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>> [0000135c](01) 51 push ecx // push P
>> [0000135d](05) e840feffff call 000011a2 // call H
>> [00001362](03) 83c408 add esp,+08
>> [00001365](02) 85c0 test eax,eax
>> [00001367](02) 7402 jz 0000136b
>> [00001369](02) ebfe jmp 00001369
>> [0000136b](01) 5d pop ebp
>> [0000136c](01) c3 ret
>> Size in bytes:(0027) [0000136c]
>>
>> Every sufficiently competent software engineer can easily verify that
>> the complete and correct x86 emulation of the input to H(P,P) by H
>> would never reach the "ret" instruction of P.
>>
>>
>>
>>
>> #define JMP 0xEB // Simplifed OpCode for all forms of JMP
>> #define CALL 0xE8 // Simplifed OpCode for all forms of CALL
>> #define JCC 0x7F // Simplifed OpCode for all forms of Jump on
>> Condition #define RET 0xC3 // Simplifed OpCode for all forms of
>> Return #define PUSH 0x68 // Simplifed OpCode for all forms of PUSH
>>
>> typedef struct Decoded
>> {
>> u32 Address;
>> u32 ESP; // Current value of ESP
>> u32 TOS; // Current value of Top of Stack
>> u32 NumBytes;
>> u32 Simplified_Opcode;
>> u32 Decode_Target;
>> } Decoded_Line_Of_Code;
>>
>> Software engineers with extremely high technical competence will be
>> able to verify that H correctly determines (in a finite number of
>> steps) that its complete and correct x86 emulation of its input would
>> never reach the "ret" instruction of P on this criterion measure
>> basis:
>>
>> H knows its own machine address and on this basis:
>> (a) H recognizes that P is calling H with the same arguments that H
>> was called with at its machine address [0000135d]. The immecdiately
>> precdding pait of PUSH instructions
>>
>> (b) There are no instructions in P that could possibly escape this
>> otherwise infinitely recursive emulation.
>>
>> (c) H aborts its emulation of P before its call to H is invoked.
>>
>> machine stack stack machine assembly
>> address address data code language
>> ======== ======== ======== ========= =============
>> Begin Simulation Execution Trace Stored at:211e9e
>> ...[000010d2][00211e8a][00211e8e] 55 push ebp
>> ...[000010d3][00211e8a][00211e8e] 8bec mov ebp,esp
>> ...[000010d5][00211e8a][00211e8e] 8b4508 mov eax,[ebp+08]
>> ...[000010d8][00211e86][000010d2] 50 push eax // Push P
>> ...[000010d9][00211e86][000010d2] 8b4d08 mov ecx,[ebp+08]
>> ...[000010dc][00211e82][000010d2] 51 push ecx // Push P
>> ...[000010dd][00211e7e][000010e2] e820feffff call 00000f02 // Call H
>> Infinitely Recursive Simulation Detected Simulation Stopped
>>
>> Software engineers with extremely high technical competence could
>> translate the above criterion measure into working code on the basis
>> of an the execution_trace list of Decoded_Line_Of_Code of the x86
>> emulated first seven instructions of P shown above. It is assumed
>> that P has been translated into x86 by the Microsoft C compiler, thus
>> having the C calling conventions.
>>
>> https://docs.microsoft.com/en-us/cpp/cpp/cdecl?view=msvc-170
>
> void Px(u32 x)
> {
> H(x, x);
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", H((u32)Px, (u32)Px));
> }
>
> ...[000013e8][00102357][00000000] 83c408 add esp,+08
> ...[000013eb][00102353][00000000] 50 push eax
> ...[000013ec][0010234f][00000427] 6827040000 push 00000427
> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
> Input_Halts = 0
> ...[000013f6][00102357][00000000] 83c408 add esp,+08
> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
> ...[000013fb][0010235b][00100000] 5d pop ebp
> ...[000013fc][0010235f][00000004] c3 ret
> Number of Instructions Executed(16120)
>
> It gets the answer wrong, i.e. input has not been decided correctly.
> QED.
>
> /Flibble
>
>

Every sufficiently competent software engineer can easily verify that
the complete and correct x86 emulation of the input to H(Px,Px) by H
would never reach the "ret" instruction of P because both H and P would
remain stuck in infinitely recursive emulation.

If H can determine that this is the case in a finite number of steps
then H could reject its input on this basis.

If you can't form a correct rebuttal in terms of the actual software
engineering of the *exact words specified above* then that would prove
that you are insufficiently technically competent on this point.

If you incorrectly paraphrase what I said and form a rebuttal to this
incorrect paraphrase then sufficiently technically competent software
engineers would know that you are trying to get away with the strawman
deception.

straw man
An intentionally misrepresented proposition that is set up because it is
easier to defeat than an opponent's real argument.
https://www.lexico.com/en/definition/straw_man

--
Copyright 2022 Pete Olcott

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

Re: Software engineers of extreme technical competence [ strawman deception]

<SLOdnVpUhsmw6i__nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=34698&group=comp.theory#34698

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 21 Jun 2022 20:58:05 -0500
Date: Tue, 21 Jun 2022 20:58:03 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Software engineers of extreme technical competence [ strawman
deception]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <t8sffd$r78$1@dont-email.me> <fErsK.5525$Me2.3759@fx47.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <fErsK.5525$Me2.3759@fx47.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <SLOdnVpUhsmw6i__nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 144
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Ey2ZaTpcb8bMRXAUqDB2w/ZZrlUEEUF6I++YhvdNL0yo/cJCOGGunM3QnSuLp+plTZb8aneeh6/ARQ2!q7Q24BfX3CGw5aBbK1SNT2yGrm1NffhpDy9Tn/cBZbZEeG0OF9xHi8AcCpgbqnK6/izKqow3IfjC
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 6982
 by: olcott - Wed, 22 Jun 2022 01:58 UTC

On 6/21/2022 5:30 PM, Richard Damon wrote:
> On 6/21/22 9:01 AM, olcott wrote:
>> #include <stdint.h>
>> typedef void (*ptr)();
>>
>> void P(ptr x)
>> {
>>    if (H(x, x))
>>      HERE: goto HERE;
>>    return;
>> }
>>
>> int main()
>> {
>>    Output("Input_Halts = ", H(P, P));
>> }
>>
>> _P()
>> [00001352](01) 55 push ebp
>> [00001353](02) 8bec mov ebp,esp
>> [00001355](03) 8b4508 mov eax,[ebp+08]
>> [00001358](01) 50 push eax              // push P
>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>> [0000135c](01) 51 push ecx              // push P
>> [0000135d](05) e840feffff call 000011a2 // call H
>> [00001362](03) 83c408 add esp,+08
>> [00001365](02) 85c0 test eax,eax
>> [00001367](02) 7402 jz 0000136b
>> [00001369](02) ebfe jmp 00001369
>> [0000136b](01) 5d pop ebp
>> [0000136c](01) c3 ret
>> Size in bytes:(0027) [0000136c]
>>
>> Every sufficiently competent software engineer can easily verify that
>> the complete and correct x86 emulation of the input to H(P,P) by H
>> would never reach the "ret" instruction of P.
>>
>>
>>
>>
>> #define   JMP 0xEB // Simplifed OpCode for all forms of JMP
>> #define  CALL 0xE8 // Simplifed OpCode for all forms of CALL
>> #define   JCC 0x7F // Simplifed OpCode for all forms of Jump on Condition
>> #define   RET 0xC3 // Simplifed OpCode for all forms of Return
>> #define  PUSH 0x68 // Simplifed OpCode for all forms of PUSH
>>
>> typedef struct Decoded
>> {
>>    u32 Address;
>>    u32 ESP;          // Current value of ESP
>>    u32 TOS;          // Current value of Top of Stack
>>    u32 NumBytes;
>>    u32 Simplified_Opcode;
>>    u32 Decode_Target;
>> } Decoded_Line_Of_Code;
>>
>> Software engineers with extremely high technical competence will be able
>> to verify that H correctly determines (in a finite number of steps) that
>> its complete and correct x86 emulation of its input would never reach
>> the "ret" instruction of P on this criterion measure basis:
>>
>> H knows its own machine address and on this basis:
>> (a) H recognizes that P is calling H with the same arguments that H was
>> called with at its machine address [0000135d]. The immecdiately
>> precdding pait of PUSH instructions
>>
>> (b) There are no instructions in P that could possibly escape this
>> otherwise infinitely recursive emulation.
>>
>
> And, what is your basis for THIS wording, the way you interpret it.
>
> There IS an instruction in the PROGRAM P (which is what halting deciders
> are supposed to be looking at), namely in the code for H that decides to
> abort (or are you talkinga about the H that doesn't abort and thus fails
> to answer?)
>
>> (c) H aborts its emulation of P before its call to H is invoked.
>
> And thus is WRONG.
>
>>
>>      machine   stack     stack     machine    assembly
>>      address   address   data      code       language
>>      ========  ========  ========  =========  =============
>> Begin Simulation   Execution Trace Stored at:211e9e
>> ...[000010d2][00211e8a][00211e8e] 55         push ebp
>> ...[000010d3][00211e8a][00211e8e] 8bec       mov ebp,esp
>> ...[000010d5][00211e8a][00211e8e] 8b4508     mov eax,[ebp+08]
>> ...[000010d8][00211e86][000010d2] 50         push eax      // Push P
>> ...[000010d9][00211e86][000010d2] 8b4d08     mov ecx,[ebp+08]
>> ...[000010dc][00211e82][000010d2] 51         push ecx      // Push P
>> ...[000010dd][00211e7e][000010e2] e820feffff call 00000f02 // Call H
>> Infinitely Recursive Simulation Detected Simulation Stopped
>>
>> Software engineers with extremely high technical competence could
>> translate the above criterion measure into working code on the basis
>> of an the execution_trace list of Decoded_Line_Of_Code of the x86
>> emulated first seven instructions of P shown above. It is assumed that
>> P has been translated into x86 by the Microsoft C compiler, thus
>> having the C calling conventions.
>>
>> https://docs.microsoft.com/en-us/cpp/cpp/cdecl?view=msvc-170
>>
>>
>
> Yes, you can code the above definition, and get the same broken decider.
>
> H is WRONG, because H(P,P) is SUPPOSED to tell us if P(P) will halt or
> not, but if H(P,P) returns 0, then P(P) will Halt, and thus H is wrong.
>
> If H(P,P) doesn't return an answer, it fails to be a decider, and thus
> also wrong.

Every sufficiently competent software engineer can easily verify that
the complete and correct x86 emulation of the input to H(P,P) by H would
never reach the "ret" instruction of P because both H and P would remain
stuck in infinitely recursive emulation.

If H can determine that this is the case in a finite number of steps
then H could reject its input on this basis.

If you can't form a correct rebuttal in terms of the actual software
engineering of the *exact words specified above* then that would prove
that you are insufficiently technically competent on this point.

If you incorrectly paraphrase what I said and form a rebuttal to this
incorrect paraphrase then sufficiently technically competent software
engineers would know that you are trying to get away with the strawman
deception.

straw man
An intentionally misrepresented proposition that is set up because it is
easier to defeat than an opponent's real argument.
https://www.lexico.com/en/definition/straw_man

--
Copyright 2022 Pete Olcott

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

Re: Software engineers of extreme technical competence [ strawman deception]

<%ivsK.2331$dh2.80@fx46.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=34701&group=comp.theory#34701

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx46.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.10.0
Subject: Re: Software engineers of extreme technical competence [ strawman
deception]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <t8sffd$r78$1@dont-email.me>
<20220621172410.00000972@reddwarf.jmc>
<SLOdnVtUhslI6y__nZ2dnUU7_8xh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <SLOdnVtUhslI6y__nZ2dnUU7_8xh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 186
Message-ID: <%ivsK.2331$dh2.80@fx46.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 21 Jun 2022 22:40:58 -0400
X-Received-Bytes: 8073
 by: Richard Damon - Wed, 22 Jun 2022 02:40 UTC

On 6/21/22 9:56 PM, olcott wrote:
> On 6/21/2022 11:24 AM, Mr Flibble wrote:
>> On Tue, 21 Jun 2022 08:01:31 -0500
>> olcott <polcott2@gmail.com> wrote:
>>
>>> #include <stdint.h>
>>> typedef void (*ptr)();
>>>
>>> void P(ptr x)
>>> {
>>>     if (H(x, x))
>>>       HERE: goto HERE;
>>>     return;
>>> }
>>>
>>> int main()
>>> {
>>>     Output("Input_Halts = ", H(P, P));
>>> }
>>>
>>> _P()
>>> [00001352](01) 55 push ebp
>>> [00001353](02) 8bec mov ebp,esp
>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>> [00001358](01) 50 push eax              // push P
>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>> [0000135c](01) 51 push ecx              // push P
>>> [0000135d](05) e840feffff call 000011a2 // call H
>>> [00001362](03) 83c408 add esp,+08
>>> [00001365](02) 85c0 test eax,eax
>>> [00001367](02) 7402 jz 0000136b
>>> [00001369](02) ebfe jmp 00001369
>>> [0000136b](01) 5d pop ebp
>>> [0000136c](01) c3 ret
>>> Size in bytes:(0027) [0000136c]
>>>
>>> Every sufficiently competent software engineer can easily verify that
>>> the complete and correct x86 emulation of the input to H(P,P) by H
>>> would never reach the "ret" instruction of P.
>>>
>>>
>>>
>>>
>>> #define   JMP 0xEB // Simplifed OpCode for all forms of JMP
>>> #define  CALL 0xE8 // Simplifed OpCode for all forms of CALL
>>> #define   JCC 0x7F // Simplifed OpCode for all forms of Jump on
>>> Condition #define   RET 0xC3 // Simplifed OpCode for all forms of
>>> Return #define  PUSH 0x68 // Simplifed OpCode for all forms of PUSH
>>>
>>> typedef struct Decoded
>>> {
>>>     u32 Address;
>>>     u32 ESP;          // Current value of ESP
>>>     u32 TOS;          // Current value of Top of Stack
>>>     u32 NumBytes;
>>>     u32 Simplified_Opcode;
>>>     u32 Decode_Target;
>>> } Decoded_Line_Of_Code;
>>>
>>> Software engineers with extremely high technical competence will be
>>> able to verify that H correctly determines (in a finite number of
>>> steps) that its complete and correct x86 emulation of its input would
>>> never reach the "ret" instruction of P on this criterion measure
>>> basis:
>>>
>>> H knows its own machine address and on this basis:
>>> (a) H recognizes that P is calling H with the same arguments that H
>>> was called with at its machine address [0000135d]. The immecdiately
>>> precdding pait of PUSH instructions
>>>
>>> (b) There are no instructions in P that could possibly escape this
>>> otherwise infinitely recursive emulation.
>>>
>>> (c) H aborts its emulation of P before its call to H is invoked.
>>>
>>>       machine   stack     stack     machine    assembly
>>>       address   address   data      code       language
>>>       ========  ========  ========  =========  =============
>>> Begin Simulation   Execution Trace Stored at:211e9e
>>> ...[000010d2][00211e8a][00211e8e] 55         push ebp
>>> ...[000010d3][00211e8a][00211e8e] 8bec       mov ebp,esp
>>> ...[000010d5][00211e8a][00211e8e] 8b4508     mov eax,[ebp+08]
>>> ...[000010d8][00211e86][000010d2] 50         push eax      // Push P
>>> ...[000010d9][00211e86][000010d2] 8b4d08     mov ecx,[ebp+08]
>>> ...[000010dc][00211e82][000010d2] 51         push ecx      // Push P
>>> ...[000010dd][00211e7e][000010e2] e820feffff call 00000f02 // Call H
>>> Infinitely Recursive Simulation Detected Simulation Stopped
>>>
>>> Software engineers with extremely high technical competence could
>>> translate the above criterion measure into working code on the basis
>>> of an the execution_trace list of Decoded_Line_Of_Code of the x86
>>> emulated first seven instructions of P shown above. It is assumed
>>> that P has been translated into x86 by the Microsoft C compiler, thus
>>> having the C calling conventions.
>>>
>>> https://docs.microsoft.com/en-us/cpp/cpp/cdecl?view=msvc-170
>> void Px(u32 x)
>> {
>>     H(x, x);
>>     return;
>> }
>>
>> int main()
>> {
>>     Output("Input_Halts = ", H((u32)Px, (u32)Px));
>> }
>>
>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>> ...[000013eb][00102353][00000000] 50              push eax
>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
>> Input_Halts = 0
>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>> ...[000013fc][0010235f][00000004] c3              ret
>> Number of Instructions Executed(16120)
>>
>> It gets the answer wrong, i.e. input has not been decided correctly.
>> QED.
>>
>> /Flibble
>>
>>
>
>
> Every sufficiently competent software engineer can easily verify that
> the complete and correct x86 emulation of the input to H(Px,Px) by H
> would never reach the "ret" instruction of P because both H and P would
> remain stuck in infinitely recursive emulation.

Well, if H does a complete and

>
> If H can determine that this is the case in a finite number of steps
> then H could reject its input on this basis.

*IF* which it can't.

Note, if H can stop its emulation, it isn't the H that would do the
complete and correct emulation, now is it?

So, it doesn't matter that this H can determine that some other "H" got
stuck, thats just its not quite a twin.

>
> If you can't form a correct rebuttal in terms of the actual software
> engineering of the *exact words specified above* then that would prove
> that you are insufficiently technically competent on this point.

YOU can't make a correct argument.

>
> If you incorrectly paraphrase what I said and form a rebuttal to this
> incorrect paraphrase then sufficiently technically competent software
> engineers would know that you are trying to get away with the strawman
> deception.

Since your whole arguement is based on an incorrect paraphrase of the
original problem, you are one to talk.

H(M,x) must accept its input if M(x) Halts, and Reject only if M(x)
never will Halt.

P(P) Halts if H(P,P) rejects it (returns 0) so H(P,P) rejecting is
incorrect.

DEFINITION.

IF you want to claim that H(P,P) doesn't refer to P(P), then your P is
defined wrong, since P needs to be asking H about P(P).

So. somewhere you are just lying that you are following the requirements
of the proof you are refuting.

I think the issue is you just don't understand about requireents.

>
> straw man
> An intentionally misrepresented proposition that is set up because it is
> easier to defeat than an opponent's real argument.
> https://www.lexico.com/en/definition/straw_man
>
>

Re: Software engineers of extreme technical competence [ strawman deception]

<ErvsK.300026$5fVf.88929@fx09.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=34703&group=comp.theory#34703

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!news.neodome.net!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx09.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.10.0
Subject: Re: Software engineers of extreme technical competence [ strawman
deception]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <t8sffd$r78$1@dont-email.me> <fErsK.5525$Me2.3759@fx47.iad>
<SLOdnVpUhsmw6i__nZ2dnUU7_8xh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <SLOdnVpUhsmw6i__nZ2dnUU7_8xh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 184
Message-ID: <ErvsK.300026$5fVf.88929@fx09.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 21 Jun 2022 22:50:12 -0400
X-Received-Bytes: 8365
 by: Richard Damon - Wed, 22 Jun 2022 02:50 UTC

On 6/21/22 9:58 PM, olcott wrote:
> On 6/21/2022 5:30 PM, Richard Damon wrote:
>> On 6/21/22 9:01 AM, olcott wrote:
>>> #include <stdint.h>
>>> typedef void (*ptr)();
>>>
>>> void P(ptr x)
>>> {
>>>    if (H(x, x))
>>>      HERE: goto HERE;
>>>    return;
>>> }
>>>
>>> int main()
>>> {
>>>    Output("Input_Halts = ", H(P, P));
>>> }
>>>
>>> _P()
>>> [00001352](01) 55 push ebp
>>> [00001353](02) 8bec mov ebp,esp
>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>> [00001358](01) 50 push eax              // push P
>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>> [0000135c](01) 51 push ecx              // push P
>>> [0000135d](05) e840feffff call 000011a2 // call H
>>> [00001362](03) 83c408 add esp,+08
>>> [00001365](02) 85c0 test eax,eax
>>> [00001367](02) 7402 jz 0000136b
>>> [00001369](02) ebfe jmp 00001369
>>> [0000136b](01) 5d pop ebp
>>> [0000136c](01) c3 ret
>>> Size in bytes:(0027) [0000136c]
>>>
>>> Every sufficiently competent software engineer can easily verify that
>>> the complete and correct x86 emulation of the input to H(P,P) by H
>>> would never reach the "ret" instruction of P.
>>>
>>>
>>>
>>>
>>> #define   JMP 0xEB // Simplifed OpCode for all forms of JMP
>>> #define  CALL 0xE8 // Simplifed OpCode for all forms of CALL
>>> #define   JCC 0x7F // Simplifed OpCode for all forms of Jump on
>>> Condition
>>> #define   RET 0xC3 // Simplifed OpCode for all forms of Return
>>> #define  PUSH 0x68 // Simplifed OpCode for all forms of PUSH
>>>
>>> typedef struct Decoded
>>> {
>>>    u32 Address;
>>>    u32 ESP;          // Current value of ESP
>>>    u32 TOS;          // Current value of Top of Stack
>>>    u32 NumBytes;
>>>    u32 Simplified_Opcode;
>>>    u32 Decode_Target;
>>> } Decoded_Line_Of_Code;
>>>
>>> Software engineers with extremely high technical competence will be able
>>> to verify that H correctly determines (in a finite number of steps) that
>>> its complete and correct x86 emulation of its input would never reach
>>> the "ret" instruction of P on this criterion measure basis:
>>>
>>> H knows its own machine address and on this basis:
>>> (a) H recognizes that P is calling H with the same arguments that H was
>>> called with at its machine address [0000135d]. The immecdiately
>>> precdding pait of PUSH instructions
>>>
>>> (b) There are no instructions in P that could possibly escape this
>>> otherwise infinitely recursive emulation.
>>>
>>
>> And, what is your basis for THIS wording, the way you interpret it.
>>
>> There IS an instruction in the PROGRAM P (which is what halting
>> deciders are supposed to be looking at), namely in the code for H that
>> decides to abort (or are you talkinga about the H that doesn't abort
>> and thus fails to answer?)
>>
>>> (c) H aborts its emulation of P before its call to H is invoked.
>>
>> And thus is WRONG.
>>
>>>
>>>      machine   stack     stack     machine    assembly
>>>      address   address   data      code       language
>>>      ========  ========  ========  =========  =============
>>> Begin Simulation   Execution Trace Stored at:211e9e
>>> ...[000010d2][00211e8a][00211e8e] 55         push ebp
>>> ...[000010d3][00211e8a][00211e8e] 8bec       mov ebp,esp
>>> ...[000010d5][00211e8a][00211e8e] 8b4508     mov eax,[ebp+08]
>>> ...[000010d8][00211e86][000010d2] 50         push eax      // Push P
>>> ...[000010d9][00211e86][000010d2] 8b4d08     mov ecx,[ebp+08]
>>> ...[000010dc][00211e82][000010d2] 51         push ecx      // Push P
>>> ...[000010dd][00211e7e][000010e2] e820feffff call 00000f02 // Call H
>>> Infinitely Recursive Simulation Detected Simulation Stopped
>>>
>>> Software engineers with extremely high technical competence could
>>> translate the above criterion measure into working code on the basis
>>> of an the execution_trace list of Decoded_Line_Of_Code of the x86
>>> emulated first seven instructions of P shown above. It is assumed
>>> that P has been translated into x86 by the Microsoft C compiler, thus
>>> having the C calling conventions.
>>>
>>> https://docs.microsoft.com/en-us/cpp/cpp/cdecl?view=msvc-170
>>>
>>>
>>
>> Yes, you can code the above definition, and get the same broken decider.
>>
>> H is WRONG, because H(P,P) is SUPPOSED to tell us if P(P) will halt or
>> not, but if H(P,P) returns 0, then P(P) will Halt, and thus H is wrong.
>>
>> If H(P,P) doesn't return an answer, it fails to be a decider, and thus
>> also wrong.
>
> Every sufficiently competent software engineer can easily verify that
> the complete and correct x86 emulation of the input to H(P,P) by H would
> never reach the "ret" instruction of P because both H and P would remain
> stuck in infinitely recursive emulation.

Yes *IF* H just does a complete and correct emulation of its input, the
P(P) will never return, but neither does H(P,P) so it can't answer. THis
is NOT the H you are claiming about, so it is just more red herring.

>
> If H can determine that this is the case in a finite number of steps
> then H could reject its input on this basis.

WHich you can't prove, since if H does reject the input, then the input
is Halting, and you can't actually validly prove something that isn't true.

>
> If you can't form a correct rebuttal in terms of the actual software
> engineering of the *exact words specified above* then that would prove
> that you are insufficiently technically competent on this point.

Since your *EXACT* words are nonsense, postulating an impossible machine
that both complete emulates a non-halting machine and also returning and
answer in finte time, you words refute themselves.

That prove that you are the technically incompetent one in this arguement.

Please explaim how H can do both an infinte number of steps of emulaton
and also return an answer after a finite number of steps?

That says that you have found a finite number bigger than an unbounded
number.

>
> If you incorrectly paraphrase what I said and form a rebuttal to this
> incorrect paraphrase then sufficiently technically competent software
> engineers would know that you are trying to get away with the strawman
> deception.

Well, since YOU started with the incorrect paraphrase, maybe you should
take your own advise.

The halting problem NEVER mentions that the test depends on what the
instance of the decider does, only what the machine the input represents.

>
> straw man
> An intentionally misrepresented proposition that is set up because it is
> easier to defeat than an opponent's real argument.
> https://www.lexico.com/en/definition/straw_man
>
>
>

Yep, you make a lot of scarecrows in your arguements, and then stuff
them with red herring.

Remember the definition:

H(M,x) must Accept its input if M(x) halts and Reject its input if M(x)
will never halt.

P needs to ask H about P(P) and do the opposite.

Since this isn't what you claim to do, and in fact claim that it CAN'T
be, you are just not working on the Halting Problem.

1
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor