Message-ID:

All Finagle Laws may be bypassed by learning the simple art of doing without thinking.

devel / comp.theory / Does everyone agree with this halt status decision?

// direct execution of x(y) derives equivalent
// behavior to the simulation of x(y)
u32 Simulate(ptr x, ptr y)
{ x(y);
return 1;
}

void Px(ptr x)
{ Simulate(x, x);
return;
}

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

_Simulate()
[000010b2](01) 55 push ebp
[000010b3](02) 8bec mov ebp,esp
[000010b5](03) 8b450c mov eax,[ebp+0c]
[000010b8](01) 50 push eax
[000010b9](03) ff5508 call dword [ebp+08]
[000010bc](03) 83c404 add esp,+04
[000010bf](05) b801000000 mov eax,00000001
[000010c4](01) 5d pop ebp
[000010c5](01) c3 ret
Size in bytes:(0020) [000010c5]

_Px()
[00001102](01) 55 push ebp
[00001103](02) 8bec mov ebp,esp
[00001105](03) 8b4508 mov eax,[ebp+08]
[00001108](01) 50 push eax
[00001109](03) 8b4d08 mov ecx,[ebp+08]
[0000110c](01) 51 push ecx
[0000110d](05) e8a0ffffff call 000010b2
[00001112](03) 83c408 add esp,+08
[00001115](01) 5d pop ebp
[00001116](01) c3 ret
Size in bytes:(0021) [00001116]

_main()
[00001122](01) 55 push ebp
[00001123](02) 8bec mov ebp,esp
[00001125](05) 6802110000 push 00001102
[0000112a](05) 6802110000 push 00001102
[0000112f](05) e85efdffff call 00000e92
[00001134](03) 83c408 add esp,+08
[00001137](01) 50 push eax
[00001138](05) 6863040000 push 00000463
[0000113d](05) e840f3ffff call 00000482
[00001142](03) 83c408 add esp,+08
[00001145](02) 33c0 xor eax,eax
[00001147](01) 5d pop ebp
[00001148](01) c3 ret
Size in bytes:(0039) [00001148]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00001122][00101c15][00000000] 55 push ebp
[00001123][00101c15][00000000] 8bec mov ebp,esp
[00001125][00101c11][00001102] 6802110000 push 00001102
[0000112a][00101c0d][00001102] 6802110000 push 00001102
[0000112f][00101c09][00001134] e85efdffff call 00000e92
Address_of_H:e92

H: Begin Simulation Execution Trace Stored at:111cc1
Address_of_H:e92
[00001102][00111cad][00111cb1] 55 push ebp
[00001103][00111cad][00111cb1] 8bec mov ebp,esp
[00001105][00111cad][00111cb1] 8b4508 mov eax,[ebp+08]
[00001108][00111ca9][00001102] 50 push eax
[00001109][00111ca9][00001102] 8b4d08 mov ecx,[ebp+08]
[0000110c][00111ca5][00001102] 51 push ecx
[0000110d][00111ca1][00001112] e8a0ffffff call 000010b2
[000010b2][00111c9d][00111cad] 55 push ebp
[000010b3][00111c9d][00111cad] 8bec mov ebp,esp
[000010b5][00111c9d][00111cad] 8b450c mov eax,[ebp+0c]
[000010b8][00111c99][00001102] 50 push eax
Calling:_Px()
Decode_Control_Flow_Instruction([00000008][00111c9d][00001102])
[000010b9][00111c95][000010bc] ff5508 call dword [ebp+08]
[00001102][00111c91][00111c9d] 55 push ebp
[00001103][00111c91][00111c9d] 8bec mov ebp,esp
[00001105][00111c91][00111c9d] 8b4508 mov eax,[ebp+08]
[00001108][00111c8d][00001102] 50 push eax
[00001109][00111c8d][00001102] 8b4d08 mov ecx,[ebp+08]
[0000110c][00111c89][00001102] 51 push ecx
[0000110d][00111c85][00001112] e8a0ffffff call 000010b2
H: Infinite Recursion Detected Simulation Stopped

[00001134][00101c15][00000000] 83c408 add esp,+08
[00001137][00101c11][00000000] 50 push eax
[00001138][00101c0d][00000463] 6863040000 push 00000463
[0000113d][00101c0d][00000463] e840f3ffff call 00000482
Input_Halts = 0
[00001142][00101c15][00000000] 83c408 add esp,+08
[00001145][00101c15][00000000] 33c0 xor eax,eax
[00001147][00101c19][00000018] 5d pop ebp
[00001148][00101c1d][00000000] c3 ret
Number of Instructions Executed(2195) == 33 Pages

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

On Tue, 30 Aug 2022 10:04:36 -0500
olcott <polcott2@gmail.com> wrote:

> // direct execution of x(y) derives equivalent
> // behavior to the simulation of x(y)
> u32 Simulate(ptr x, ptr y)
> {
> x(y);
> return 1;
> }
>
> void Px(ptr x)
> {
> Simulate(x, x);
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", H(Px, Px));
> }
>
> _Simulate()
> [000010b2](01) 55 push ebp
> [000010b3](02) 8bec mov ebp,esp
> [000010b5](03) 8b450c mov eax,[ebp+0c]
> [000010b8](01) 50 push eax
> [000010b9](03) ff5508 call dword [ebp+08]
> [000010bc](03) 83c404 add esp,+04
> [000010bf](05) b801000000 mov eax,00000001
> [000010c4](01) 5d pop ebp
> [000010c5](01) c3 ret
> Size in bytes:(0020) [000010c5]
>
> _Px()
> [00001102](01) 55 push ebp
> [00001103](02) 8bec mov ebp,esp
> [00001105](03) 8b4508 mov eax,[ebp+08]
> [00001108](01) 50 push eax
> [00001109](03) 8b4d08 mov ecx,[ebp+08]
> [0000110c](01) 51 push ecx
> [0000110d](05) e8a0ffffff call 000010b2
> [00001112](03) 83c408 add esp,+08
> [00001115](01) 5d pop ebp
> [00001116](01) c3 ret
> Size in bytes:(0021) [00001116]
>
> _main()
> [00001122](01) 55 push ebp
> [00001123](02) 8bec mov ebp,esp
> [00001125](05) 6802110000 push 00001102
> [0000112a](05) 6802110000 push 00001102
> [0000112f](05) e85efdffff call 00000e92
> [00001134](03) 83c408 add esp,+08
> [00001137](01) 50 push eax
> [00001138](05) 6863040000 push 00000463
> [0000113d](05) e840f3ffff call 00000482
> [00001142](03) 83c408 add esp,+08
> [00001145](02) 33c0 xor eax,eax
> [00001147](01) 5d pop ebp
> [00001148](01) c3 ret
> Size in bytes:(0039) [00001148]
>
> machine stack stack machine assembly
> address address data code language
> ======== ======== ======== ========= =============
> [00001122][00101c15][00000000] 55 push ebp
> [00001123][00101c15][00000000] 8bec mov ebp,esp
> [00001125][00101c11][00001102] 6802110000 push 00001102
> [0000112a][00101c0d][00001102] 6802110000 push 00001102
> [0000112f][00101c09][00001134] e85efdffff call 00000e92
> Address_of_H:e92
>
> H: Begin Simulation Execution Trace Stored at:111cc1
> Address_of_H:e92
> [00001102][00111cad][00111cb1] 55 push ebp
> [00001103][00111cad][00111cb1] 8bec mov ebp,esp
> [00001105][00111cad][00111cb1] 8b4508 mov eax,[ebp+08]
> [00001108][00111ca9][00001102] 50 push eax
> [00001109][00111ca9][00001102] 8b4d08 mov ecx,[ebp+08]
> [0000110c][00111ca5][00001102] 51 push ecx
> [0000110d][00111ca1][00001112] e8a0ffffff call 000010b2
> [000010b2][00111c9d][00111cad] 55 push ebp
> [000010b3][00111c9d][00111cad] 8bec mov ebp,esp
> [000010b5][00111c9d][00111cad] 8b450c mov eax,[ebp+0c]
> [000010b8][00111c99][00001102] 50 push eax
> Calling:_Px()
> Decode_Control_Flow_Instruction([00000008][00111c9d][00001102])
> [000010b9][00111c95][000010bc] ff5508 call dword [ebp+08]
> [00001102][00111c91][00111c9d] 55 push ebp
> [00001103][00111c91][00111c9d] 8bec mov ebp,esp
> [00001105][00111c91][00111c9d] 8b4508 mov eax,[ebp+08]
> [00001108][00111c8d][00001102] 50 push eax
> [00001109][00111c8d][00001102] 8b4d08 mov ecx,[ebp+08]
> [0000110c][00111c89][00001102] 51 push ecx
> [0000110d][00111c85][00001112] e8a0ffffff call 000010b2
> H: Infinite Recursion Detected Simulation Stopped
>
> [00001134][00101c15][00000000] 83c408 add esp,+08
> [00001137][00101c11][00000000] 50 push eax
> [00001138][00101c0d][00000463] 6863040000 push 00000463
> [0000113d][00101c0d][00000463] e840f3ffff call 00000482
> Input_Halts = 0
> [00001142][00101c15][00000000] 83c408 add esp,+08
> [00001145][00101c15][00000000] 33c0 xor eax,eax
> [00001147][00101c19][00000018] 5d pop ebp
> [00001148][00101c1d][00000000] c3 ret
> Number of Instructions Executed(2195) == 33 Pages
Px doesn't call Simulate, Px calls H. You have made the same error
repeatedly.

/Flibble

On 8/30/2022 10:08 AM, Mr Flibble wrote:
> On Tue, 30 Aug 2022 10:04:36 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> // direct execution of x(y) derives equivalent
>> // behavior to the simulation of x(y)
>> u32 Simulate(ptr x, ptr y)
>> {
>> x(y);
>> return 1;
>> }
>>
>> void Px(ptr x)
>> {
>> Simulate(x, x);
>> return;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H(Px, Px));
>> }
>>
>> _Simulate()
>> [000010b2](01) 55 push ebp
>> [000010b3](02) 8bec mov ebp,esp
>> [000010b5](03) 8b450c mov eax,[ebp+0c]
>> [000010b8](01) 50 push eax
>> [000010b9](03) ff5508 call dword [ebp+08]
>> [000010bc](03) 83c404 add esp,+04
>> [000010bf](05) b801000000 mov eax,00000001
>> [000010c4](01) 5d pop ebp
>> [000010c5](01) c3 ret
>> Size in bytes:(0020) [000010c5]
>>
>> _Px()
>> [00001102](01) 55 push ebp
>> [00001103](02) 8bec mov ebp,esp
>> [00001105](03) 8b4508 mov eax,[ebp+08]
>> [00001108](01) 50 push eax
>> [00001109](03) 8b4d08 mov ecx,[ebp+08]
>> [0000110c](01) 51 push ecx
>> [0000110d](05) e8a0ffffff call 000010b2
>> [00001112](03) 83c408 add esp,+08
>> [00001115](01) 5d pop ebp
>> [00001116](01) c3 ret
>> Size in bytes:(0021) [00001116]
>>
>> _main()
>> [00001122](01) 55 push ebp
>> [00001123](02) 8bec mov ebp,esp
>> [00001125](05) 6802110000 push 00001102
>> [0000112a](05) 6802110000 push 00001102
>> [0000112f](05) e85efdffff call 00000e92
>> [00001134](03) 83c408 add esp,+08
>> [00001137](01) 50 push eax
>> [00001138](05) 6863040000 push 00000463
>> [0000113d](05) e840f3ffff call 00000482
>> [00001142](03) 83c408 add esp,+08
>> [00001145](02) 33c0 xor eax,eax
>> [00001147](01) 5d pop ebp
>> [00001148](01) c3 ret
>> Size in bytes:(0039) [00001148]
>>
>> machine stack stack machine assembly
>> address address data code language
>> ======== ======== ======== ========= =============
>> [00001122][00101c15][00000000] 55 push ebp
>> [00001123][00101c15][00000000] 8bec mov ebp,esp
>> [00001125][00101c11][00001102] 6802110000 push 00001102
>> [0000112a][00101c0d][00001102] 6802110000 push 00001102
>> [0000112f][00101c09][00001134] e85efdffff call 00000e92
>> Address_of_H:e92
>>
>> H: Begin Simulation Execution Trace Stored at:111cc1
>> Address_of_H:e92
>> [00001102][00111cad][00111cb1] 55 push ebp
>> [00001103][00111cad][00111cb1] 8bec mov ebp,esp
>> [00001105][00111cad][00111cb1] 8b4508 mov eax,[ebp+08]
>> [00001108][00111ca9][00001102] 50 push eax
>> [00001109][00111ca9][00001102] 8b4d08 mov ecx,[ebp+08]
>> [0000110c][00111ca5][00001102] 51 push ecx
>> [0000110d][00111ca1][00001112] e8a0ffffff call 000010b2
>> [000010b2][00111c9d][00111cad] 55 push ebp
>> [000010b3][00111c9d][00111cad] 8bec mov ebp,esp
>> [000010b5][00111c9d][00111cad] 8b450c mov eax,[ebp+0c]
>> [000010b8][00111c99][00001102] 50 push eax
>> Calling:_Px()
>> Decode_Control_Flow_Instruction([00000008][00111c9d][00001102])
>> [000010b9][00111c95][000010bc] ff5508 call dword [ebp+08]
>> [00001102][00111c91][00111c9d] 55 push ebp
>> [00001103][00111c91][00111c9d] 8bec mov ebp,esp
>> [00001105][00111c91][00111c9d] 8b4508 mov eax,[ebp+08]
>> [00001108][00111c8d][00001102] 50 push eax
>> [00001109][00111c8d][00001102] 8b4d08 mov ecx,[ebp+08]
>> [0000110c][00111c89][00001102] 51 push ecx
>> [0000110d][00111c85][00001112] e8a0ffffff call 000010b2
>> H: Infinite Recursion Detected Simulation Stopped
>>
>> [00001134][00101c15][00000000] 83c408 add esp,+08
>> [00001137][00101c11][00000000] 50 push eax
>> [00001138][00101c0d][00000463] 6863040000 push 00000463
>> [0000113d][00101c0d][00000463] e840f3ffff call 00000482
>> Input_Halts = 0
>> [00001142][00101c15][00000000] 83c408 add esp,+08
>> [00001145][00101c15][00000000] 33c0 xor eax,eax
>> [00001147][00101c19][00000018] 5d pop ebp
>> [00001148][00101c1d][00000000] c3 ret
>> Number of Instructions Executed(2195) == 33 Pages
>
> Px doesn't call Simulate, Px calls H. You have made the same error
> repeatedly.
>
> /Flibble
>

Your Px does not call Simulate, mine does.
Call my Px Pz if this helps avoid the confusion.

--
Copyright 2022 Pete Olcott

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

On Tue, 30 Aug 2022 10:13:52 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/30/2022 10:08 AM, Mr Flibble wrote:
> > On Tue, 30 Aug 2022 10:04:36 -0500
> > olcott <polcott2@gmail.com> wrote:
> >
> >> // direct execution of x(y) derives equivalent
> >> // behavior to the simulation of x(y)
> >> u32 Simulate(ptr x, ptr y)
> >> {
> >> x(y);
> >> return 1;
> >> }
> >>
> >> void Px(ptr x)
> >> {
> >> Simulate(x, x);
> >> return;
> >> }
> >>
> >> int main()
> >> {
> >> Output("Input_Halts = ", H(Px, Px));
> >> }
> >>
> >> _Simulate()
> >> [000010b2](01) 55 push ebp
> >> [000010b3](02) 8bec mov ebp,esp
> >> [000010b5](03) 8b450c mov eax,[ebp+0c]
> >> [000010b8](01) 50 push eax
> >> [000010b9](03) ff5508 call dword [ebp+08]
> >> [000010bc](03) 83c404 add esp,+04
> >> [000010bf](05) b801000000 mov eax,00000001
> >> [000010c4](01) 5d pop ebp
> >> [000010c5](01) c3 ret
> >> Size in bytes:(0020) [000010c5]
> >>
> >> _Px()
> >> [00001102](01) 55 push ebp
> >> [00001103](02) 8bec mov ebp,esp
> >> [00001105](03) 8b4508 mov eax,[ebp+08]
> >> [00001108](01) 50 push eax
> >> [00001109](03) 8b4d08 mov ecx,[ebp+08]
> >> [0000110c](01) 51 push ecx
> >> [0000110d](05) e8a0ffffff call 000010b2
> >> [00001112](03) 83c408 add esp,+08
> >> [00001115](01) 5d pop ebp
> >> [00001116](01) c3 ret
> >> Size in bytes:(0021) [00001116]
> >>
> >> _main()
> >> [00001122](01) 55 push ebp
> >> [00001123](02) 8bec mov ebp,esp
> >> [00001125](05) 6802110000 push 00001102
> >> [0000112a](05) 6802110000 push 00001102
> >> [0000112f](05) e85efdffff call 00000e92
> >> [00001134](03) 83c408 add esp,+08
> >> [00001137](01) 50 push eax
> >> [00001138](05) 6863040000 push 00000463
> >> [0000113d](05) e840f3ffff call 00000482
> >> [00001142](03) 83c408 add esp,+08
> >> [00001145](02) 33c0 xor eax,eax
> >> [00001147](01) 5d pop ebp
> >> [00001148](01) c3 ret
> >> Size in bytes:(0039) [00001148]
> >>
> >> machine stack stack machine assembly
> >> address address data code language
> >> ======== ======== ======== ========= =============
> >> [00001122][00101c15][00000000] 55 push ebp
> >> [00001123][00101c15][00000000] 8bec mov ebp,esp
> >> [00001125][00101c11][00001102] 6802110000 push 00001102
> >> [0000112a][00101c0d][00001102] 6802110000 push 00001102
> >> [0000112f][00101c09][00001134] e85efdffff call 00000e92
> >> Address_of_H:e92
> >>
> >> H: Begin Simulation Execution Trace Stored at:111cc1
> >> Address_of_H:e92
> >> [00001102][00111cad][00111cb1] 55 push ebp
> >> [00001103][00111cad][00111cb1] 8bec mov ebp,esp
> >> [00001105][00111cad][00111cb1] 8b4508 mov eax,[ebp+08]
> >> [00001108][00111ca9][00001102] 50 push eax
> >> [00001109][00111ca9][00001102] 8b4d08 mov ecx,[ebp+08]
> >> [0000110c][00111ca5][00001102] 51 push ecx
> >> [0000110d][00111ca1][00001112] e8a0ffffff call 000010b2
> >> [000010b2][00111c9d][00111cad] 55 push ebp
> >> [000010b3][00111c9d][00111cad] 8bec mov ebp,esp
> >> [000010b5][00111c9d][00111cad] 8b450c mov eax,[ebp+0c]
> >> [000010b8][00111c99][00001102] 50 push eax
> >> Calling:_Px()
> >> Decode_Control_Flow_Instruction([00000008][00111c9d][00001102])
> >> [000010b9][00111c95][000010bc] ff5508 call dword [ebp+08]
> >> [00001102][00111c91][00111c9d] 55 push ebp
> >> [00001103][00111c91][00111c9d] 8bec mov ebp,esp
> >> [00001105][00111c91][00111c9d] 8b4508 mov eax,[ebp+08]
> >> [00001108][00111c8d][00001102] 50 push eax
> >> [00001109][00111c8d][00001102] 8b4d08 mov ecx,[ebp+08]
> >> [0000110c][00111c89][00001102] 51 push ecx
> >> [0000110d][00111c85][00001112] e8a0ffffff call 000010b2
> >> H: Infinite Recursion Detected Simulation Stopped
> >>
> >> [00001134][00101c15][00000000] 83c408 add esp,+08
> >> [00001137][00101c11][00000000] 50 push eax
> >> [00001138][00101c0d][00000463] 6863040000 push 00000463
> >> [0000113d][00101c0d][00000463] e840f3ffff call 00000482
> >> Input_Halts = 0
> >> [00001142][00101c15][00000000] 83c408 add esp,+08
> >> [00001145][00101c15][00000000] 33c0 xor eax,eax
> >> [00001147][00101c19][00000018] 5d pop ebp
> >> [00001148][00101c1d][00000000] c3 ret
> >> Number of Instructions Executed(2195) == 33 Pages
> >
> > Px doesn't call Simulate, Px calls H. You have made the same error
> > repeatedly.
> >
> > /Flibble
> >
>
> Your Px does not call Simulate, mine does.
> Call my Px Pz if this helps avoid the confusion.

Pz doesn't call Simulate, Pz calls H. You have made the same error
repeatedly.

/Flibble

Re: Does everyone agree with this halt status decision?

<O66dnYVHPYzpsJP-nZ2dnZfqlJxh4p2d@giganews.com>

copy mid

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

copy link Newsgroups: comp.theory

Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!border-1.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-2.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 30 Aug 2022 15:32:03 +0000
Date: Tue, 30 Aug 2022 10:32:03 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.2.0
Subject: Re: Does everyone agree with this halt status decision?
Content-Language: en-US
Newsgroups: comp.theory
References: <tel8u5$1gels$1@dont-email.me>
<20220830160852.00003019@reddwarf.jmc.corp>
<EIedneB4tNystJP-nZ2dnZfqlJxh4p2d@giganews.com>
<20220830162355.00003a79@reddwarf.jmc.corp>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220830162355.00003a79@reddwarf.jmc.corp>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <O66dnYVHPYzpsJP-nZ2dnZfqlJxh4p2d@giganews.com>
Lines: 140
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-K197hDOux9Y67OcqS84h7PwP8lqIia5PjFMXVKTOROEjCb1STob6eAIltIJJpUFTYs3F30FvkPgCH1D!RZddKaWfIJRzUxNjhT481rCh28kjjia4AJAOpW0iWzH4VRP51iCY0ylQQAu5cfU3snFte3h23gw=
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-Received-Bytes: 6890

by: olcott - Tue, 30 Aug 2022 15:32 UTC

On 8/30/2022 10:23 AM, Mr Flibble wrote:
> On Tue, 30 Aug 2022 10:13:52 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/30/2022 10:08 AM, Mr Flibble wrote:
>>> On Tue, 30 Aug 2022 10:04:36 -0500
>>> olcott <polcott2@gmail.com> wrote:
>>>
>>>> // direct execution of x(y) derives equivalent
>>>> // behavior to the simulation of x(y)
>>>> u32 Simulate(ptr x, ptr y)
>>>> {
>>>> x(y);
>>>> return 1;
>>>> }
>>>>
>>>> void Px(ptr x)
>>>> {
>>>> Simulate(x, x);
>>>> return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", H(Px, Px));
>>>> }
>>>>
>>>> _Simulate()
>>>> [000010b2](01) 55 push ebp
>>>> [000010b3](02) 8bec mov ebp,esp
>>>> [000010b5](03) 8b450c mov eax,[ebp+0c]
>>>> [000010b8](01) 50 push eax
>>>> [000010b9](03) ff5508 call dword [ebp+08]
>>>> [000010bc](03) 83c404 add esp,+04
>>>> [000010bf](05) b801000000 mov eax,00000001
>>>> [000010c4](01) 5d pop ebp
>>>> [000010c5](01) c3 ret
>>>> Size in bytes:(0020) [000010c5]
>>>>
>>>> _Px()
>>>> [00001102](01) 55 push ebp
>>>> [00001103](02) 8bec mov ebp,esp
>>>> [00001105](03) 8b4508 mov eax,[ebp+08]
>>>> [00001108](01) 50 push eax
>>>> [00001109](03) 8b4d08 mov ecx,[ebp+08]
>>>> [0000110c](01) 51 push ecx
>>>> [0000110d](05) e8a0ffffff call 000010b2
>>>> [00001112](03) 83c408 add esp,+08
>>>> [00001115](01) 5d pop ebp
>>>> [00001116](01) c3 ret
>>>> Size in bytes:(0021) [00001116]
>>>>
>>>> _main()
>>>> [00001122](01) 55 push ebp
>>>> [00001123](02) 8bec mov ebp,esp
>>>> [00001125](05) 6802110000 push 00001102
>>>> [0000112a](05) 6802110000 push 00001102
>>>> [0000112f](05) e85efdffff call 00000e92
>>>> [00001134](03) 83c408 add esp,+08
>>>> [00001137](01) 50 push eax
>>>> [00001138](05) 6863040000 push 00000463
>>>> [0000113d](05) e840f3ffff call 00000482
>>>> [00001142](03) 83c408 add esp,+08
>>>> [00001145](02) 33c0 xor eax,eax
>>>> [00001147](01) 5d pop ebp
>>>> [00001148](01) c3 ret
>>>> Size in bytes:(0039) [00001148]
>>>>
>>>> machine stack stack machine assembly
>>>> address address data code language
>>>> ======== ======== ======== ========= =============
>>>> [00001122][00101c15][00000000] 55 push ebp
>>>> [00001123][00101c15][00000000] 8bec mov ebp,esp
>>>> [00001125][00101c11][00001102] 6802110000 push 00001102
>>>> [0000112a][00101c0d][00001102] 6802110000 push 00001102
>>>> [0000112f][00101c09][00001134] e85efdffff call 00000e92
>>>> Address_of_H:e92
>>>>
>>>> H: Begin Simulation Execution Trace Stored at:111cc1
>>>> Address_of_H:e92
>>>> [00001102][00111cad][00111cb1] 55 push ebp
>>>> [00001103][00111cad][00111cb1] 8bec mov ebp,esp
>>>> [00001105][00111cad][00111cb1] 8b4508 mov eax,[ebp+08]
>>>> [00001108][00111ca9][00001102] 50 push eax
>>>> [00001109][00111ca9][00001102] 8b4d08 mov ecx,[ebp+08]
>>>> [0000110c][00111ca5][00001102] 51 push ecx
>>>> [0000110d][00111ca1][00001112] e8a0ffffff call 000010b2
>>>> [000010b2][00111c9d][00111cad] 55 push ebp
>>>> [000010b3][00111c9d][00111cad] 8bec mov ebp,esp
>>>> [000010b5][00111c9d][00111cad] 8b450c mov eax,[ebp+0c]
>>>> [000010b8][00111c99][00001102] 50 push eax
>>>> Calling:_Px()
>>>> Decode_Control_Flow_Instruction([00000008][00111c9d][00001102])
>>>> [000010b9][00111c95][000010bc] ff5508 call dword [ebp+08]
>>>> [00001102][00111c91][00111c9d] 55 push ebp
>>>> [00001103][00111c91][00111c9d] 8bec mov ebp,esp
>>>> [00001105][00111c91][00111c9d] 8b4508 mov eax,[ebp+08]
>>>> [00001108][00111c8d][00001102] 50 push eax
>>>> [00001109][00111c8d][00001102] 8b4d08 mov ecx,[ebp+08]
>>>> [0000110c][00111c89][00001102] 51 push ecx
>>>> [0000110d][00111c85][00001112] e8a0ffffff call 000010b2
>>>> H: Infinite Recursion Detected Simulation Stopped
>>>>
>>>> [00001134][00101c15][00000000] 83c408 add esp,+08
>>>> [00001137][00101c11][00000000] 50 push eax
>>>> [00001138][00101c0d][00000463] 6863040000 push 00000463
>>>> [0000113d][00101c0d][00000463] e840f3ffff call 00000482
>>>> Input_Halts = 0
>>>> [00001142][00101c15][00000000] 83c408 add esp,+08
>>>> [00001145][00101c15][00000000] 33c0 xor eax,eax
>>>> [00001147][00101c19][00000018] 5d pop ebp
>>>> [00001148][00101c1d][00000000] c3 ret
>>>> Number of Instructions Executed(2195) == 33 Pages
>>>
>>> Px doesn't call Simulate, Px calls H. You have made the same error
>>> repeatedly.
>>>
>>> /Flibble
>>>
>>
>> Your Px does not call Simulate, mine does.
>> Call my Px Pz if this helps avoid the confusion.
>
> Pz doesn't call Simulate, Pz calls H. You have made the same error
> repeatedly.
>
> /Flibble
>

What is your basis for saying that?

--
Copyright 2022 Pete Olcott

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

On Tue, 30 Aug 2022 10:32:03 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/30/2022 10:23 AM, Mr Flibble wrote:
> > On Tue, 30 Aug 2022 10:13:52 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 8/30/2022 10:08 AM, Mr Flibble wrote:
> >>> On Tue, 30 Aug 2022 10:04:36 -0500
> >>> olcott <polcott2@gmail.com> wrote:
> >>>
> >>>> // direct execution of x(y) derives equivalent
> >>>> // behavior to the simulation of x(y)
> >>>> u32 Simulate(ptr x, ptr y)
> >>>> {
> >>>> x(y);
> >>>> return 1;
> >>>> }
> >>>>
> >>>> void Px(ptr x)
> >>>> {
> >>>> Simulate(x, x);
> >>>> return;
> >>>> }
> >>>>
> >>>> int main()
> >>>> {
> >>>> Output("Input_Halts = ", H(Px, Px));
> >>>> }
> >>>>
> >>>> _Simulate()
> >>>> [000010b2](01) 55 push ebp
> >>>> [000010b3](02) 8bec mov ebp,esp
> >>>> [000010b5](03) 8b450c mov eax,[ebp+0c]
> >>>> [000010b8](01) 50 push eax
> >>>> [000010b9](03) ff5508 call dword [ebp+08]
> >>>> [000010bc](03) 83c404 add esp,+04
> >>>> [000010bf](05) b801000000 mov eax,00000001
> >>>> [000010c4](01) 5d pop ebp
> >>>> [000010c5](01) c3 ret
> >>>> Size in bytes:(0020) [000010c5]
> >>>>
> >>>> _Px()
> >>>> [00001102](01) 55 push ebp
> >>>> [00001103](02) 8bec mov ebp,esp
> >>>> [00001105](03) 8b4508 mov eax,[ebp+08]
> >>>> [00001108](01) 50 push eax
> >>>> [00001109](03) 8b4d08 mov ecx,[ebp+08]
> >>>> [0000110c](01) 51 push ecx
> >>>> [0000110d](05) e8a0ffffff call 000010b2
> >>>> [00001112](03) 83c408 add esp,+08
> >>>> [00001115](01) 5d pop ebp
> >>>> [00001116](01) c3 ret
> >>>> Size in bytes:(0021) [00001116]
> >>>>
> >>>> _main()
> >>>> [00001122](01) 55 push ebp
> >>>> [00001123](02) 8bec mov ebp,esp
> >>>> [00001125](05) 6802110000 push 00001102
> >>>> [0000112a](05) 6802110000 push 00001102
> >>>> [0000112f](05) e85efdffff call 00000e92
> >>>> [00001134](03) 83c408 add esp,+08
> >>>> [00001137](01) 50 push eax
> >>>> [00001138](05) 6863040000 push 00000463
> >>>> [0000113d](05) e840f3ffff call 00000482
> >>>> [00001142](03) 83c408 add esp,+08
> >>>> [00001145](02) 33c0 xor eax,eax
> >>>> [00001147](01) 5d pop ebp
> >>>> [00001148](01) c3 ret
> >>>> Size in bytes:(0039) [00001148]
> >>>>
> >>>> machine stack stack machine assembly
> >>>> address address data code language
> >>>> ======== ======== ======== ========= =============
> >>>> [00001122][00101c15][00000000] 55 push ebp
> >>>> [00001123][00101c15][00000000] 8bec mov ebp,esp
> >>>> [00001125][00101c11][00001102] 6802110000 push 00001102
> >>>> [0000112a][00101c0d][00001102] 6802110000 push 00001102
> >>>> [0000112f][00101c09][00001134] e85efdffff call 00000e92
> >>>> Address_of_H:e92
> >>>>
> >>>> H: Begin Simulation Execution Trace Stored at:111cc1
> >>>> Address_of_H:e92
> >>>> [00001102][00111cad][00111cb1] 55 push ebp
> >>>> [00001103][00111cad][00111cb1] 8bec mov ebp,esp
> >>>> [00001105][00111cad][00111cb1] 8b4508 mov eax,[ebp+08]
> >>>> [00001108][00111ca9][00001102] 50 push eax
> >>>> [00001109][00111ca9][00001102] 8b4d08 mov ecx,[ebp+08]
> >>>> [0000110c][00111ca5][00001102] 51 push ecx
> >>>> [0000110d][00111ca1][00001112] e8a0ffffff call 000010b2
> >>>> [000010b2][00111c9d][00111cad] 55 push ebp
> >>>> [000010b3][00111c9d][00111cad] 8bec mov ebp,esp
> >>>> [000010b5][00111c9d][00111cad] 8b450c mov eax,[ebp+0c]
> >>>> [000010b8][00111c99][00001102] 50 push eax
> >>>> Calling:_Px()
> >>>> Decode_Control_Flow_Instruction([00000008][00111c9d][00001102])
> >>>> [000010b9][00111c95][000010bc] ff5508 call dword [ebp+08]
> >>>> [00001102][00111c91][00111c9d] 55 push ebp
> >>>> [00001103][00111c91][00111c9d] 8bec mov ebp,esp
> >>>> [00001105][00111c91][00111c9d] 8b4508 mov eax,[ebp+08]
> >>>> [00001108][00111c8d][00001102] 50 push eax
> >>>> [00001109][00111c8d][00001102] 8b4d08 mov ecx,[ebp+08]
> >>>> [0000110c][00111c89][00001102] 51 push ecx
> >>>> [0000110d][00111c85][00001112] e8a0ffffff call 000010b2
> >>>> H: Infinite Recursion Detected Simulation Stopped
> >>>>
> >>>> [00001134][00101c15][00000000] 83c408 add esp,+08
> >>>> [00001137][00101c11][00000000] 50 push eax
> >>>> [00001138][00101c0d][00000463] 6863040000 push 00000463
> >>>> [0000113d][00101c0d][00000463] e840f3ffff call 00000482
> >>>> Input_Halts = 0
> >>>> [00001142][00101c15][00000000] 83c408 add esp,+08
> >>>> [00001145][00101c15][00000000] 33c0 xor eax,eax
> >>>> [00001147][00101c19][00000018] 5d pop ebp
> >>>> [00001148][00101c1d][00000000] c3 ret
> >>>> Number of Instructions Executed(2195) == 33 Pages
> >>>
> >>> Px doesn't call Simulate, Px calls H. You have made the same
> >>> error repeatedly.
> >>>
> >>> /Flibble
> >>>
> >>
> >> Your Px does not call Simulate, mine does.
> >> Call my Px Pz if this helps avoid the confusion.
> >
> > Pz doesn't call Simulate, Pz calls H. You have made the same error
> > repeatedly.
> >
> > /Flibble
> >
>
> What is your basis for saying that?

My basis for saying that is an observation that you are attempting to
build some convoluted strawman whereby you can claim equivalence
between H and Simulate so you can then erroneously claim that all
simulating halt deciders are recursive and cannot return a value to
their callers from within the simulation.

/Flibble

On 8/30/2022 12:00 PM, Mr Flibble wrote:
> On Tue, 30 Aug 2022 10:32:03 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/30/2022 10:23 AM, Mr Flibble wrote:
>>> On Tue, 30 Aug 2022 10:13:52 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 8/30/2022 10:08 AM, Mr Flibble wrote:
>>>>> On Tue, 30 Aug 2022 10:04:36 -0500
>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>
>>>>>> // direct execution of x(y) derives equivalent
>>>>>> // behavior to the simulation of x(y)
>>>>>> u32 Simulate(ptr x, ptr y)
>>>>>> {
>>>>>> x(y);
>>>>>> return 1;
>>>>>> }
>>>>>>
>>>>>> void Px(ptr x)
>>>>>> {
>>>>>> Simulate(x, x);
>>>>>> return;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> Output("Input_Halts = ", H(Px, Px));
>>>>>> }
>>>>>>
>>>>>> _Simulate()
>>>>>> [000010b2](01) 55 push ebp
>>>>>> [000010b3](02) 8bec mov ebp,esp
>>>>>> [000010b5](03) 8b450c mov eax,[ebp+0c]
>>>>>> [000010b8](01) 50 push eax
>>>>>> [000010b9](03) ff5508 call dword [ebp+08]
>>>>>> [000010bc](03) 83c404 add esp,+04
>>>>>> [000010bf](05) b801000000 mov eax,00000001
>>>>>> [000010c4](01) 5d pop ebp
>>>>>> [000010c5](01) c3 ret
>>>>>> Size in bytes:(0020) [000010c5]
>>>>>>
>>>>>> _Px()
>>>>>> [00001102](01) 55 push ebp
>>>>>> [00001103](02) 8bec mov ebp,esp
>>>>>> [00001105](03) 8b4508 mov eax,[ebp+08]
>>>>>> [00001108](01) 50 push eax
>>>>>> [00001109](03) 8b4d08 mov ecx,[ebp+08]
>>>>>> [0000110c](01) 51 push ecx
>>>>>> [0000110d](05) e8a0ffffff call 000010b2
>>>>>> [00001112](03) 83c408 add esp,+08
>>>>>> [00001115](01) 5d pop ebp
>>>>>> [00001116](01) c3 ret
>>>>>> Size in bytes:(0021) [00001116]
>>>>>>
>>>>>> _main()
>>>>>> [00001122](01) 55 push ebp
>>>>>> [00001123](02) 8bec mov ebp,esp
>>>>>> [00001125](05) 6802110000 push 00001102
>>>>>> [0000112a](05) 6802110000 push 00001102
>>>>>> [0000112f](05) e85efdffff call 00000e92
>>>>>> [00001134](03) 83c408 add esp,+08
>>>>>> [00001137](01) 50 push eax
>>>>>> [00001138](05) 6863040000 push 00000463
>>>>>> [0000113d](05) e840f3ffff call 00000482
>>>>>> [00001142](03) 83c408 add esp,+08
>>>>>> [00001145](02) 33c0 xor eax,eax
>>>>>> [00001147](01) 5d pop ebp
>>>>>> [00001148](01) c3 ret
>>>>>> Size in bytes:(0039) [00001148]
>>>>>>
>>>>>> machine stack stack machine assembly
>>>>>> address address data code language
>>>>>> ======== ======== ======== ========= =============
>>>>>> [00001122][00101c15][00000000] 55 push ebp
>>>>>> [00001123][00101c15][00000000] 8bec mov ebp,esp
>>>>>> [00001125][00101c11][00001102] 6802110000 push 00001102
>>>>>> [0000112a][00101c0d][00001102] 6802110000 push 00001102
>>>>>> [0000112f][00101c09][00001134] e85efdffff call 00000e92
>>>>>> Address_of_H:e92
>>>>>>
>>>>>> H: Begin Simulation Execution Trace Stored at:111cc1
>>>>>> Address_of_H:e92
>>>>>> [00001102][00111cad][00111cb1] 55 push ebp
>>>>>> [00001103][00111cad][00111cb1] 8bec mov ebp,esp
>>>>>> [00001105][00111cad][00111cb1] 8b4508 mov eax,[ebp+08]
>>>>>> [00001108][00111ca9][00001102] 50 push eax
>>>>>> [00001109][00111ca9][00001102] 8b4d08 mov ecx,[ebp+08]
>>>>>> [0000110c][00111ca5][00001102] 51 push ecx
>>>>>> [0000110d][00111ca1][00001112] e8a0ffffff call 000010b2
>>>>>> [000010b2][00111c9d][00111cad] 55 push ebp
>>>>>> [000010b3][00111c9d][00111cad] 8bec mov ebp,esp
>>>>>> [000010b5][00111c9d][00111cad] 8b450c mov eax,[ebp+0c]
>>>>>> [000010b8][00111c99][00001102] 50 push eax
>>>>>> Calling:_Px()
>>>>>> Decode_Control_Flow_Instruction([00000008][00111c9d][00001102])
>>>>>> [000010b9][00111c95][000010bc] ff5508 call dword [ebp+08]
>>>>>> [00001102][00111c91][00111c9d] 55 push ebp
>>>>>> [00001103][00111c91][00111c9d] 8bec mov ebp,esp
>>>>>> [00001105][00111c91][00111c9d] 8b4508 mov eax,[ebp+08]
>>>>>> [00001108][00111c8d][00001102] 50 push eax
>>>>>> [00001109][00111c8d][00001102] 8b4d08 mov ecx,[ebp+08]
>>>>>> [0000110c][00111c89][00001102] 51 push ecx
>>>>>> [0000110d][00111c85][00001112] e8a0ffffff call 000010b2
>>>>>> H: Infinite Recursion Detected Simulation Stopped
>>>>>>
>>>>>> [00001134][00101c15][00000000] 83c408 add esp,+08
>>>>>> [00001137][00101c11][00000000] 50 push eax
>>>>>> [00001138][00101c0d][00000463] 6863040000 push 00000463
>>>>>> [0000113d][00101c0d][00000463] e840f3ffff call 00000482
>>>>>> Input_Halts = 0
>>>>>> [00001142][00101c15][00000000] 83c408 add esp,+08
>>>>>> [00001145][00101c15][00000000] 33c0 xor eax,eax
>>>>>> [00001147][00101c19][00000018] 5d pop ebp
>>>>>> [00001148][00101c1d][00000000] c3 ret
>>>>>> Number of Instructions Executed(2195) == 33 Pages
>>>>>
>>>>> Px doesn't call Simulate, Px calls H. You have made the same
>>>>> error repeatedly.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> Your Px does not call Simulate, mine does.
>>>> Call my Px Pz if this helps avoid the confusion.
>>>
>>> Pz doesn't call Simulate, Pz calls H. You have made the same error
>>> repeatedly.
>>>
>>> /Flibble
>>>
>>
>> What is your basis for saying that?
>
> My basis for saying that is an observation that you are attempting to
> build some convoluted strawman whereby you can claim equivalence
> between H and Simulate so you can then erroneously claim that all
> simulating halt deciders are recursive and cannot return a value to
> their callers from within the simulation.
>
> /Flibble
>

So you are disagreeing with what I said on some other basis than what I
actually said: *that is the definition of dishonestly*

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

On Tue, 30 Aug 2022 15:09:40 -0500
olcott <polcott2@gmail.com> wrote:

> On 8/30/2022 12:00 PM, Mr Flibble wrote:
> > On Tue, 30 Aug 2022 10:32:03 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 8/30/2022 10:23 AM, Mr Flibble wrote:
> >>> On Tue, 30 Aug 2022 10:13:52 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 8/30/2022 10:08 AM, Mr Flibble wrote:
> >>>>> On Tue, 30 Aug 2022 10:04:36 -0500
> >>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>
> >>>>>> // direct execution of x(y) derives equivalent
> >>>>>> // behavior to the simulation of x(y)
> >>>>>> u32 Simulate(ptr x, ptr y)
> >>>>>> {
> >>>>>> x(y);
> >>>>>> return 1;
> >>>>>> }
> >>>>>>
> >>>>>> void Px(ptr x)
> >>>>>> {
> >>>>>> Simulate(x, x);
> >>>>>> return;
> >>>>>> }
> >>>>>>
> >>>>>> int main()
> >>>>>> {
> >>>>>> Output("Input_Halts = ", H(Px, Px));
> >>>>>> }
> >>>>>>
> >>>>>> _Simulate()
> >>>>>> [000010b2](01) 55 push ebp
> >>>>>> [000010b3](02) 8bec mov ebp,esp
> >>>>>> [000010b5](03) 8b450c mov eax,[ebp+0c]
> >>>>>> [000010b8](01) 50 push eax
> >>>>>> [000010b9](03) ff5508 call dword [ebp+08]
> >>>>>> [000010bc](03) 83c404 add esp,+04
> >>>>>> [000010bf](05) b801000000 mov eax,00000001
> >>>>>> [000010c4](01) 5d pop ebp
> >>>>>> [000010c5](01) c3 ret
> >>>>>> Size in bytes:(0020) [000010c5]
> >>>>>>
> >>>>>> _Px()
> >>>>>> [00001102](01) 55 push ebp
> >>>>>> [00001103](02) 8bec mov ebp,esp
> >>>>>> [00001105](03) 8b4508 mov eax,[ebp+08]
> >>>>>> [00001108](01) 50 push eax
> >>>>>> [00001109](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>> [0000110c](01) 51 push ecx
> >>>>>> [0000110d](05) e8a0ffffff call 000010b2
> >>>>>> [00001112](03) 83c408 add esp,+08
> >>>>>> [00001115](01) 5d pop ebp
> >>>>>> [00001116](01) c3 ret
> >>>>>> Size in bytes:(0021) [00001116]
> >>>>>>
> >>>>>> _main()
> >>>>>> [00001122](01) 55 push ebp
> >>>>>> [00001123](02) 8bec mov ebp,esp
> >>>>>> [00001125](05) 6802110000 push 00001102
> >>>>>> [0000112a](05) 6802110000 push 00001102
> >>>>>> [0000112f](05) e85efdffff call 00000e92
> >>>>>> [00001134](03) 83c408 add esp,+08
> >>>>>> [00001137](01) 50 push eax
> >>>>>> [00001138](05) 6863040000 push 00000463
> >>>>>> [0000113d](05) e840f3ffff call 00000482
> >>>>>> [00001142](03) 83c408 add esp,+08
> >>>>>> [00001145](02) 33c0 xor eax,eax
> >>>>>> [00001147](01) 5d pop ebp
> >>>>>> [00001148](01) c3 ret
> >>>>>> Size in bytes:(0039) [00001148]
> >>>>>>
> >>>>>> machine stack stack machine assembly
> >>>>>> address address data code language
> >>>>>> ======== ======== ======== ========= =============
> >>>>>> [00001122][00101c15][00000000] 55 push ebp
> >>>>>> [00001123][00101c15][00000000] 8bec mov ebp,esp
> >>>>>> [00001125][00101c11][00001102] 6802110000 push 00001102
> >>>>>> [0000112a][00101c0d][00001102] 6802110000 push 00001102
> >>>>>> [0000112f][00101c09][00001134] e85efdffff call 00000e92
> >>>>>> Address_of_H:e92
> >>>>>>
> >>>>>> H: Begin Simulation Execution Trace Stored at:111cc1
> >>>>>> Address_of_H:e92
> >>>>>> [00001102][00111cad][00111cb1] 55 push ebp
> >>>>>> [00001103][00111cad][00111cb1] 8bec mov ebp,esp
> >>>>>> [00001105][00111cad][00111cb1] 8b4508 mov eax,[ebp+08]
> >>>>>> [00001108][00111ca9][00001102] 50 push eax
> >>>>>> [00001109][00111ca9][00001102] 8b4d08 mov ecx,[ebp+08]
> >>>>>> [0000110c][00111ca5][00001102] 51 push ecx
> >>>>>> [0000110d][00111ca1][00001112] e8a0ffffff call 000010b2
> >>>>>> [000010b2][00111c9d][00111cad] 55 push ebp
> >>>>>> [000010b3][00111c9d][00111cad] 8bec mov ebp,esp
> >>>>>> [000010b5][00111c9d][00111cad] 8b450c mov eax,[ebp+0c]
> >>>>>> [000010b8][00111c99][00001102] 50 push eax
> >>>>>> Calling:_Px()
> >>>>>> Decode_Control_Flow_Instruction([00000008][00111c9d][00001102])
> >>>>>> [000010b9][00111c95][000010bc] ff5508 call dword
> >>>>>> [ebp+08] [00001102][00111c91][00111c9d] 55 push ebp
> >>>>>> [00001103][00111c91][00111c9d] 8bec mov ebp,esp
> >>>>>> [00001105][00111c91][00111c9d] 8b4508 mov eax,[ebp+08]
> >>>>>> [00001108][00111c8d][00001102] 50 push eax
> >>>>>> [00001109][00111c8d][00001102] 8b4d08 mov ecx,[ebp+08]
> >>>>>> [0000110c][00111c89][00001102] 51 push ecx
> >>>>>> [0000110d][00111c85][00001112] e8a0ffffff call 000010b2
> >>>>>> H: Infinite Recursion Detected Simulation Stopped
> >>>>>>
> >>>>>> [00001134][00101c15][00000000] 83c408 add esp,+08
> >>>>>> [00001137][00101c11][00000000] 50 push eax
> >>>>>> [00001138][00101c0d][00000463] 6863040000 push 00000463
> >>>>>> [0000113d][00101c0d][00000463] e840f3ffff call 00000482
> >>>>>> Input_Halts = 0
> >>>>>> [00001142][00101c15][00000000] 83c408 add esp,+08
> >>>>>> [00001145][00101c15][00000000] 33c0 xor eax,eax
> >>>>>> [00001147][00101c19][00000018] 5d pop ebp
> >>>>>> [00001148][00101c1d][00000000] c3 ret
> >>>>>> Number of Instructions Executed(2195) == 33 Pages
> >>>>>
> >>>>> Px doesn't call Simulate, Px calls H. You have made the same
> >>>>> error repeatedly.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> Your Px does not call Simulate, mine does.
> >>>> Call my Px Pz if this helps avoid the confusion.
> >>>
> >>> Pz doesn't call Simulate, Pz calls H. You have made the same error
> >>> repeatedly.
> >>>
> >>> /Flibble
> >>>
> >>
> >> What is your basis for saying that?
> >
> > My basis for saying that is an observation that you are attempting
> > to build some convoluted strawman whereby you can claim equivalence
> > between H and Simulate so you can then erroneously claim that all
> > simulating halt deciders are recursive and cannot return a value to
> > their callers from within the simulation.
> >
> > /Flibble
> >
>
>
> So you are disagreeing with what I said on some other basis than what
> I actually said: *that is the definition of dishonestly*

OK dear. Carry on constructing your strawman, everyone will knock it
down as usual.

/Flibble

On 8/30/2022 3:28 PM, Mr Flibble wrote:
> On Tue, 30 Aug 2022 15:09:40 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> On 8/30/2022 12:00 PM, Mr Flibble wrote:
>>> On Tue, 30 Aug 2022 10:32:03 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 8/30/2022 10:23 AM, Mr Flibble wrote:
>>>>> On Tue, 30 Aug 2022 10:13:52 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 8/30/2022 10:08 AM, Mr Flibble wrote:
>>>>>>> On Tue, 30 Aug 2022 10:04:36 -0500
>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>
>>>>>>>> // direct execution of x(y) derives equivalent
>>>>>>>> // behavior to the simulation of x(y)
>>>>>>>> u32 Simulate(ptr x, ptr y)
>>>>>>>> {
>>>>>>>> x(y);
>>>>>>>> return 1;
>>>>>>>> }
>>>>>>>>
>>>>>>>> void Px(ptr x)
>>>>>>>> {
>>>>>>>> Simulate(x, x);
>>>>>>>> return;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> Output("Input_Halts = ", H(Px, Px));
>>>>>>>> }
>>>>>>>>
>>>>>>>> _Simulate()
>>>>>>>> [000010b2](01) 55 push ebp
>>>>>>>> [000010b3](02) 8bec mov ebp,esp
>>>>>>>> [000010b5](03) 8b450c mov eax,[ebp+0c]
>>>>>>>> [000010b8](01) 50 push eax
>>>>>>>> [000010b9](03) ff5508 call dword [ebp+08]
>>>>>>>> [000010bc](03) 83c404 add esp,+04
>>>>>>>> [000010bf](05) b801000000 mov eax,00000001
>>>>>>>> [000010c4](01) 5d pop ebp
>>>>>>>> [000010c5](01) c3 ret
>>>>>>>> Size in bytes:(0020) [000010c5]
>>>>>>>>
>>>>>>>> _Px()
>>>>>>>> [00001102](01) 55 push ebp
>>>>>>>> [00001103](02) 8bec mov ebp,esp
>>>>>>>> [00001105](03) 8b4508 mov eax,[ebp+08]
>>>>>>>> [00001108](01) 50 push eax
>>>>>>>> [00001109](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>> [0000110c](01) 51 push ecx
>>>>>>>> [0000110d](05) e8a0ffffff call 000010b2
>>>>>>>> [00001112](03) 83c408 add esp,+08
>>>>>>>> [00001115](01) 5d pop ebp
>>>>>>>> [00001116](01) c3 ret
>>>>>>>> Size in bytes:(0021) [00001116]
>>>>>>>>
>>>>>>>> _main()
>>>>>>>> [00001122](01) 55 push ebp
>>>>>>>> [00001123](02) 8bec mov ebp,esp
>>>>>>>> [00001125](05) 6802110000 push 00001102
>>>>>>>> [0000112a](05) 6802110000 push 00001102
>>>>>>>> [0000112f](05) e85efdffff call 00000e92
>>>>>>>> [00001134](03) 83c408 add esp,+08
>>>>>>>> [00001137](01) 50 push eax
>>>>>>>> [00001138](05) 6863040000 push 00000463
>>>>>>>> [0000113d](05) e840f3ffff call 00000482
>>>>>>>> [00001142](03) 83c408 add esp,+08
>>>>>>>> [00001145](02) 33c0 xor eax,eax
>>>>>>>> [00001147](01) 5d pop ebp
>>>>>>>> [00001148](01) c3 ret
>>>>>>>> Size in bytes:(0039) [00001148]
>>>>>>>>
>>>>>>>> machine stack stack machine assembly
>>>>>>>> address address data code language
>>>>>>>> ======== ======== ======== ========= =============
>>>>>>>> [00001122][00101c15][00000000] 55 push ebp
>>>>>>>> [00001123][00101c15][00000000] 8bec mov ebp,esp
>>>>>>>> [00001125][00101c11][00001102] 6802110000 push 00001102
>>>>>>>> [0000112a][00101c0d][00001102] 6802110000 push 00001102
>>>>>>>> [0000112f][00101c09][00001134] e85efdffff call 00000e92
>>>>>>>> Address_of_H:e92
>>>>>>>>
>>>>>>>> H: Begin Simulation Execution Trace Stored at:111cc1
>>>>>>>> Address_of_H:e92
>>>>>>>> [00001102][00111cad][00111cb1] 55 push ebp
>>>>>>>> [00001103][00111cad][00111cb1] 8bec mov ebp,esp
>>>>>>>> [00001105][00111cad][00111cb1] 8b4508 mov eax,[ebp+08]
>>>>>>>> [00001108][00111ca9][00001102] 50 push eax
>>>>>>>> [00001109][00111ca9][00001102] 8b4d08 mov ecx,[ebp+08]
>>>>>>>> [0000110c][00111ca5][00001102] 51 push ecx
>>>>>>>> [0000110d][00111ca1][00001112] e8a0ffffff call 000010b2
>>>>>>>> [000010b2][00111c9d][00111cad] 55 push ebp
>>>>>>>> [000010b3][00111c9d][00111cad] 8bec mov ebp,esp
>>>>>>>> [000010b5][00111c9d][00111cad] 8b450c mov eax,[ebp+0c]
>>>>>>>> [000010b8][00111c99][00001102] 50 push eax
>>>>>>>> Calling:_Px()
>>>>>>>> Decode_Control_Flow_Instruction([00000008][00111c9d][00001102])
>>>>>>>> [000010b9][00111c95][000010bc] ff5508 call dword
>>>>>>>> [ebp+08] [00001102][00111c91][00111c9d] 55 push ebp
>>>>>>>> [00001103][00111c91][00111c9d] 8bec mov ebp,esp
>>>>>>>> [00001105][00111c91][00111c9d] 8b4508 mov eax,[ebp+08]
>>>>>>>> [00001108][00111c8d][00001102] 50 push eax
>>>>>>>> [00001109][00111c8d][00001102] 8b4d08 mov ecx,[ebp+08]
>>>>>>>> [0000110c][00111c89][00001102] 51 push ecx
>>>>>>>> [0000110d][00111c85][00001112] e8a0ffffff call 000010b2
>>>>>>>> H: Infinite Recursion Detected Simulation Stopped
>>>>>>>>
>>>>>>>> [00001134][00101c15][00000000] 83c408 add esp,+08
>>>>>>>> [00001137][00101c11][00000000] 50 push eax
>>>>>>>> [00001138][00101c0d][00000463] 6863040000 push 00000463
>>>>>>>> [0000113d][00101c0d][00000463] e840f3ffff call 00000482
>>>>>>>> Input_Halts = 0
>>>>>>>> [00001142][00101c15][00000000] 83c408 add esp,+08
>>>>>>>> [00001145][00101c15][00000000] 33c0 xor eax,eax
>>>>>>>> [00001147][00101c19][00000018] 5d pop ebp
>>>>>>>> [00001148][00101c1d][00000000] c3 ret
>>>>>>>> Number of Instructions Executed(2195) == 33 Pages
>>>>>>>
>>>>>>> Px doesn't call Simulate, Px calls H. You have made the same
>>>>>>> error repeatedly.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> Your Px does not call Simulate, mine does.
>>>>>> Call my Px Pz if this helps avoid the confusion.
>>>>>
>>>>> Pz doesn't call Simulate, Pz calls H. You have made the same error
>>>>> repeatedly.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> What is your basis for saying that?
>>>
>>> My basis for saying that is an observation that you are attempting
>>> to build some convoluted strawman whereby you can claim equivalence
>>> between H and Simulate so you can then erroneously claim that all
>>> simulating halt deciders are recursive and cannot return a value to
>>> their callers from within the simulation.
>>>
>>> /Flibble
>>>
>>
>>
>> So you are disagreeing with what I said on some other basis than what
>> I actually said: *that is the definition of dishonestly*
>
> OK dear. Carry on constructing your strawman, everyone will knock it
> down as usual.
>
> /Flibble
>

Click here to read the complete article

On Tue, 30 Aug 2022 15:59:31 -0500
olcott <polcott2@gmail.com> wrote:

> On 8/30/2022 3:28 PM, Mr Flibble wrote:
> > On Tue, 30 Aug 2022 15:09:40 -0500
> > olcott <polcott2@gmail.com> wrote:
> >
> >> On 8/30/2022 12:00 PM, Mr Flibble wrote:
> >>> On Tue, 30 Aug 2022 10:32:03 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 8/30/2022 10:23 AM, Mr Flibble wrote:
> >>>>> On Tue, 30 Aug 2022 10:13:52 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 8/30/2022 10:08 AM, Mr Flibble wrote:
> >>>>>>> On Tue, 30 Aug 2022 10:04:36 -0500
> >>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>
> >>>>>>>> // direct execution of x(y) derives equivalent
> >>>>>>>> // behavior to the simulation of x(y)
> >>>>>>>> u32 Simulate(ptr x, ptr y)
> >>>>>>>> {
> >>>>>>>> x(y);
> >>>>>>>> return 1;
> >>>>>>>> }
> >>>>>>>>
> >>>>>>>> void Px(ptr x)
> >>>>>>>> {
> >>>>>>>> Simulate(x, x);
> >>>>>>>> return;
> >>>>>>>> }
> >>>>>>>>
> >>>>>>>> int main()
> >>>>>>>> {
> >>>>>>>> Output("Input_Halts = ", H(Px, Px));
> >>>>>>>> }
> >>>>>>>>
> >>>>>>>> _Simulate()
> >>>>>>>> [000010b2](01) 55 push ebp
> >>>>>>>> [000010b3](02) 8bec mov ebp,esp
> >>>>>>>> [000010b5](03) 8b450c mov eax,[ebp+0c]
> >>>>>>>> [000010b8](01) 50 push eax
> >>>>>>>> [000010b9](03) ff5508 call dword [ebp+08]
> >>>>>>>> [000010bc](03) 83c404 add esp,+04
> >>>>>>>> [000010bf](05) b801000000 mov eax,00000001
> >>>>>>>> [000010c4](01) 5d pop ebp
> >>>>>>>> [000010c5](01) c3 ret
> >>>>>>>> Size in bytes:(0020) [000010c5]
> >>>>>>>>
> >>>>>>>> _Px()
> >>>>>>>> [00001102](01) 55 push ebp
> >>>>>>>> [00001103](02) 8bec mov ebp,esp
> >>>>>>>> [00001105](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>> [00001108](01) 50 push eax
> >>>>>>>> [00001109](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>>>> [0000110c](01) 51 push ecx
> >>>>>>>> [0000110d](05) e8a0ffffff call 000010b2
> >>>>>>>> [00001112](03) 83c408 add esp,+08
> >>>>>>>> [00001115](01) 5d pop ebp
> >>>>>>>> [00001116](01) c3 ret
> >>>>>>>> Size in bytes:(0021) [00001116]
> >>>>>>>>
> >>>>>>>> _main()
> >>>>>>>> [00001122](01) 55 push ebp
> >>>>>>>> [00001123](02) 8bec mov ebp,esp
> >>>>>>>> [00001125](05) 6802110000 push 00001102
> >>>>>>>> [0000112a](05) 6802110000 push 00001102
> >>>>>>>> [0000112f](05) e85efdffff call 00000e92
> >>>>>>>> [00001134](03) 83c408 add esp,+08
> >>>>>>>> [00001137](01) 50 push eax
> >>>>>>>> [00001138](05) 6863040000 push 00000463
> >>>>>>>> [0000113d](05) e840f3ffff call 00000482
> >>>>>>>> [00001142](03) 83c408 add esp,+08
> >>>>>>>> [00001145](02) 33c0 xor eax,eax
> >>>>>>>> [00001147](01) 5d pop ebp
> >>>>>>>> [00001148](01) c3 ret
> >>>>>>>> Size in bytes:(0039) [00001148]
> >>>>>>>>
> >>>>>>>> machine stack stack machine assembly
> >>>>>>>> address address data code language
> >>>>>>>> ======== ======== ======== ========= =============
> >>>>>>>> [00001122][00101c15][00000000] 55 push ebp
> >>>>>>>> [00001123][00101c15][00000000] 8bec mov ebp,esp
> >>>>>>>> [00001125][00101c11][00001102] 6802110000 push 00001102
> >>>>>>>> [0000112a][00101c0d][00001102] 6802110000 push 00001102
> >>>>>>>> [0000112f][00101c09][00001134] e85efdffff call 00000e92
> >>>>>>>> Address_of_H:e92
> >>>>>>>>
> >>>>>>>> H: Begin Simulation Execution Trace Stored at:111cc1
> >>>>>>>> Address_of_H:e92
> >>>>>>>> [00001102][00111cad][00111cb1] 55 push ebp
> >>>>>>>> [00001103][00111cad][00111cb1] 8bec mov ebp,esp
> >>>>>>>> [00001105][00111cad][00111cb1] 8b4508 mov
> >>>>>>>> eax,[ebp+08] [00001108][00111ca9][00001102] 50
> >>>>>>>> push eax [00001109][00111ca9][00001102] 8b4d08 mov
> >>>>>>>> ecx,[ebp+08] [0000110c][00111ca5][00001102] 51
> >>>>>>>> push ecx [0000110d][00111ca1][00001112] e8a0ffffff call
> >>>>>>>> 000010b2 [000010b2][00111c9d][00111cad] 55 push
> >>>>>>>> ebp [000010b3][00111c9d][00111cad] 8bec mov ebp,esp
> >>>>>>>> [000010b5][00111c9d][00111cad] 8b450c mov
> >>>>>>>> eax,[ebp+0c] [000010b8][00111c99][00001102] 50
> >>>>>>>> push eax Calling:_Px()
> >>>>>>>> Decode_Control_Flow_Instruction([00000008][00111c9d][00001102])
> >>>>>>>> [000010b9][00111c95][000010bc] ff5508 call dword
> >>>>>>>> [ebp+08] [00001102][00111c91][00111c9d] 55 push
> >>>>>>>> ebp [00001103][00111c91][00111c9d] 8bec mov ebp,esp
> >>>>>>>> [00001105][00111c91][00111c9d] 8b4508 mov
> >>>>>>>> eax,[ebp+08] [00001108][00111c8d][00001102] 50
> >>>>>>>> push eax [00001109][00111c8d][00001102] 8b4d08 mov
> >>>>>>>> ecx,[ebp+08] [0000110c][00111c89][00001102] 51
> >>>>>>>> push ecx [0000110d][00111c85][00001112] e8a0ffffff call
> >>>>>>>> 000010b2 H: Infinite Recursion Detected Simulation Stopped
> >>>>>>>>
> >>>>>>>> [00001134][00101c15][00000000] 83c408 add esp,+08
> >>>>>>>> [00001137][00101c11][00000000] 50 push eax
> >>>>>>>> [00001138][00101c0d][00000463] 6863040000 push 00000463
> >>>>>>>> [0000113d][00101c0d][00000463] e840f3ffff call 00000482
> >>>>>>>> Input_Halts = 0
> >>>>>>>> [00001142][00101c15][00000000] 83c408 add esp,+08
> >>>>>>>> [00001145][00101c15][00000000] 33c0 xor eax,eax
> >>>>>>>> [00001147][00101c19][00000018] 5d pop ebp
> >>>>>>>> [00001148][00101c1d][00000000] c3 ret
> >>>>>>>> Number of Instructions Executed(2195) == 33 Pages
> >>>>>>>
> >>>>>>> Px doesn't call Simulate, Px calls H. You have made the same
> >>>>>>> error repeatedly.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> Your Px does not call Simulate, mine does.
> >>>>>> Call my Px Pz if this helps avoid the confusion.
> >>>>>
> >>>>> Pz doesn't call Simulate, Pz calls H. You have made the same
> >>>>> error repeatedly.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> What is your basis for saying that?
> >>>
> >>> My basis for saying that is an observation that you are attempting
> >>> to build some convoluted strawman whereby you can claim
> >>> equivalence between H and Simulate so you can then erroneously
> >>> claim that all simulating halt deciders are recursive and cannot
> >>> return a value to their callers from within the simulation.
> >>>
> >>> /Flibble
> >>>
> >>
> >>
> >> So you are disagreeing with what I said on some other basis than
> >> what I actually said: *that is the definition of dishonestly*
> >
> > OK dear. Carry on constructing your strawman, everyone will knock it
> > down as usual.
> >
> > /Flibble
> >
>
> Failing to provide a YES/NO answer breaks an honest dialogue.
>
> Failing to fully explain all of the reasoning for a NO answer
> breaks and honest dialogue.
>
> u32 Simulate(ptr x, ptr y)
> {
> x(y);
> }
>
> void Pz(ptr x)
> {
> Simulate(x, x);
> }
>
> int main()
> {
> Output("Input_Halts = ", H(Pz, Pz));
> }
>
> H(Pz,Pz) correctly returns 0.
>
> *So you agree with the first step of the proof*?
> Only YES/NO are honest answers, NO requires a complete explanation.

Click here to read the complete article

On 8/30/2022 4:02 PM, Mr Flibble wrote:
> On Tue, 30 Aug 2022 15:59:31 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> On 8/30/2022 3:28 PM, Mr Flibble wrote:
>>> On Tue, 30 Aug 2022 15:09:40 -0500
>>> olcott <polcott2@gmail.com> wrote:
>>>
>>>> On 8/30/2022 12:00 PM, Mr Flibble wrote:
>>>>> On Tue, 30 Aug 2022 10:32:03 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 8/30/2022 10:23 AM, Mr Flibble wrote:
>>>>>>> On Tue, 30 Aug 2022 10:13:52 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 8/30/2022 10:08 AM, Mr Flibble wrote:
>>>>>>>>> On Tue, 30 Aug 2022 10:04:36 -0500
>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>
>>>>>>>>>> // direct execution of x(y) derives equivalent
>>>>>>>>>> // behavior to the simulation of x(y)
>>>>>>>>>> u32 Simulate(ptr x, ptr y)
>>>>>>>>>> {
>>>>>>>>>> x(y);
>>>>>>>>>> return 1;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> void Px(ptr x)
>>>>>>>>>> {
>>>>>>>>>> Simulate(x, x);
>>>>>>>>>> return;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>> Output("Input_Halts = ", H(Px, Px));
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> _Simulate()
>>>>>>>>>> [000010b2](01) 55 push ebp
>>>>>>>>>> [000010b3](02) 8bec mov ebp,esp
>>>>>>>>>> [000010b5](03) 8b450c mov eax,[ebp+0c]
>>>>>>>>>> [000010b8](01) 50 push eax
>>>>>>>>>> [000010b9](03) ff5508 call dword [ebp+08]
>>>>>>>>>> [000010bc](03) 83c404 add esp,+04
>>>>>>>>>> [000010bf](05) b801000000 mov eax,00000001
>>>>>>>>>> [000010c4](01) 5d pop ebp
>>>>>>>>>> [000010c5](01) c3 ret
>>>>>>>>>> Size in bytes:(0020) [000010c5]
>>>>>>>>>>
>>>>>>>>>> _Px()
>>>>>>>>>> [00001102](01) 55 push ebp
>>>>>>>>>> [00001103](02) 8bec mov ebp,esp
>>>>>>>>>> [00001105](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>> [00001108](01) 50 push eax
>>>>>>>>>> [00001109](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>> [0000110c](01) 51 push ecx
>>>>>>>>>> [0000110d](05) e8a0ffffff call 000010b2
>>>>>>>>>> [00001112](03) 83c408 add esp,+08
>>>>>>>>>> [00001115](01) 5d pop ebp
>>>>>>>>>> [00001116](01) c3 ret
>>>>>>>>>> Size in bytes:(0021) [00001116]
>>>>>>>>>>
>>>>>>>>>> _main()
>>>>>>>>>> [00001122](01) 55 push ebp
>>>>>>>>>> [00001123](02) 8bec mov ebp,esp
>>>>>>>>>> [00001125](05) 6802110000 push 00001102
>>>>>>>>>> [0000112a](05) 6802110000 push 00001102
>>>>>>>>>> [0000112f](05) e85efdffff call 00000e92
>>>>>>>>>> [00001134](03) 83c408 add esp,+08
>>>>>>>>>> [00001137](01) 50 push eax
>>>>>>>>>> [00001138](05) 6863040000 push 00000463
>>>>>>>>>> [0000113d](05) e840f3ffff call 00000482
>>>>>>>>>> [00001142](03) 83c408 add esp,+08
>>>>>>>>>> [00001145](02) 33c0 xor eax,eax
>>>>>>>>>> [00001147](01) 5d pop ebp
>>>>>>>>>> [00001148](01) c3 ret
>>>>>>>>>> Size in bytes:(0039) [00001148]
>>>>>>>>>>
>>>>>>>>>> machine stack stack machine assembly
>>>>>>>>>> address address data code language
>>>>>>>>>> ======== ======== ======== ========= =============
>>>>>>>>>> [00001122][00101c15][00000000] 55 push ebp
>>>>>>>>>> [00001123][00101c15][00000000] 8bec mov ebp,esp
>>>>>>>>>> [00001125][00101c11][00001102] 6802110000 push 00001102
>>>>>>>>>> [0000112a][00101c0d][00001102] 6802110000 push 00001102
>>>>>>>>>> [0000112f][00101c09][00001134] e85efdffff call 00000e92
>>>>>>>>>> Address_of_H:e92
>>>>>>>>>>
>>>>>>>>>> H: Begin Simulation Execution Trace Stored at:111cc1
>>>>>>>>>> Address_of_H:e92
>>>>>>>>>> [00001102][00111cad][00111cb1] 55 push ebp
>>>>>>>>>> [00001103][00111cad][00111cb1] 8bec mov ebp,esp
>>>>>>>>>> [00001105][00111cad][00111cb1] 8b4508 mov
>>>>>>>>>> eax,[ebp+08] [00001108][00111ca9][00001102] 50
>>>>>>>>>> push eax [00001109][00111ca9][00001102] 8b4d08 mov
>>>>>>>>>> ecx,[ebp+08] [0000110c][00111ca5][00001102] 51
>>>>>>>>>> push ecx [0000110d][00111ca1][00001112] e8a0ffffff call
>>>>>>>>>> 000010b2 [000010b2][00111c9d][00111cad] 55 push
>>>>>>>>>> ebp [000010b3][00111c9d][00111cad] 8bec mov ebp,esp
>>>>>>>>>> [000010b5][00111c9d][00111cad] 8b450c mov
>>>>>>>>>> eax,[ebp+0c] [000010b8][00111c99][00001102] 50
>>>>>>>>>> push eax Calling:_Px()
>>>>>>>>>> Decode_Control_Flow_Instruction([00000008][00111c9d][00001102])
>>>>>>>>>> [000010b9][00111c95][000010bc] ff5508 call dword
>>>>>>>>>> [ebp+08] [00001102][00111c91][00111c9d] 55 push
>>>>>>>>>> ebp [00001103][00111c91][00111c9d] 8bec mov ebp,esp
>>>>>>>>>> [00001105][00111c91][00111c9d] 8b4508 mov
>>>>>>>>>> eax,[ebp+08] [00001108][00111c8d][00001102] 50
>>>>>>>>>> push eax [00001109][00111c8d][00001102] 8b4d08 mov
>>>>>>>>>> ecx,[ebp+08] [0000110c][00111c89][00001102] 51
>>>>>>>>>> push ecx [0000110d][00111c85][00001112] e8a0ffffff call
>>>>>>>>>> 000010b2 H: Infinite Recursion Detected Simulation Stopped
>>>>>>>>>>
>>>>>>>>>> [00001134][00101c15][00000000] 83c408 add esp,+08
>>>>>>>>>> [00001137][00101c11][00000000] 50 push eax
>>>>>>>>>> [00001138][00101c0d][00000463] 6863040000 push 00000463
>>>>>>>>>> [0000113d][00101c0d][00000463] e840f3ffff call 00000482
>>>>>>>>>> Input_Halts = 0
>>>>>>>>>> [00001142][00101c15][00000000] 83c408 add esp,+08
>>>>>>>>>> [00001145][00101c15][00000000] 33c0 xor eax,eax
>>>>>>>>>> [00001147][00101c19][00000018] 5d pop ebp
>>>>>>>>>> [00001148][00101c1d][00000000] c3 ret
>>>>>>>>>> Number of Instructions Executed(2195) == 33 Pages
>>>>>>>>>
>>>>>>>>> Px doesn't call Simulate, Px calls H. You have made the same
>>>>>>>>> error repeatedly.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> Your Px does not call Simulate, mine does.
>>>>>>>> Call my Px Pz if this helps avoid the confusion.
>>>>>>>
>>>>>>> Pz doesn't call Simulate, Pz calls H. You have made the same
>>>>>>> error repeatedly.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> What is your basis for saying that?
>>>>>
>>>>> My basis for saying that is an observation that you are attempting
>>>>> to build some convoluted strawman whereby you can claim
>>>>> equivalence between H and Simulate so you can then erroneously
>>>>> claim that all simulating halt deciders are recursive and cannot
>>>>> return a value to their callers from within the simulation.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>>
>>>> So you are disagreeing with what I said on some other basis than
>>>> what I actually said: *that is the definition of dishonestly*
>>>
>>> OK dear. Carry on constructing your strawman, everyone will knock it
>>> down as usual.
>>>
>>> /Flibble
>>>
>>
>> Failing to provide a YES/NO answer breaks an honest dialogue.
>>
>> Failing to fully explain all of the reasoning for a NO answer
>> breaks and honest dialogue.
>>
>> u32 Simulate(ptr x, ptr y)
>> {
>> x(y);
>> }
>>
>> void Pz(ptr x)
>> {
>> Simulate(x, x);
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H(Pz, Pz));
>> }
>>
>> H(Pz,Pz) correctly returns 0.
>>
>> *So you agree with the first step of the proof*?
>> Only YES/NO are honest answers, NO requires a complete explanation.
>
> Answer me this, dear, why does Simulate have a u32 return type if it
> can never return to its caller? You've fucked up, BIG TIME.
>
> /Flibble
>
>

Click here to read the complete article

On Tue, 30 Aug 2022 16:23:18 -0500
olcott <polcott2@gmail.com> wrote:

> On 8/30/2022 4:02 PM, Mr Flibble wrote:
> > On Tue, 30 Aug 2022 15:59:31 -0500
> > olcott <polcott2@gmail.com> wrote:
> >
> >> On 8/30/2022 3:28 PM, Mr Flibble wrote:
> >>> On Tue, 30 Aug 2022 15:09:40 -0500
> >>> olcott <polcott2@gmail.com> wrote:
> >>>
> >>>> On 8/30/2022 12:00 PM, Mr Flibble wrote:
> >>>>> On Tue, 30 Aug 2022 10:32:03 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 8/30/2022 10:23 AM, Mr Flibble wrote:
> >>>>>>> On Tue, 30 Aug 2022 10:13:52 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 8/30/2022 10:08 AM, Mr Flibble wrote:
> >>>>>>>>> On Tue, 30 Aug 2022 10:04:36 -0500
> >>>>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> // direct execution of x(y) derives equivalent
> >>>>>>>>>> // behavior to the simulation of x(y)
> >>>>>>>>>> u32 Simulate(ptr x, ptr y)
> >>>>>>>>>> {
> >>>>>>>>>> x(y);
> >>>>>>>>>> return 1;
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>> void Px(ptr x)
> >>>>>>>>>> {
> >>>>>>>>>> Simulate(x, x);
> >>>>>>>>>> return;
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>> int main()
> >>>>>>>>>> {
> >>>>>>>>>> Output("Input_Halts = ", H(Px, Px));
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>> _Simulate()
> >>>>>>>>>> [000010b2](01) 55 push ebp
> >>>>>>>>>> [000010b3](02) 8bec mov ebp,esp
> >>>>>>>>>> [000010b5](03) 8b450c mov eax,[ebp+0c]
> >>>>>>>>>> [000010b8](01) 50 push eax
> >>>>>>>>>> [000010b9](03) ff5508 call dword [ebp+08]
> >>>>>>>>>> [000010bc](03) 83c404 add esp,+04
> >>>>>>>>>> [000010bf](05) b801000000 mov eax,00000001
> >>>>>>>>>> [000010c4](01) 5d pop ebp
> >>>>>>>>>> [000010c5](01) c3 ret
> >>>>>>>>>> Size in bytes:(0020) [000010c5]
> >>>>>>>>>>
> >>>>>>>>>> _Px()
> >>>>>>>>>> [00001102](01) 55 push ebp
> >>>>>>>>>> [00001103](02) 8bec mov ebp,esp
> >>>>>>>>>> [00001105](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>> [00001108](01) 50 push eax
> >>>>>>>>>> [00001109](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>> [0000110c](01) 51 push ecx
> >>>>>>>>>> [0000110d](05) e8a0ffffff call 000010b2
> >>>>>>>>>> [00001112](03) 83c408 add esp,+08
> >>>>>>>>>> [00001115](01) 5d pop ebp
> >>>>>>>>>> [00001116](01) c3 ret
> >>>>>>>>>> Size in bytes:(0021) [00001116]
> >>>>>>>>>>
> >>>>>>>>>> _main()
> >>>>>>>>>> [00001122](01) 55 push ebp
> >>>>>>>>>> [00001123](02) 8bec mov ebp,esp
> >>>>>>>>>> [00001125](05) 6802110000 push 00001102
> >>>>>>>>>> [0000112a](05) 6802110000 push 00001102
> >>>>>>>>>> [0000112f](05) e85efdffff call 00000e92
> >>>>>>>>>> [00001134](03) 83c408 add esp,+08
> >>>>>>>>>> [00001137](01) 50 push eax
> >>>>>>>>>> [00001138](05) 6863040000 push 00000463
> >>>>>>>>>> [0000113d](05) e840f3ffff call 00000482
> >>>>>>>>>> [00001142](03) 83c408 add esp,+08
> >>>>>>>>>> [00001145](02) 33c0 xor eax,eax
> >>>>>>>>>> [00001147](01) 5d pop ebp
> >>>>>>>>>> [00001148](01) c3 ret
> >>>>>>>>>> Size in bytes:(0039) [00001148]
> >>>>>>>>>>
> >>>>>>>>>> machine stack stack machine assembly
> >>>>>>>>>> address address data code language
> >>>>>>>>>> ======== ======== ======== =========
> >>>>>>>>>> ============= [00001122][00101c15][00000000] 55
> >>>>>>>>>> push ebp [00001123][00101c15][00000000] 8bec
> >>>>>>>>>> mov ebp,esp [00001125][00101c11][00001102] 6802110000
> >>>>>>>>>> push 00001102 [0000112a][00101c0d][00001102] 6802110000
> >>>>>>>>>> push 00001102 [0000112f][00101c09][00001134] e85efdffff
> >>>>>>>>>> call 00000e92 Address_of_H:e92
> >>>>>>>>>>
> >>>>>>>>>> H: Begin Simulation Execution Trace Stored at:111cc1
> >>>>>>>>>> Address_of_H:e92
> >>>>>>>>>> [00001102][00111cad][00111cb1] 55 push ebp
> >>>>>>>>>> [00001103][00111cad][00111cb1] 8bec mov ebp,esp
> >>>>>>>>>> [00001105][00111cad][00111cb1] 8b4508 mov
> >>>>>>>>>> eax,[ebp+08] [00001108][00111ca9][00001102] 50
> >>>>>>>>>> push eax [00001109][00111ca9][00001102] 8b4d08 mov
> >>>>>>>>>> ecx,[ebp+08] [0000110c][00111ca5][00001102] 51
> >>>>>>>>>> push ecx [0000110d][00111ca1][00001112] e8a0ffffff call
> >>>>>>>>>> 000010b2 [000010b2][00111c9d][00111cad] 55 push
> >>>>>>>>>> ebp [000010b3][00111c9d][00111cad] 8bec mov
> >>>>>>>>>> ebp,esp [000010b5][00111c9d][00111cad] 8b450c mov
> >>>>>>>>>> eax,[ebp+0c] [000010b8][00111c99][00001102] 50
> >>>>>>>>>> push eax Calling:_Px()
> >>>>>>>>>> Decode_Control_Flow_Instruction([00000008][00111c9d][00001102])
> >>>>>>>>>> [000010b9][00111c95][000010bc] ff5508 call dword
> >>>>>>>>>> [ebp+08] [00001102][00111c91][00111c9d] 55 push
> >>>>>>>>>> ebp [00001103][00111c91][00111c9d] 8bec mov
> >>>>>>>>>> ebp,esp [00001105][00111c91][00111c9d] 8b4508 mov
> >>>>>>>>>> eax,[ebp+08] [00001108][00111c8d][00001102] 50
> >>>>>>>>>> push eax [00001109][00111c8d][00001102] 8b4d08 mov
> >>>>>>>>>> ecx,[ebp+08] [0000110c][00111c89][00001102] 51
> >>>>>>>>>> push ecx [0000110d][00111c85][00001112] e8a0ffffff call
> >>>>>>>>>> 000010b2 H: Infinite Recursion Detected Simulation Stopped
> >>>>>>>>>>
> >>>>>>>>>> [00001134][00101c15][00000000] 83c408 add esp,+08
> >>>>>>>>>> [00001137][00101c11][00000000] 50 push eax
> >>>>>>>>>> [00001138][00101c0d][00000463] 6863040000 push 00000463
> >>>>>>>>>> [0000113d][00101c0d][00000463] e840f3ffff call 00000482
> >>>>>>>>>> Input_Halts = 0
> >>>>>>>>>> [00001142][00101c15][00000000] 83c408 add esp,+08
> >>>>>>>>>> [00001145][00101c15][00000000] 33c0 xor eax,eax
> >>>>>>>>>> [00001147][00101c19][00000018] 5d pop ebp
> >>>>>>>>>> [00001148][00101c1d][00000000] c3 ret
> >>>>>>>>>> Number of Instructions Executed(2195) == 33 Pages
> >>>>>>>>>
> >>>>>>>>> Px doesn't call Simulate, Px calls H. You have made the
> >>>>>>>>> same error repeatedly.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> Your Px does not call Simulate, mine does.
> >>>>>>>> Call my Px Pz if this helps avoid the confusion.
> >>>>>>>
> >>>>>>> Pz doesn't call Simulate, Pz calls H. You have made the same
> >>>>>>> error repeatedly.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> What is your basis for saying that?
> >>>>>
> >>>>> My basis for saying that is an observation that you are
> >>>>> attempting to build some convoluted strawman whereby you can
> >>>>> claim equivalence between H and Simulate so you can then
> >>>>> erroneously claim that all simulating halt deciders are
> >>>>> recursive and cannot return a value to their callers from
> >>>>> within the simulation.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>>
> >>>> So you are disagreeing with what I said on some other basis than
> >>>> what I actually said: *that is the definition of dishonestly*
> >>>
> >>> OK dear. Carry on constructing your strawman, everyone will knock
> >>> it down as usual.
> >>>
> >>> /Flibble
> >>>
> >>
> >> Failing to provide a YES/NO answer breaks an honest dialogue.
> >>
> >> Failing to fully explain all of the reasoning for a NO answer
> >> breaks and honest dialogue.
> >>
> >> u32 Simulate(ptr x, ptr y)
> >> {
> >> x(y);
> >> }
> >>
> >> void Pz(ptr x)
> >> {
> >> Simulate(x, x);
> >> }
> >>
> >> int main()
> >> {
> >> Output("Input_Halts = ", H(Pz, Pz));
> >> }
> >>
> >> H(Pz,Pz) correctly returns 0.
> >>
> >> *So you agree with the first step of the proof*?
> >> Only YES/NO are honest answers, NO requires a complete
> >> explanation.
> >
> > Answer me this, dear, why does Simulate have a u32 return type if it
> > can never return to its caller? You've fucked up, BIG TIME.
> >
> > /Flibble
> >
> >
>
> Simulate initially always returned 1, which it can always do for
> every input that halts. I removed this return to make it simpler. I
> should have converted the return type to void.
>
> Is H(Pz,Pz) correct to return 0?

Click here to read the complete article

Re: Does everyone agree with this halt status decision?

<tem1n9$1ii2g$3@dont-email.me>

copy mid

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

copy link Newsgroups: comp.theory

Path: i2pn2.org!i2pn.org!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: Does everyone agree with this halt status decision?
Date: Tue, 30 Aug 2022 17:07:36 -0500
Organization: A noiseless patient Spider
Lines: 219
Message-ID: <tem1n9$1ii2g$3@dont-email.me>
References: <tel8u5$1gels$1@dont-email.me>
<20220830160852.00003019@reddwarf.jmc.corp>
<EIedneB4tNystJP-nZ2dnZfqlJxh4p2d@giganews.com>
<20220830162355.00003a79@reddwarf.jmc.corp>
<O66dnYVHPYzpsJP-nZ2dnZfqlJxh4p2d@giganews.com>
<20220830180003.00004dae@reddwarf.jmc.corp> <telqq5$1i8ul$1@dont-email.me>
<20220830212813.000024dd@reddwarf.jmc.corp> <teltnk$1ii2g$1@dont-email.me>
<20220830220225.000000d8@reddwarf.jmc.corp> <telv47$1ii2g$2@dont-email.me>
<20220830225723.000018f3@reddwarf.jmc.corp>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Tue, 30 Aug 2022 22:07:37 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="c23d4a7c43a6eb8ef040166d41246eda";
logging-data="1656912"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+GU9oDU6Zh5lgQ22csZGEy"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.2.0
Cancel-Lock: sha1:3u4nzMuYkzQs5J8hvaJYoNbtJQc=
In-Reply-To: <20220830225723.000018f3@reddwarf.jmc.corp>
Content-Language: en-US

by: olcott - Tue, 30 Aug 2022 22:07 UTC

On 8/30/2022 4:57 PM, Mr Flibble wrote:
> On Tue, 30 Aug 2022 16:23:18 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> On 8/30/2022 4:02 PM, Mr Flibble wrote:
>>> On Tue, 30 Aug 2022 15:59:31 -0500
>>> olcott <polcott2@gmail.com> wrote:
>>>
>>>> On 8/30/2022 3:28 PM, Mr Flibble wrote:
>>>>> On Tue, 30 Aug 2022 15:09:40 -0500
>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>
>>>>>> On 8/30/2022 12:00 PM, Mr Flibble wrote:
>>>>>>> On Tue, 30 Aug 2022 10:32:03 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 8/30/2022 10:23 AM, Mr Flibble wrote:
>>>>>>>>> On Tue, 30 Aug 2022 10:13:52 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 8/30/2022 10:08 AM, Mr Flibble wrote:
>>>>>>>>>>> On Tue, 30 Aug 2022 10:04:36 -0500
>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> // direct execution of x(y) derives equivalent
>>>>>>>>>>>> // behavior to the simulation of x(y)
>>>>>>>>>>>> u32 Simulate(ptr x, ptr y)
>>>>>>>>>>>> {
>>>>>>>>>>>> x(y);
>>>>>>>>>>>> return 1;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>> {
>>>>>>>>>>>> Simulate(x, x);
>>>>>>>>>>>> return;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>> Output("Input_Halts = ", H(Px, Px));
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> _Simulate()
>>>>>>>>>>>> [000010b2](01) 55 push ebp
>>>>>>>>>>>> [000010b3](02) 8bec mov ebp,esp
>>>>>>>>>>>> [000010b5](03) 8b450c mov eax,[ebp+0c]
>>>>>>>>>>>> [000010b8](01) 50 push eax
>>>>>>>>>>>> [000010b9](03) ff5508 call dword [ebp+08]
>>>>>>>>>>>> [000010bc](03) 83c404 add esp,+04
>>>>>>>>>>>> [000010bf](05) b801000000 mov eax,00000001
>>>>>>>>>>>> [000010c4](01) 5d pop ebp
>>>>>>>>>>>> [000010c5](01) c3 ret
>>>>>>>>>>>> Size in bytes:(0020) [000010c5]
>>>>>>>>>>>>
>>>>>>>>>>>> _Px()
>>>>>>>>>>>> [00001102](01) 55 push ebp
>>>>>>>>>>>> [00001103](02) 8bec mov ebp,esp
>>>>>>>>>>>> [00001105](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>> [00001108](01) 50 push eax
>>>>>>>>>>>> [00001109](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>> [0000110c](01) 51 push ecx
>>>>>>>>>>>> [0000110d](05) e8a0ffffff call 000010b2
>>>>>>>>>>>> [00001112](03) 83c408 add esp,+08
>>>>>>>>>>>> [00001115](01) 5d pop ebp
>>>>>>>>>>>> [00001116](01) c3 ret
>>>>>>>>>>>> Size in bytes:(0021) [00001116]
>>>>>>>>>>>>
>>>>>>>>>>>> _main()
>>>>>>>>>>>> [00001122](01) 55 push ebp
>>>>>>>>>>>> [00001123](02) 8bec mov ebp,esp
>>>>>>>>>>>> [00001125](05) 6802110000 push 00001102
>>>>>>>>>>>> [0000112a](05) 6802110000 push 00001102
>>>>>>>>>>>> [0000112f](05) e85efdffff call 00000e92
>>>>>>>>>>>> [00001134](03) 83c408 add esp,+08
>>>>>>>>>>>> [00001137](01) 50 push eax
>>>>>>>>>>>> [00001138](05) 6863040000 push 00000463
>>>>>>>>>>>> [0000113d](05) e840f3ffff call 00000482
>>>>>>>>>>>> [00001142](03) 83c408 add esp,+08
>>>>>>>>>>>> [00001145](02) 33c0 xor eax,eax
>>>>>>>>>>>> [00001147](01) 5d pop ebp
>>>>>>>>>>>> [00001148](01) c3 ret
>>>>>>>>>>>> Size in bytes:(0039) [00001148]
>>>>>>>>>>>>
>>>>>>>>>>>> machine stack stack machine assembly
>>>>>>>>>>>> address address data code language
>>>>>>>>>>>> ======== ======== ======== =========
>>>>>>>>>>>> ============= [00001122][00101c15][00000000] 55
>>>>>>>>>>>> push ebp [00001123][00101c15][00000000] 8bec
>>>>>>>>>>>> mov ebp,esp [00001125][00101c11][00001102] 6802110000
>>>>>>>>>>>> push 00001102 [0000112a][00101c0d][00001102] 6802110000
>>>>>>>>>>>> push 00001102 [0000112f][00101c09][00001134] e85efdffff
>>>>>>>>>>>> call 00000e92 Address_of_H:e92
>>>>>>>>>>>>
>>>>>>>>>>>> H: Begin Simulation Execution Trace Stored at:111cc1
>>>>>>>>>>>> Address_of_H:e92
>>>>>>>>>>>> [00001102][00111cad][00111cb1] 55 push ebp
>>>>>>>>>>>> [00001103][00111cad][00111cb1] 8bec mov ebp,esp
>>>>>>>>>>>> [00001105][00111cad][00111cb1] 8b4508 mov
>>>>>>>>>>>> eax,[ebp+08] [00001108][00111ca9][00001102] 50
>>>>>>>>>>>> push eax [00001109][00111ca9][00001102] 8b4d08 mov
>>>>>>>>>>>> ecx,[ebp+08] [0000110c][00111ca5][00001102] 51
>>>>>>>>>>>> push ecx [0000110d][00111ca1][00001112] e8a0ffffff call
>>>>>>>>>>>> 000010b2 [000010b2][00111c9d][00111cad] 55 push
>>>>>>>>>>>> ebp [000010b3][00111c9d][00111cad] 8bec mov
>>>>>>>>>>>> ebp,esp [000010b5][00111c9d][00111cad] 8b450c mov
>>>>>>>>>>>> eax,[ebp+0c] [000010b8][00111c99][00001102] 50
>>>>>>>>>>>> push eax Calling:_Px()
>>>>>>>>>>>> Decode_Control_Flow_Instruction([00000008][00111c9d][00001102])
>>>>>>>>>>>> [000010b9][00111c95][000010bc] ff5508 call dword
>>>>>>>>>>>> [ebp+08] [00001102][00111c91][00111c9d] 55 push
>>>>>>>>>>>> ebp [00001103][00111c91][00111c9d] 8bec mov
>>>>>>>>>>>> ebp,esp [00001105][00111c91][00111c9d] 8b4508 mov
>>>>>>>>>>>> eax,[ebp+08] [00001108][00111c8d][00001102] 50
>>>>>>>>>>>> push eax [00001109][00111c8d][00001102] 8b4d08 mov
>>>>>>>>>>>> ecx,[ebp+08] [0000110c][00111c89][00001102] 51
>>>>>>>>>>>> push ecx [0000110d][00111c85][00001112] e8a0ffffff call
>>>>>>>>>>>> 000010b2 H: Infinite Recursion Detected Simulation Stopped
>>>>>>>>>>>>
>>>>>>>>>>>> [00001134][00101c15][00000000] 83c408 add esp,+08
>>>>>>>>>>>> [00001137][00101c11][00000000] 50 push eax
>>>>>>>>>>>> [00001138][00101c0d][00000463] 6863040000 push 00000463
>>>>>>>>>>>> [0000113d][00101c0d][00000463] e840f3ffff call 00000482
>>>>>>>>>>>> Input_Halts = 0
>>>>>>>>>>>> [00001142][00101c15][00000000] 83c408 add esp,+08
>>>>>>>>>>>> [00001145][00101c15][00000000] 33c0 xor eax,eax
>>>>>>>>>>>> [00001147][00101c19][00000018] 5d pop ebp
>>>>>>>>>>>> [00001148][00101c1d][00000000] c3 ret
>>>>>>>>>>>> Number of Instructions Executed(2195) == 33 Pages
>>>>>>>>>>>
>>>>>>>>>>> Px doesn't call Simulate, Px calls H. You have made the
>>>>>>>>>>> same error repeatedly.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Your Px does not call Simulate, mine does.
>>>>>>>>>> Call my Px Pz if this helps avoid the confusion.
>>>>>>>>>
>>>>>>>>> Pz doesn't call Simulate, Pz calls H. You have made the same
>>>>>>>>> error repeatedly.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> What is your basis for saying that?
>>>>>>>
>>>>>>> My basis for saying that is an observation that you are
>>>>>>> attempting to build some convoluted strawman whereby you can
>>>>>>> claim equivalence between H and Simulate so you can then
>>>>>>> erroneously claim that all simulating halt deciders are
>>>>>>> recursive and cannot return a value to their callers from
>>>>>>> within the simulation.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>>
>>>>>> So you are disagreeing with what I said on some other basis than
>>>>>> what I actually said: *that is the definition of dishonestly*
>>>>>
>>>>> OK dear. Carry on constructing your strawman, everyone will knock
>>>>> it down as usual.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> Failing to provide a YES/NO answer breaks an honest dialogue.
>>>>
>>>> Failing to fully explain all of the reasoning for a NO answer
>>>> breaks and honest dialogue.
>>>>
>>>> u32 Simulate(ptr x, ptr y)
>>>> {
>>>> x(y);
>>>> }
>>>>
>>>> void Pz(ptr x)
>>>> {
>>>> Simulate(x, x);
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", H(Pz, Pz));
>>>> }
>>>>
>>>> H(Pz,Pz) correctly returns 0.
>>>>
>>>> *So you agree with the first step of the proof*?
>>>> Only YES/NO are honest answers, NO requires a complete
>>>> explanation.
>>>
>>> Answer me this, dear, why does Simulate have a u32 return type if it
>>> can never return to its caller? You've fucked up, BIG TIME.
>>>
>>> /Flibble
>>>
>>>
>>
>> Simulate initially always returned 1, which it can always do for
>> every input that halts. I removed this return to make it simpler. I
>> should have converted the return type to void.
>>
>> Is H(Pz,Pz) correct to return 0?
>
> LOL.
>
> /Flibble
>

Click here to read the complete article

On Tue, 30 Aug 2022 17:07:36 -0500
olcott <polcott2@gmail.com> wrote:

> On 8/30/2022 4:57 PM, Mr Flibble wrote:
> > On Tue, 30 Aug 2022 16:23:18 -0500
> > olcott <polcott2@gmail.com> wrote:
> >
> >> On 8/30/2022 4:02 PM, Mr Flibble wrote:
> >>> On Tue, 30 Aug 2022 15:59:31 -0500
> >>> olcott <polcott2@gmail.com> wrote:
> >>>
> >>>> On 8/30/2022 3:28 PM, Mr Flibble wrote:
> >>>>> On Tue, 30 Aug 2022 15:09:40 -0500
> >>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>
> >>>>>> On 8/30/2022 12:00 PM, Mr Flibble wrote:
> >>>>>>> On Tue, 30 Aug 2022 10:32:03 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 8/30/2022 10:23 AM, Mr Flibble wrote:
> >>>>>>>>> On Tue, 30 Aug 2022 10:13:52 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 8/30/2022 10:08 AM, Mr Flibble wrote:
> >>>>>>>>>>> On Tue, 30 Aug 2022 10:04:36 -0500
> >>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>>>>>
> >>>>>>>>>>>> // direct execution of x(y) derives equivalent
> >>>>>>>>>>>> // behavior to the simulation of x(y)
> >>>>>>>>>>>> u32 Simulate(ptr x, ptr y)
> >>>>>>>>>>>> {
> >>>>>>>>>>>> x(y);
> >>>>>>>>>>>> return 1;
> >>>>>>>>>>>> }
> >>>>>>>>>>>>
> >>>>>>>>>>>> void Px(ptr x)
> >>>>>>>>>>>> {
> >>>>>>>>>>>> Simulate(x, x);
> >>>>>>>>>>>> return;
> >>>>>>>>>>>> }
> >>>>>>>>>>>>
> >>>>>>>>>>>> int main()
> >>>>>>>>>>>> {
> >>>>>>>>>>>> Output("Input_Halts = ", H(Px, Px));
> >>>>>>>>>>>> }
> >>>>>>>>>>>>
> >>>>>>>>>>>> _Simulate()
> >>>>>>>>>>>> [000010b2](01) 55 push ebp
> >>>>>>>>>>>> [000010b3](02) 8bec mov ebp,esp
> >>>>>>>>>>>> [000010b5](03) 8b450c mov eax,[ebp+0c]
> >>>>>>>>>>>> [000010b8](01) 50 push eax
> >>>>>>>>>>>> [000010b9](03) ff5508 call dword [ebp+08]
> >>>>>>>>>>>> [000010bc](03) 83c404 add esp,+04
> >>>>>>>>>>>> [000010bf](05) b801000000 mov eax,00000001
> >>>>>>>>>>>> [000010c4](01) 5d pop ebp
> >>>>>>>>>>>> [000010c5](01) c3 ret
> >>>>>>>>>>>> Size in bytes:(0020) [000010c5]
> >>>>>>>>>>>>
> >>>>>>>>>>>> _Px()
> >>>>>>>>>>>> [00001102](01) 55 push ebp
> >>>>>>>>>>>> [00001103](02) 8bec mov ebp,esp
> >>>>>>>>>>>> [00001105](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>> [00001108](01) 50 push eax
> >>>>>>>>>>>> [00001109](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>> [0000110c](01) 51 push ecx
> >>>>>>>>>>>> [0000110d](05) e8a0ffffff call 000010b2
> >>>>>>>>>>>> [00001112](03) 83c408 add esp,+08
> >>>>>>>>>>>> [00001115](01) 5d pop ebp
> >>>>>>>>>>>> [00001116](01) c3 ret
> >>>>>>>>>>>> Size in bytes:(0021) [00001116]
> >>>>>>>>>>>>
> >>>>>>>>>>>> _main()
> >>>>>>>>>>>> [00001122](01) 55 push ebp
> >>>>>>>>>>>> [00001123](02) 8bec mov ebp,esp
> >>>>>>>>>>>> [00001125](05) 6802110000 push 00001102
> >>>>>>>>>>>> [0000112a](05) 6802110000 push 00001102
> >>>>>>>>>>>> [0000112f](05) e85efdffff call 00000e92
> >>>>>>>>>>>> [00001134](03) 83c408 add esp,+08
> >>>>>>>>>>>> [00001137](01) 50 push eax
> >>>>>>>>>>>> [00001138](05) 6863040000 push 00000463
> >>>>>>>>>>>> [0000113d](05) e840f3ffff call 00000482
> >>>>>>>>>>>> [00001142](03) 83c408 add esp,+08
> >>>>>>>>>>>> [00001145](02) 33c0 xor eax,eax
> >>>>>>>>>>>> [00001147](01) 5d pop ebp
> >>>>>>>>>>>> [00001148](01) c3 ret
> >>>>>>>>>>>> Size in bytes:(0039) [00001148]
> >>>>>>>>>>>>
> >>>>>>>>>>>> machine stack stack machine assembly
> >>>>>>>>>>>> address address data code language
> >>>>>>>>>>>> ======== ======== ======== =========
> >>>>>>>>>>>> ============= [00001122][00101c15][00000000] 55
> >>>>>>>>>>>> push ebp [00001123][00101c15][00000000] 8bec
> >>>>>>>>>>>> mov ebp,esp [00001125][00101c11][00001102] 6802110000
> >>>>>>>>>>>> push 00001102 [0000112a][00101c0d][00001102] 6802110000
> >>>>>>>>>>>> push 00001102 [0000112f][00101c09][00001134] e85efdffff
> >>>>>>>>>>>> call 00000e92 Address_of_H:e92
> >>>>>>>>>>>>
> >>>>>>>>>>>> H: Begin Simulation Execution Trace Stored at:111cc1
> >>>>>>>>>>>> Address_of_H:e92
> >>>>>>>>>>>> [00001102][00111cad][00111cb1] 55 push ebp
> >>>>>>>>>>>> [00001103][00111cad][00111cb1] 8bec mov ebp,esp
> >>>>>>>>>>>> [00001105][00111cad][00111cb1] 8b4508 mov
> >>>>>>>>>>>> eax,[ebp+08] [00001108][00111ca9][00001102] 50
> >>>>>>>>>>>> push eax [00001109][00111ca9][00001102] 8b4d08
> >>>>>>>>>>>> mov ecx,[ebp+08] [0000110c][00111ca5][00001102] 51
> >>>>>>>>>>>> push ecx [0000110d][00111ca1][00001112] e8a0ffffff
> >>>>>>>>>>>> call 000010b2 [000010b2][00111c9d][00111cad] 55
> >>>>>>>>>>>> push ebp [000010b3][00111c9d][00111cad] 8bec
> >>>>>>>>>>>> mov ebp,esp [000010b5][00111c9d][00111cad] 8b450c
> >>>>>>>>>>>> mov eax,[ebp+0c] [000010b8][00111c99][00001102] 50
> >>>>>>>>>>>> push eax Calling:_Px()
> >>>>>>>>>>>> Decode_Control_Flow_Instruction([00000008][00111c9d][00001102])
> >>>>>>>>>>>> [000010b9][00111c95][000010bc] ff5508 call dword
> >>>>>>>>>>>> [ebp+08] [00001102][00111c91][00111c9d] 55
> >>>>>>>>>>>> push ebp [00001103][00111c91][00111c9d] 8bec
> >>>>>>>>>>>> mov ebp,esp [00001105][00111c91][00111c9d] 8b4508
> >>>>>>>>>>>> mov eax,[ebp+08] [00001108][00111c8d][00001102] 50
> >>>>>>>>>>>> push eax [00001109][00111c8d][00001102] 8b4d08
> >>>>>>>>>>>> mov ecx,[ebp+08] [0000110c][00111c89][00001102] 51
> >>>>>>>>>>>> push ecx [0000110d][00111c85][00001112] e8a0ffffff
> >>>>>>>>>>>> call 000010b2 H: Infinite Recursion Detected Simulation
> >>>>>>>>>>>> Stopped
> >>>>>>>>>>>>
> >>>>>>>>>>>> [00001134][00101c15][00000000] 83c408 add esp,+08
> >>>>>>>>>>>> [00001137][00101c11][00000000] 50 push eax
> >>>>>>>>>>>> [00001138][00101c0d][00000463] 6863040000 push
> >>>>>>>>>>>> 00000463 [0000113d][00101c0d][00000463] e840f3ffff
> >>>>>>>>>>>> call 00000482 Input_Halts = 0
> >>>>>>>>>>>> [00001142][00101c15][00000000] 83c408 add esp,+08
> >>>>>>>>>>>> [00001145][00101c15][00000000] 33c0 xor eax,eax
> >>>>>>>>>>>> [00001147][00101c19][00000018] 5d pop ebp
> >>>>>>>>>>>> [00001148][00101c1d][00000000] c3 ret
> >>>>>>>>>>>> Number of Instructions Executed(2195) == 33 Pages
> >>>>>>>>>>>
> >>>>>>>>>>> Px doesn't call Simulate, Px calls H. You have made the
> >>>>>>>>>>> same error repeatedly.
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> Your Px does not call Simulate, mine does.
> >>>>>>>>>> Call my Px Pz if this helps avoid the confusion.
> >>>>>>>>>
> >>>>>>>>> Pz doesn't call Simulate, Pz calls H. You have made the same
> >>>>>>>>> error repeatedly.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> What is your basis for saying that?
> >>>>>>>
> >>>>>>> My basis for saying that is an observation that you are
> >>>>>>> attempting to build some convoluted strawman whereby you can
> >>>>>>> claim equivalence between H and Simulate so you can then
> >>>>>>> erroneously claim that all simulating halt deciders are
> >>>>>>> recursive and cannot return a value to their callers from
> >>>>>>> within the simulation.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>>
> >>>>>> So you are disagreeing with what I said on some other basis
> >>>>>> than what I actually said: *that is the definition of
> >>>>>> dishonestly*
> >>>>>
> >>>>> OK dear. Carry on constructing your strawman, everyone will
> >>>>> knock it down as usual.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> Failing to provide a YES/NO answer breaks an honest dialogue.
> >>>>
> >>>> Failing to fully explain all of the reasoning for a NO answer
> >>>> breaks and honest dialogue.
> >>>>
> >>>> u32 Simulate(ptr x, ptr y)
> >>>> {
> >>>> x(y);
> >>>> }
> >>>>
> >>>> void Pz(ptr x)
> >>>> {
> >>>> Simulate(x, x);
> >>>> }
> >>>>
> >>>> int main()
> >>>> {
> >>>> Output("Input_Halts = ", H(Pz, Pz));
> >>>> }
> >>>>
> >>>> H(Pz,Pz) correctly returns 0.
> >>>>
> >>>> *So you agree with the first step of the proof*?
> >>>> Only YES/NO are honest answers, NO requires a complete
> >>>> explanation.
> >>>
> >>> Answer me this, dear, why does Simulate have a u32 return type if
> >>> it can never return to its caller? You've fucked up, BIG TIME.
> >>>
> >>> /Flibble
> >>>
> >>>
> >>
> >> Simulate initially always returned 1, which it can always do for
> >> every input that halts. I removed this return to make it simpler. I
> >> should have converted the return type to void.
> >>
> >> Is H(Pz,Pz) correct to return 0?
> >
> > LOL.
> >
> > /Flibble
> >
>
> In other words you have no intention of an honest dialogue.

Click here to read the complete article

Re: Does everyone agree with this halt status decision?

<tem39p$1ii2g$4@dont-email.me>

copy mid

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

copy link Newsgroups: comp.theory

Path: i2pn2.org!i2pn.org!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: Does everyone agree with this halt status decision?
Date: Tue, 30 Aug 2022 17:34:32 -0500
Organization: A noiseless patient Spider
Lines: 234
Message-ID: <tem39p$1ii2g$4@dont-email.me>
References: <tel8u5$1gels$1@dont-email.me>
<20220830160852.00003019@reddwarf.jmc.corp>
<EIedneB4tNystJP-nZ2dnZfqlJxh4p2d@giganews.com>
<20220830162355.00003a79@reddwarf.jmc.corp>
<O66dnYVHPYzpsJP-nZ2dnZfqlJxh4p2d@giganews.com>
<20220830180003.00004dae@reddwarf.jmc.corp> <telqq5$1i8ul$1@dont-email.me>
<20220830212813.000024dd@reddwarf.jmc.corp> <teltnk$1ii2g$1@dont-email.me>
<20220830220225.000000d8@reddwarf.jmc.corp> <telv47$1ii2g$2@dont-email.me>
<20220830225723.000018f3@reddwarf.jmc.corp> <tem1n9$1ii2g$3@dont-email.me>
<20220830232027.00001ba6@reddwarf.jmc.corp>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Tue, 30 Aug 2022 22:34:33 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="c23d4a7c43a6eb8ef040166d41246eda";
logging-data="1656912"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18INXrbc/2AsLvBMIL87MWj"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.2.0
Cancel-Lock: sha1:Mk/A9ML9S9epBGIRqEZ2AR0TTXE=
In-Reply-To: <20220830232027.00001ba6@reddwarf.jmc.corp>
Content-Language: en-US

by: olcott - Tue, 30 Aug 2022 22:34 UTC

On 8/30/2022 5:20 PM, Mr Flibble wrote:
> On Tue, 30 Aug 2022 17:07:36 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> On 8/30/2022 4:57 PM, Mr Flibble wrote:
>>> On Tue, 30 Aug 2022 16:23:18 -0500
>>> olcott <polcott2@gmail.com> wrote:
>>>
>>>> On 8/30/2022 4:02 PM, Mr Flibble wrote:
>>>>> On Tue, 30 Aug 2022 15:59:31 -0500
>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>
>>>>>> On 8/30/2022 3:28 PM, Mr Flibble wrote:
>>>>>>> On Tue, 30 Aug 2022 15:09:40 -0500
>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>
>>>>>>>> On 8/30/2022 12:00 PM, Mr Flibble wrote:
>>>>>>>>> On Tue, 30 Aug 2022 10:32:03 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 8/30/2022 10:23 AM, Mr Flibble wrote:
>>>>>>>>>>> On Tue, 30 Aug 2022 10:13:52 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 8/30/2022 10:08 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On Tue, 30 Aug 2022 10:04:36 -0500
>>>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> // direct execution of x(y) derives equivalent
>>>>>>>>>>>>>> // behavior to the simulation of x(y)
>>>>>>>>>>>>>> u32 Simulate(ptr x, ptr y)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> x(y);
>>>>>>>>>>>>>> return 1;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> Simulate(x, x);
>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> Output("Input_Halts = ", H(Px, Px));
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> _Simulate()
>>>>>>>>>>>>>> [000010b2](01) 55 push ebp
>>>>>>>>>>>>>> [000010b3](02) 8bec mov ebp,esp
>>>>>>>>>>>>>> [000010b5](03) 8b450c mov eax,[ebp+0c]
>>>>>>>>>>>>>> [000010b8](01) 50 push eax
>>>>>>>>>>>>>> [000010b9](03) ff5508 call dword [ebp+08]
>>>>>>>>>>>>>> [000010bc](03) 83c404 add esp,+04
>>>>>>>>>>>>>> [000010bf](05) b801000000 mov eax,00000001
>>>>>>>>>>>>>> [000010c4](01) 5d pop ebp
>>>>>>>>>>>>>> [000010c5](01) c3 ret
>>>>>>>>>>>>>> Size in bytes:(0020) [000010c5]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> _Px()
>>>>>>>>>>>>>> [00001102](01) 55 push ebp
>>>>>>>>>>>>>> [00001103](02) 8bec mov ebp,esp
>>>>>>>>>>>>>> [00001105](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>> [00001108](01) 50 push eax
>>>>>>>>>>>>>> [00001109](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>> [0000110c](01) 51 push ecx
>>>>>>>>>>>>>> [0000110d](05) e8a0ffffff call 000010b2
>>>>>>>>>>>>>> [00001112](03) 83c408 add esp,+08
>>>>>>>>>>>>>> [00001115](01) 5d pop ebp
>>>>>>>>>>>>>> [00001116](01) c3 ret
>>>>>>>>>>>>>> Size in bytes:(0021) [00001116]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> _main()
>>>>>>>>>>>>>> [00001122](01) 55 push ebp
>>>>>>>>>>>>>> [00001123](02) 8bec mov ebp,esp
>>>>>>>>>>>>>> [00001125](05) 6802110000 push 00001102
>>>>>>>>>>>>>> [0000112a](05) 6802110000 push 00001102
>>>>>>>>>>>>>> [0000112f](05) e85efdffff call 00000e92
>>>>>>>>>>>>>> [00001134](03) 83c408 add esp,+08
>>>>>>>>>>>>>> [00001137](01) 50 push eax
>>>>>>>>>>>>>> [00001138](05) 6863040000 push 00000463
>>>>>>>>>>>>>> [0000113d](05) e840f3ffff call 00000482
>>>>>>>>>>>>>> [00001142](03) 83c408 add esp,+08
>>>>>>>>>>>>>> [00001145](02) 33c0 xor eax,eax
>>>>>>>>>>>>>> [00001147](01) 5d pop ebp
>>>>>>>>>>>>>> [00001148](01) c3 ret
>>>>>>>>>>>>>> Size in bytes:(0039) [00001148]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> machine stack stack machine assembly
>>>>>>>>>>>>>> address address data code language
>>>>>>>>>>>>>> ======== ======== ======== =========
>>>>>>>>>>>>>> ============= [00001122][00101c15][00000000] 55
>>>>>>>>>>>>>> push ebp [00001123][00101c15][00000000] 8bec
>>>>>>>>>>>>>> mov ebp,esp [00001125][00101c11][00001102] 6802110000
>>>>>>>>>>>>>> push 00001102 [0000112a][00101c0d][00001102] 6802110000
>>>>>>>>>>>>>> push 00001102 [0000112f][00101c09][00001134] e85efdffff
>>>>>>>>>>>>>> call 00000e92 Address_of_H:e92
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H: Begin Simulation Execution Trace Stored at:111cc1
>>>>>>>>>>>>>> Address_of_H:e92
>>>>>>>>>>>>>> [00001102][00111cad][00111cb1] 55 push ebp
>>>>>>>>>>>>>> [00001103][00111cad][00111cb1] 8bec mov ebp,esp
>>>>>>>>>>>>>> [00001105][00111cad][00111cb1] 8b4508 mov
>>>>>>>>>>>>>> eax,[ebp+08] [00001108][00111ca9][00001102] 50
>>>>>>>>>>>>>> push eax [00001109][00111ca9][00001102] 8b4d08
>>>>>>>>>>>>>> mov ecx,[ebp+08] [0000110c][00111ca5][00001102] 51
>>>>>>>>>>>>>> push ecx [0000110d][00111ca1][00001112] e8a0ffffff
>>>>>>>>>>>>>> call 000010b2 [000010b2][00111c9d][00111cad] 55
>>>>>>>>>>>>>> push ebp [000010b3][00111c9d][00111cad] 8bec
>>>>>>>>>>>>>> mov ebp,esp [000010b5][00111c9d][00111cad] 8b450c
>>>>>>>>>>>>>> mov eax,[ebp+0c] [000010b8][00111c99][00001102] 50
>>>>>>>>>>>>>> push eax Calling:_Px()
>>>>>>>>>>>>>> Decode_Control_Flow_Instruction([00000008][00111c9d][00001102])
>>>>>>>>>>>>>> [000010b9][00111c95][000010bc] ff5508 call dword
>>>>>>>>>>>>>> [ebp+08] [00001102][00111c91][00111c9d] 55
>>>>>>>>>>>>>> push ebp [00001103][00111c91][00111c9d] 8bec
>>>>>>>>>>>>>> mov ebp,esp [00001105][00111c91][00111c9d] 8b4508
>>>>>>>>>>>>>> mov eax,[ebp+08] [00001108][00111c8d][00001102] 50
>>>>>>>>>>>>>> push eax [00001109][00111c8d][00001102] 8b4d08
>>>>>>>>>>>>>> mov ecx,[ebp+08] [0000110c][00111c89][00001102] 51
>>>>>>>>>>>>>> push ecx [0000110d][00111c85][00001112] e8a0ffffff
>>>>>>>>>>>>>> call 000010b2 H: Infinite Recursion Detected Simulation
>>>>>>>>>>>>>> Stopped
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> [00001134][00101c15][00000000] 83c408 add esp,+08
>>>>>>>>>>>>>> [00001137][00101c11][00000000] 50 push eax
>>>>>>>>>>>>>> [00001138][00101c0d][00000463] 6863040000 push
>>>>>>>>>>>>>> 00000463 [0000113d][00101c0d][00000463] e840f3ffff
>>>>>>>>>>>>>> call 00000482 Input_Halts = 0
>>>>>>>>>>>>>> [00001142][00101c15][00000000] 83c408 add esp,+08
>>>>>>>>>>>>>> [00001145][00101c15][00000000] 33c0 xor eax,eax
>>>>>>>>>>>>>> [00001147][00101c19][00000018] 5d pop ebp
>>>>>>>>>>>>>> [00001148][00101c1d][00000000] c3 ret
>>>>>>>>>>>>>> Number of Instructions Executed(2195) == 33 Pages
>>>>>>>>>>>>>
>>>>>>>>>>>>> Px doesn't call Simulate, Px calls H. You have made the
>>>>>>>>>>>>> same error repeatedly.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Your Px does not call Simulate, mine does.
>>>>>>>>>>>> Call my Px Pz if this helps avoid the confusion.
>>>>>>>>>>>
>>>>>>>>>>> Pz doesn't call Simulate, Pz calls H. You have made the same
>>>>>>>>>>> error repeatedly.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> What is your basis for saying that?
>>>>>>>>>
>>>>>>>>> My basis for saying that is an observation that you are
>>>>>>>>> attempting to build some convoluted strawman whereby you can
>>>>>>>>> claim equivalence between H and Simulate so you can then
>>>>>>>>> erroneously claim that all simulating halt deciders are
>>>>>>>>> recursive and cannot return a value to their callers from
>>>>>>>>> within the simulation.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> So you are disagreeing with what I said on some other basis
>>>>>>>> than what I actually said: *that is the definition of
>>>>>>>> dishonestly*
>>>>>>>
>>>>>>> OK dear. Carry on constructing your strawman, everyone will
>>>>>>> knock it down as usual.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> Failing to provide a YES/NO answer breaks an honest dialogue.
>>>>>>
>>>>>> Failing to fully explain all of the reasoning for a NO answer
>>>>>> breaks and honest dialogue.
>>>>>>
>>>>>> u32 Simulate(ptr x, ptr y)
>>>>>> {
>>>>>> x(y);
>>>>>> }
>>>>>>
>>>>>> void Pz(ptr x)
>>>>>> {
>>>>>> Simulate(x, x);
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> Output("Input_Halts = ", H(Pz, Pz));
>>>>>> }
>>>>>>
>>>>>> H(Pz,Pz) correctly returns 0.
>>>>>>
>>>>>> *So you agree with the first step of the proof*?
>>>>>> Only YES/NO are honest answers, NO requires a complete
>>>>>> explanation.
>>>>>
>>>>> Answer me this, dear, why does Simulate have a u32 return type if
>>>>> it can never return to its caller? You've fucked up, BIG TIME.
>>>>>
>>>>> /Flibble
>>>>>
>>>>>
>>>>
>>>> Simulate initially always returned 1, which it can always do for
>>>> every input that halts. I removed this return to make it simpler. I
>>>> should have converted the return type to void.
>>>>
>>>> Is H(Pz,Pz) correct to return 0?
>>>
>>> LOL.
>>>
>>> /Flibble
>>>
>>
>> In other words you have no intention of an honest dialogue.
>
> When people engage you with honest dialog your response is more or less
> always dishonest.
>
> /Flibble

Click here to read the complete article

On Tue, 30 Aug 2022 17:34:32 -0500
olcott <polcott2@gmail.com> wrote:

> On 8/30/2022 5:20 PM, Mr Flibble wrote:
> > On Tue, 30 Aug 2022 17:07:36 -0500
> > olcott <polcott2@gmail.com> wrote:
> >
> >> On 8/30/2022 4:57 PM, Mr Flibble wrote:
> >>> On Tue, 30 Aug 2022 16:23:18 -0500
> >>> olcott <polcott2@gmail.com> wrote:
> >>>
> >>>> On 8/30/2022 4:02 PM, Mr Flibble wrote:
> >>>>> On Tue, 30 Aug 2022 15:59:31 -0500
> >>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>
> >>>>>> On 8/30/2022 3:28 PM, Mr Flibble wrote:
> >>>>>>> On Tue, 30 Aug 2022 15:09:40 -0500
> >>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>
> >>>>>>>> On 8/30/2022 12:00 PM, Mr Flibble wrote:
> >>>>>>>>> On Tue, 30 Aug 2022 10:32:03 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 8/30/2022 10:23 AM, Mr Flibble wrote:
> >>>>>>>>>>> On Tue, 30 Aug 2022 10:13:52 -0500
> >>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>
> >>>>>>>>>>>> On 8/30/2022 10:08 AM, Mr Flibble wrote:
> >>>>>>>>>>>>> On Tue, 30 Aug 2022 10:04:36 -0500
> >>>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> // direct execution of x(y) derives equivalent
> >>>>>>>>>>>>>> // behavior to the simulation of x(y)
> >>>>>>>>>>>>>> u32 Simulate(ptr x, ptr y)
> >>>>>>>>>>>>>> {
> >>>>>>>>>>>>>> x(y);
> >>>>>>>>>>>>>> return 1;
> >>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> void Px(ptr x)
> >>>>>>>>>>>>>> {
> >>>>>>>>>>>>>> Simulate(x, x);
> >>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>> {
> >>>>>>>>>>>>>> Output("Input_Halts = ", H(Px, Px));
> >>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> _Simulate()
> >>>>>>>>>>>>>> [000010b2](01) 55 push ebp
> >>>>>>>>>>>>>> [000010b3](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>> [000010b5](03) 8b450c mov eax,[ebp+0c]
> >>>>>>>>>>>>>> [000010b8](01) 50 push eax
> >>>>>>>>>>>>>> [000010b9](03) ff5508 call dword [ebp+08]
> >>>>>>>>>>>>>> [000010bc](03) 83c404 add esp,+04
> >>>>>>>>>>>>>> [000010bf](05) b801000000 mov eax,00000001
> >>>>>>>>>>>>>> [000010c4](01) 5d pop ebp
> >>>>>>>>>>>>>> [000010c5](01) c3 ret
> >>>>>>>>>>>>>> Size in bytes:(0020) [000010c5]
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> _Px()
> >>>>>>>>>>>>>> [00001102](01) 55 push ebp
> >>>>>>>>>>>>>> [00001103](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>> [00001105](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>>> [00001108](01) 50 push eax
> >>>>>>>>>>>>>> [00001109](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>>>> [0000110c](01) 51 push ecx
> >>>>>>>>>>>>>> [0000110d](05) e8a0ffffff call 000010b2
> >>>>>>>>>>>>>> [00001112](03) 83c408 add esp,+08
> >>>>>>>>>>>>>> [00001115](01) 5d pop ebp
> >>>>>>>>>>>>>> [00001116](01) c3 ret
> >>>>>>>>>>>>>> Size in bytes:(0021) [00001116]
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> _main()
> >>>>>>>>>>>>>> [00001122](01) 55 push ebp
> >>>>>>>>>>>>>> [00001123](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>> [00001125](05) 6802110000 push 00001102
> >>>>>>>>>>>>>> [0000112a](05) 6802110000 push 00001102
> >>>>>>>>>>>>>> [0000112f](05) e85efdffff call 00000e92
> >>>>>>>>>>>>>> [00001134](03) 83c408 add esp,+08
> >>>>>>>>>>>>>> [00001137](01) 50 push eax
> >>>>>>>>>>>>>> [00001138](05) 6863040000 push 00000463
> >>>>>>>>>>>>>> [0000113d](05) e840f3ffff call 00000482
> >>>>>>>>>>>>>> [00001142](03) 83c408 add esp,+08
> >>>>>>>>>>>>>> [00001145](02) 33c0 xor eax,eax
> >>>>>>>>>>>>>> [00001147](01) 5d pop ebp
> >>>>>>>>>>>>>> [00001148](01) c3 ret
> >>>>>>>>>>>>>> Size in bytes:(0039) [00001148]
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> machine stack stack machine
> >>>>>>>>>>>>>> assembly address address data code
> >>>>>>>>>>>>>> language ======== ======== ======== =========
> >>>>>>>>>>>>>> ============= [00001122][00101c15][00000000] 55
> >>>>>>>>>>>>>> push ebp [00001123][00101c15][00000000] 8bec
> >>>>>>>>>>>>>> mov ebp,esp [00001125][00101c11][00001102] 6802110000
> >>>>>>>>>>>>>> push 00001102 [0000112a][00101c0d][00001102] 6802110000
> >>>>>>>>>>>>>> push 00001102 [0000112f][00101c09][00001134]
> >>>>>>>>>>>>>> e85efdffff call 00000e92 Address_of_H:e92
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> H: Begin Simulation Execution Trace Stored at:111cc1
> >>>>>>>>>>>>>> Address_of_H:e92
> >>>>>>>>>>>>>> [00001102][00111cad][00111cb1] 55 push ebp
> >>>>>>>>>>>>>> [00001103][00111cad][00111cb1] 8bec mov
> >>>>>>>>>>>>>> ebp,esp [00001105][00111cad][00111cb1] 8b4508
> >>>>>>>>>>>>>> mov eax,[ebp+08] [00001108][00111ca9][00001102] 50
> >>>>>>>>>>>>>> push eax [00001109][00111ca9][00001102] 8b4d08
> >>>>>>>>>>>>>> mov ecx,[ebp+08] [0000110c][00111ca5][00001102] 51
> >>>>>>>>>>>>>> push ecx [0000110d][00111ca1][00001112] e8a0ffffff
> >>>>>>>>>>>>>> call 000010b2 [000010b2][00111c9d][00111cad] 55
> >>>>>>>>>>>>>> push ebp [000010b3][00111c9d][00111cad] 8bec
> >>>>>>>>>>>>>> mov ebp,esp [000010b5][00111c9d][00111cad] 8b450c
> >>>>>>>>>>>>>> mov eax,[ebp+0c] [000010b8][00111c99][00001102] 50
> >>>>>>>>>>>>>> push eax Calling:_Px()
> >>>>>>>>>>>>>> Decode_Control_Flow_Instruction([00000008][00111c9d][00001102])
> >>>>>>>>>>>>>> [000010b9][00111c95][000010bc] ff5508 call
> >>>>>>>>>>>>>> dword [ebp+08] [00001102][00111c91][00111c9d] 55
> >>>>>>>>>>>>>> push ebp [00001103][00111c91][00111c9d] 8bec
> >>>>>>>>>>>>>> mov ebp,esp [00001105][00111c91][00111c9d] 8b4508
> >>>>>>>>>>>>>> mov eax,[ebp+08] [00001108][00111c8d][00001102] 50
> >>>>>>>>>>>>>> push eax [00001109][00111c8d][00001102] 8b4d08
> >>>>>>>>>>>>>> mov ecx,[ebp+08] [0000110c][00111c89][00001102] 51
> >>>>>>>>>>>>>> push ecx [0000110d][00111c85][00001112] e8a0ffffff
> >>>>>>>>>>>>>> call 000010b2 H: Infinite Recursion Detected Simulation
> >>>>>>>>>>>>>> Stopped
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> [00001134][00101c15][00000000] 83c408 add
> >>>>>>>>>>>>>> esp,+08 [00001137][00101c11][00000000] 50
> >>>>>>>>>>>>>> push eax [00001138][00101c0d][00000463] 6863040000
> >>>>>>>>>>>>>> push 00000463 [0000113d][00101c0d][00000463] e840f3ffff
> >>>>>>>>>>>>>> call 00000482 Input_Halts = 0
> >>>>>>>>>>>>>> [00001142][00101c15][00000000] 83c408 add
> >>>>>>>>>>>>>> esp,+08 [00001145][00101c15][00000000] 33c0
> >>>>>>>>>>>>>> xor eax,eax [00001147][00101c19][00000018] 5d
> >>>>>>>>>>>>>> pop ebp [00001148][00101c1d][00000000] c3
> >>>>>>>>>>>>>> ret Number of Instructions Executed(2195) == 33
> >>>>>>>>>>>>>> Pages
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Px doesn't call Simulate, Px calls H. You have made the
> >>>>>>>>>>>>> same error repeatedly.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> Your Px does not call Simulate, mine does.
> >>>>>>>>>>>> Call my Px Pz if this helps avoid the confusion.
> >>>>>>>>>>>
> >>>>>>>>>>> Pz doesn't call Simulate, Pz calls H. You have made the
> >>>>>>>>>>> same error repeatedly.
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> What is your basis for saying that?
> >>>>>>>>>
> >>>>>>>>> My basis for saying that is an observation that you are
> >>>>>>>>> attempting to build some convoluted strawman whereby you can
> >>>>>>>>> claim equivalence between H and Simulate so you can then
> >>>>>>>>> erroneously claim that all simulating halt deciders are
> >>>>>>>>> recursive and cannot return a value to their callers from
> >>>>>>>>> within the simulation.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>>
> >>>>>>>> So you are disagreeing with what I said on some other basis
> >>>>>>>> than what I actually said: *that is the definition of
> >>>>>>>> dishonestly*
> >>>>>>>
> >>>>>>> OK dear. Carry on constructing your strawman, everyone will
> >>>>>>> knock it down as usual.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> Failing to provide a YES/NO answer breaks an honest dialogue.
> >>>>>>
> >>>>>> Failing to fully explain all of the reasoning for a NO answer
> >>>>>> breaks and honest dialogue.
> >>>>>>
> >>>>>> u32 Simulate(ptr x, ptr y)
> >>>>>> {
> >>>>>> x(y);
> >>>>>> }
> >>>>>>
> >>>>>> void Pz(ptr x)
> >>>>>> {
> >>>>>> Simulate(x, x);
> >>>>>> }
> >>>>>>
> >>>>>> int main()
> >>>>>> {
> >>>>>> Output("Input_Halts = ", H(Pz, Pz));
> >>>>>> }
> >>>>>>
> >>>>>> H(Pz,Pz) correctly returns 0.
> >>>>>>
> >>>>>> *So you agree with the first step of the proof*?
> >>>>>> Only YES/NO are honest answers, NO requires a complete
> >>>>>> explanation.
> >>>>>
> >>>>> Answer me this, dear, why does Simulate have a u32 return type
> >>>>> if it can never return to its caller? You've fucked up, BIG
> >>>>> TIME.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>>
> >>>>
> >>>> Simulate initially always returned 1, which it can always do for
> >>>> every input that halts. I removed this return to make it
> >>>> simpler. I should have converted the return type to void.
> >>>>
> >>>> Is H(Pz,Pz) correct to return 0?
> >>>
> >>> LOL.
> >>>
> >>> /Flibble
> >>>
> >>
> >> In other words you have no intention of an honest dialogue.
> >
> > When people engage you with honest dialog your response is more or
> > less always dishonest.
> >
> > /Flibble
>
> When I go though my proof point-by-point people always find some way
> to dodge these points with one form of misdirection or another as you
> are doing.

Click here to read the complete article

IF Px REALLY does call Simulate, whether it is the simulate you show
(which doesn't actually simulates, but just calls its input), then Yes,
THAT Px is Non-Halting.

Just to cut your apparent deception off, When you change Px to call H, H
can't put the SImulate back, becuase H is not the same as Simulate, even
if it is supppsed to simulate its input until it can prove the input to
be non-halting.

That is because such an H is Halting, but Simulate of the same input is
non-halting, thus they are different functions, and not equivalent.

On 8/30/22 11:04 AM, olcott wrote:
> // direct execution of x(y) derives equivalent
> // behavior to the simulation of x(y)
> u32 Simulate(ptr x, ptr y)
> {
> x(y);
> return 1;
> }
>
> void Px(ptr x)
> {
> Simulate(x, x);
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", H(Px, Px));
> }
>
> _Simulate()
> [000010b2](01) 55             push ebp
> [000010b3](02) 8bec           mov ebp,esp
> [000010b5](03) 8b450c         mov eax,[ebp+0c]
> [000010b8](01) 50             push eax
> [000010b9](03) ff5508         call dword [ebp+08]
> [000010bc](03) 83c404         add esp,+04
> [000010bf](05) b801000000     mov eax,00000001
> [000010c4](01) 5d             pop ebp
> [000010c5](01) c3             ret
> Size in bytes:(0020) [000010c5]
>
> _Px()
> [00001102](01) 55             push ebp
> [00001103](02) 8bec           mov ebp,esp
> [00001105](03) 8b4508         mov eax,[ebp+08]
> [00001108](01) 50             push eax
> [00001109](03) 8b4d08         mov ecx,[ebp+08]
> [0000110c](01) 51             push ecx
> [0000110d](05) e8a0ffffff     call 000010b2
> [00001112](03) 83c408         add esp,+08
> [00001115](01) 5d             pop ebp
> [00001116](01) c3             ret
> Size in bytes:(0021) [00001116]
>
> _main()
> [00001122](01) 55             push ebp
> [00001123](02) 8bec           mov ebp,esp
> [00001125](05) 6802110000     push 00001102
> [0000112a](05) 6802110000     push 00001102
> [0000112f](05) e85efdffff     call 00000e92
> [00001134](03) 83c408         add esp,+08
> [00001137](01) 50             push eax
> [00001138](05) 6863040000     push 00000463
> [0000113d](05) e840f3ffff     call 00000482
> [00001142](03) 83c408         add esp,+08
> [00001145](02) 33c0           xor eax,eax
> [00001147](01) 5d             pop ebp
> [00001148](01) c3             ret
> Size in bytes:(0039) [00001148]
>
> machine   stack     stack     machine    assembly
> address   address   data      code       language
> ======== ======== ======== ========= =============
> [00001122][00101c15][00000000] 55             push ebp
> [00001123][00101c15][00000000] 8bec           mov ebp,esp
> [00001125][00101c11][00001102] 6802110000     push 00001102
> [0000112a][00101c0d][00001102] 6802110000     push 00001102
> [0000112f][00101c09][00001134] e85efdffff     call 00000e92
> Address_of_H:e92
>
> H: Begin Simulation   Execution Trace Stored at:111cc1
> Address_of_H:e92
> [00001102][00111cad][00111cb1] 55             push ebp
> [00001103][00111cad][00111cb1] 8bec           mov ebp,esp
> [00001105][00111cad][00111cb1] 8b4508         mov eax,[ebp+08]
> [00001108][00111ca9][00001102] 50             push eax
> [00001109][00111ca9][00001102] 8b4d08         mov ecx,[ebp+08]
> [0000110c][00111ca5][00001102] 51             push ecx
> [0000110d][00111ca1][00001112] e8a0ffffff     call 000010b2
> [000010b2][00111c9d][00111cad] 55             push ebp
> [000010b3][00111c9d][00111cad] 8bec           mov ebp,esp
> [000010b5][00111c9d][00111cad] 8b450c         mov eax,[ebp+0c]
> [000010b8][00111c99][00001102] 50             push eax
> Calling:_Px()
> Decode_Control_Flow_Instruction([00000008][00111c9d][00001102])
> [000010b9][00111c95][000010bc] ff5508         call dword [ebp+08]
> [00001102][00111c91][00111c9d] 55             push ebp
> [00001103][00111c91][00111c9d] 8bec           mov ebp,esp
> [00001105][00111c91][00111c9d] 8b4508         mov eax,[ebp+08]
> [00001108][00111c8d][00001102] 50             push eax
> [00001109][00111c8d][00001102] 8b4d08         mov ecx,[ebp+08]
> [0000110c][00111c89][00001102] 51             push ecx
> [0000110d][00111c85][00001112] e8a0ffffff     call 000010b2
> H: Infinite Recursion Detected Simulation Stopped
>
> [00001134][00101c15][00000000] 83c408         add esp,+08
> [00001137][00101c11][00000000] 50             push eax
> [00001138][00101c0d][00000463] 6863040000     push 00000463
> [0000113d][00101c0d][00000463] e840f3ffff     call 00000482
> Input_Halts = 0
> [00001142][00101c15][00000000] 83c408         add esp,+08
> [00001145][00101c15][00000000] 33c0           xor eax,eax
> [00001147][00101c19][00000018] 5d             pop ebp
> [00001148][00101c1d][00000000] c3             ret
> Number of Instructions Executed(2195) == 33 Pages
>

On 8/30/2022 5:37 PM, Richard Damon wrote:
> IF Px REALLY does call Simulate, whether it is the simulate you show
> (which doesn't actually simulates, but just calls its input), then Yes,
> THAT Px is Non-Halting.
>

Great an honest reply. Now if H(P,P) was supposed to predict the
behavior of a correct and complete simulation of its input as if H was
Simulate, then H(P,P) would be correct return return 0.

> Just to cut your apparent deception off, When you change Px to call H, H
> can't put the SImulate back, becuase H is not the same as Simulate, even
> if it is supppsed to simulate its input until it can prove the input to
> be non-halting.
>
> That is because such an H is Halting, but Simulate of the same input is
> non-halting, thus they are different functions, and not equivalent.
>
>
> On 8/30/22 11:04 AM, olcott wrote:
>> // direct execution of x(y) derives equivalent
>> // behavior to the simulation of x(y)
>> u32 Simulate(ptr x, ptr y)
>> {
>>    x(y);
>>    return 1;
>> }
>>
>> void Px(ptr x)
>> {
>>    Simulate(x, x);
>>    return;
>> }
>>
>> int main()
>> {
>>    Output("Input_Halts = ", H(Px, Px));
>> }
>>
>> _Simulate()
>> [000010b2](01) 55             push ebp
>> [000010b3](02) 8bec           mov ebp,esp
>> [000010b5](03) 8b450c         mov eax,[ebp+0c]
>> [000010b8](01) 50             push eax
>> [000010b9](03) ff5508         call dword [ebp+08]
>> [000010bc](03) 83c404         add esp,+04
>> [000010bf](05) b801000000     mov eax,00000001
>> [000010c4](01) 5d             pop ebp
>> [000010c5](01) c3             ret
>> Size in bytes:(0020) [000010c5]
>>
>> _Px()
>> [00001102](01) 55             push ebp
>> [00001103](02) 8bec           mov ebp,esp
>> [00001105](03) 8b4508         mov eax,[ebp+08]
>> [00001108](01) 50             push eax
>> [00001109](03) 8b4d08         mov ecx,[ebp+08]
>> [0000110c](01) 51             push ecx
>> [0000110d](05) e8a0ffffff     call 000010b2
>> [00001112](03) 83c408         add esp,+08
>> [00001115](01) 5d             pop ebp
>> [00001116](01) c3             ret
>> Size in bytes:(0021) [00001116]
>>
>> _main()
>> [00001122](01) 55             push ebp
>> [00001123](02) 8bec           mov ebp,esp
>> [00001125](05) 6802110000     push 00001102
>> [0000112a](05) 6802110000     push 00001102
>> [0000112f](05) e85efdffff     call 00000e92
>> [00001134](03) 83c408         add esp,+08
>> [00001137](01) 50             push eax
>> [00001138](05) 6863040000     push 00000463
>> [0000113d](05) e840f3ffff     call 00000482
>> [00001142](03) 83c408         add esp,+08
>> [00001145](02) 33c0           xor eax,eax
>> [00001147](01) 5d             pop ebp
>> [00001148](01) c3             ret
>> Size in bytes:(0039) [00001148]
>>
>>   machine   stack     stack     machine    assembly
>>   address   address   data      code       language
>>   ======== ======== ======== ========= =============
>> [00001122][00101c15][00000000] 55             push ebp
>> [00001123][00101c15][00000000] 8bec           mov ebp,esp
>> [00001125][00101c11][00001102] 6802110000     push 00001102
>> [0000112a][00101c0d][00001102] 6802110000     push 00001102
>> [0000112f][00101c09][00001134] e85efdffff     call 00000e92
>> Address_of_H:e92
>>
>> H: Begin Simulation   Execution Trace Stored at:111cc1
>> Address_of_H:e92
>> [00001102][00111cad][00111cb1] 55             push ebp
>> [00001103][00111cad][00111cb1] 8bec           mov ebp,esp
>> [00001105][00111cad][00111cb1] 8b4508         mov eax,[ebp+08]
>> [00001108][00111ca9][00001102] 50             push eax
>> [00001109][00111ca9][00001102] 8b4d08         mov ecx,[ebp+08]
>> [0000110c][00111ca5][00001102] 51             push ecx
>> [0000110d][00111ca1][00001112] e8a0ffffff     call 000010b2
>> [000010b2][00111c9d][00111cad] 55             push ebp
>> [000010b3][00111c9d][00111cad] 8bec           mov ebp,esp
>> [000010b5][00111c9d][00111cad] 8b450c         mov eax,[ebp+0c]
>> [000010b8][00111c99][00001102] 50             push eax
>> Calling:_Px()
>> Decode_Control_Flow_Instruction([00000008][00111c9d][00001102])
>> [000010b9][00111c95][000010bc] ff5508         call dword [ebp+08]
>> [00001102][00111c91][00111c9d] 55             push ebp
>> [00001103][00111c91][00111c9d] 8bec           mov ebp,esp
>> [00001105][00111c91][00111c9d] 8b4508         mov eax,[ebp+08]
>> [00001108][00111c8d][00001102] 50             push eax
>> [00001109][00111c8d][00001102] 8b4d08         mov ecx,[ebp+08]
>> [0000110c][00111c89][00001102] 51             push ecx
>> [0000110d][00111c85][00001112] e8a0ffffff     call 000010b2
>> H: Infinite Recursion Detected Simulation Stopped
>>
>> [00001134][00101c15][00000000] 83c408         add esp,+08
>> [00001137][00101c11][00000000] 50             push eax
>> [00001138][00101c0d][00000463] 6863040000     push 00000463
>> [0000113d][00101c0d][00000463] e840f3ffff     call 00000482
>> Input_Halts = 0
>> [00001142][00101c15][00000000] 83c408         add esp,+08
>> [00001145][00101c15][00000000] 33c0           xor eax,eax
>> [00001147][00101c19][00000018] 5d             pop ebp
>> [00001148][00101c1d][00000000] c3             ret
>> Number of Instructions Executed(2195) == 33 Pages
>>
>

--
Copyright 2022 Pete Olcott

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

On 8/30/22 7:46 PM, olcott wrote:
> On 8/30/2022 5:37 PM, Richard Damon wrote:
>> IF Px REALLY does call Simulate, whether it is the simulate you show
>> (which doesn't actually simulates, but just calls its input), then
>> Yes, THAT Px is Non-Halting.
>>
>
> Great an honest reply. Now if H(P,P) was supposed to predict the
> behavior of a correct and complete simulation of its input as if H was
> Simulate, then H(P,P) would be correct return return 0.

Nope.

You didn't read the rest.

P DOESN'T call Simulate, it calls H, so H needs to simulate the input
that is actually there, and that call H and we know that H will return
0, so P WILL halt.

H may need to predict the behavior of the complete simulation, but it
isn't actually allowed to do a complete simulation if it can't finish it
in finite time.

>
>> Just to cut your apparent deception off, When you change Px to call H,
>> H can't put the SImulate back, becuase H is not the same as Simulate,
>> even if it is supppsed to simulate its input until it can prove the
>> input to be non-halting.
>>
>> That is because such an H is Halting, but Simulate of the same input
>> is non-halting, thus they are different functions, and not equivalent.
>>
>>
>> On 8/30/22 11:04 AM, olcott wrote:
>>> // direct execution of x(y) derives equivalent
>>> // behavior to the simulation of x(y)
>>> u32 Simulate(ptr x, ptr y)
>>> {
>>>    x(y);
>>>    return 1;
>>> }
>>>
>>> void Px(ptr x)
>>> {
>>>    Simulate(x, x);
>>>    return;
>>> }
>>>
>>> int main()
>>> {
>>>    Output("Input_Halts = ", H(Px, Px));
>>> }
>>>
>>> _Simulate()
>>> [000010b2](01) 55             push ebp
>>> [000010b3](02) 8bec           mov ebp,esp
>>> [000010b5](03) 8b450c         mov eax,[ebp+0c]
>>> [000010b8](01) 50             push eax
>>> [000010b9](03) ff5508         call dword [ebp+08]
>>> [000010bc](03) 83c404         add esp,+04
>>> [000010bf](05) b801000000     mov eax,00000001
>>> [000010c4](01) 5d             pop ebp
>>> [000010c5](01) c3             ret
>>> Size in bytes:(0020) [000010c5]
>>>
>>> _Px()
>>> [00001102](01) 55             push ebp
>>> [00001103](02) 8bec           mov ebp,esp
>>> [00001105](03) 8b4508         mov eax,[ebp+08]
>>> [00001108](01) 50             push eax
>>> [00001109](03) 8b4d08         mov ecx,[ebp+08]
>>> [0000110c](01) 51             push ecx
>>> [0000110d](05) e8a0ffffff     call 000010b2
>>> [00001112](03) 83c408         add esp,+08
>>> [00001115](01) 5d             pop ebp
>>> [00001116](01) c3             ret
>>> Size in bytes:(0021) [00001116]
>>>
>>> _main()
>>> [00001122](01) 55             push ebp
>>> [00001123](02) 8bec           mov ebp,esp
>>> [00001125](05) 6802110000     push 00001102
>>> [0000112a](05) 6802110000     push 00001102
>>> [0000112f](05) e85efdffff     call 00000e92
>>> [00001134](03) 83c408         add esp,+08
>>> [00001137](01) 50             push eax
>>> [00001138](05) 6863040000     push 00000463
>>> [0000113d](05) e840f3ffff     call 00000482
>>> [00001142](03) 83c408         add esp,+08
>>> [00001145](02) 33c0           xor eax,eax
>>> [00001147](01) 5d             pop ebp
>>> [00001148](01) c3             ret
>>> Size in bytes:(0039) [00001148]
>>>
>>>   machine   stack     stack     machine    assembly
>>>   address   address   data      code       language
>>>   ======== ======== ======== ========= =============
>>> [00001122][00101c15][00000000] 55             push ebp
>>> [00001123][00101c15][00000000] 8bec           mov ebp,esp
>>> [00001125][00101c11][00001102] 6802110000     push 00001102
>>> [0000112a][00101c0d][00001102] 6802110000     push 00001102
>>> [0000112f][00101c09][00001134] e85efdffff     call 00000e92
>>> Address_of_H:e92
>>>
>>> H: Begin Simulation   Execution Trace Stored at:111cc1
>>> Address_of_H:e92
>>> [00001102][00111cad][00111cb1] 55             push ebp
>>> [00001103][00111cad][00111cb1] 8bec           mov ebp,esp
>>> [00001105][00111cad][00111cb1] 8b4508         mov eax,[ebp+08]
>>> [00001108][00111ca9][00001102] 50             push eax
>>> [00001109][00111ca9][00001102] 8b4d08         mov ecx,[ebp+08]
>>> [0000110c][00111ca5][00001102] 51             push ecx
>>> [0000110d][00111ca1][00001112] e8a0ffffff     call 000010b2
>>> [000010b2][00111c9d][00111cad] 55             push ebp
>>> [000010b3][00111c9d][00111cad] 8bec           mov ebp,esp
>>> [000010b5][00111c9d][00111cad] 8b450c         mov eax,[ebp+0c]
>>> [000010b8][00111c99][00001102] 50             push eax
>>> Calling:_Px()
>>> Decode_Control_Flow_Instruction([00000008][00111c9d][00001102])
>>> [000010b9][00111c95][000010bc] ff5508         call dword [ebp+08]
>>> [00001102][00111c91][00111c9d] 55             push ebp
>>> [00001103][00111c91][00111c9d] 8bec           mov ebp,esp
>>> [00001105][00111c91][00111c9d] 8b4508         mov eax,[ebp+08]
>>> [00001108][00111c8d][00001102] 50             push eax
>>> [00001109][00111c8d][00001102] 8b4d08         mov ecx,[ebp+08]
>>> [0000110c][00111c89][00001102] 51             push ecx
>>> [0000110d][00111c85][00001112] e8a0ffffff     call 000010b2
>>> H: Infinite Recursion Detected Simulation Stopped
>>>
>>> [00001134][00101c15][00000000] 83c408         add esp,+08
>>> [00001137][00101c11][00000000] 50             push eax
>>> [00001138][00101c0d][00000463] 6863040000     push 00000463
>>> [0000113d][00101c0d][00000463] e840f3ffff     call 00000482
>>> Input_Halts = 0
>>> [00001142][00101c15][00000000] 83c408         add esp,+08
>>> [00001145][00101c15][00000000] 33c0           xor eax,eax
>>> [00001147][00101c19][00000018] 5d             pop ebp
>>> [00001148][00101c1d][00000000] c3             ret
>>> Number of Instructions Executed(2195) == 33 Pages
>>>
>>
>

On 8/30/2022 7:40 PM, Richard Damon wrote:
> On 8/30/22 7:46 PM, olcott wrote:
>> On 8/30/2022 5:37 PM, Richard Damon wrote:
>>> IF Px REALLY does call Simulate, whether it is the simulate you show
>>> (which doesn't actually simulates, but just calls its input), then
>>> Yes, THAT Px is Non-Halting.
>>>
>>
>> Great an honest reply. Now if H(P,P) was supposed to predict the
>> behavior of a correct and complete simulation of its input as if H was
>> Simulate, then H(P,P) would be correct return return 0.
>
> Nope.
>
> You didn't read the rest.
>

If H is supposed to predict whether or not a pure simulation of its
input performed by Simulate (instead of H) will never stop running and H
returns 0 then H is necessarily correct no matter what process that H
uses to make this determination.

> P DOESN'T call Simulate, it calls H, so H needs to simulate the input
> that is actually there, and that call H and we know that H will return
> 0, so P WILL halt.
>
> H may need to predict the behavior of the complete simulation, but it
> isn't actually allowed to do a complete simulation if it can't finish it
> in finite time.
>
>
>>
>>> Just to cut your apparent deception off, When you change Px to call
>>> H, H can't put the SImulate back, becuase H is not the same as
>>> Simulate, even if it is supppsed to simulate its input until it can
>>> prove the input to be non-halting.
>>>
>>> That is because such an H is Halting, but Simulate of the same input
>>> is non-halting, thus they are different functions, and not equivalent.
>>>
>>>
>>> On 8/30/22 11:04 AM, olcott wrote:
>>>> // direct execution of x(y) derives equivalent
>>>> // behavior to the simulation of x(y)
>>>> u32 Simulate(ptr x, ptr y)
>>>> {
>>>>    x(y);
>>>>    return 1;
>>>> }
>>>>
>>>> void Px(ptr x)
>>>> {
>>>>    Simulate(x, x);
>>>>    return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>    Output("Input_Halts = ", H(Px, Px));
>>>> }
>>>>
>>>> _Simulate()
>>>> [000010b2](01) 55             push ebp
>>>> [000010b3](02) 8bec           mov ebp,esp
>>>> [000010b5](03) 8b450c         mov eax,[ebp+0c]
>>>> [000010b8](01) 50             push eax
>>>> [000010b9](03) ff5508         call dword [ebp+08]
>>>> [000010bc](03) 83c404         add esp,+04
>>>> [000010bf](05) b801000000     mov eax,00000001
>>>> [000010c4](01) 5d             pop ebp
>>>> [000010c5](01) c3             ret
>>>> Size in bytes:(0020) [000010c5]
>>>>
>>>> _Px()
>>>> [00001102](01) 55             push ebp
>>>> [00001103](02) 8bec           mov ebp,esp
>>>> [00001105](03) 8b4508         mov eax,[ebp+08]
>>>> [00001108](01) 50             push eax
>>>> [00001109](03) 8b4d08         mov ecx,[ebp+08]
>>>> [0000110c](01) 51             push ecx
>>>> [0000110d](05) e8a0ffffff     call 000010b2
>>>> [00001112](03) 83c408         add esp,+08
>>>> [00001115](01) 5d             pop ebp
>>>> [00001116](01) c3             ret
>>>> Size in bytes:(0021) [00001116]
>>>>
>>>> _main()
>>>> [00001122](01) 55             push ebp
>>>> [00001123](02) 8bec           mov ebp,esp
>>>> [00001125](05) 6802110000     push 00001102
>>>> [0000112a](05) 6802110000     push 00001102
>>>> [0000112f](05) e85efdffff     call 00000e92
>>>> [00001134](03) 83c408         add esp,+08
>>>> [00001137](01) 50             push eax
>>>> [00001138](05) 6863040000     push 00000463
>>>> [0000113d](05) e840f3ffff     call 00000482
>>>> [00001142](03) 83c408         add esp,+08
>>>> [00001145](02) 33c0           xor eax,eax
>>>> [00001147](01) 5d             pop ebp
>>>> [00001148](01) c3             ret
>>>> Size in bytes:(0039) [00001148]
>>>>
>>>>   machine   stack     stack     machine    assembly
>>>>   address   address   data      code       language
>>>>   ======== ======== ======== ========= =============
>>>> [00001122][00101c15][00000000] 55             push ebp
>>>> [00001123][00101c15][00000000] 8bec           mov ebp,esp
>>>> [00001125][00101c11][00001102] 6802110000     push 00001102
>>>> [0000112a][00101c0d][00001102] 6802110000     push 00001102
>>>> [0000112f][00101c09][00001134] e85efdffff     call 00000e92
>>>> Address_of_H:e92
>>>>
>>>> H: Begin Simulation   Execution Trace Stored at:111cc1
>>>> Address_of_H:e92
>>>> [00001102][00111cad][00111cb1] 55             push ebp
>>>> [00001103][00111cad][00111cb1] 8bec           mov ebp,esp
>>>> [00001105][00111cad][00111cb1] 8b4508         mov eax,[ebp+08]
>>>> [00001108][00111ca9][00001102] 50             push eax
>>>> [00001109][00111ca9][00001102] 8b4d08         mov ecx,[ebp+08]
>>>> [0000110c][00111ca5][00001102] 51             push ecx
>>>> [0000110d][00111ca1][00001112] e8a0ffffff     call 000010b2
>>>> [000010b2][00111c9d][00111cad] 55             push ebp
>>>> [000010b3][00111c9d][00111cad] 8bec           mov ebp,esp
>>>> [000010b5][00111c9d][00111cad] 8b450c         mov eax,[ebp+0c]
>>>> [000010b8][00111c99][00001102] 50             push eax
>>>> Calling:_Px()
>>>> Decode_Control_Flow_Instruction([00000008][00111c9d][00001102])
>>>> [000010b9][00111c95][000010bc] ff5508         call dword [ebp+08]
>>>> [00001102][00111c91][00111c9d] 55             push ebp
>>>> [00001103][00111c91][00111c9d] 8bec           mov ebp,esp
>>>> [00001105][00111c91][00111c9d] 8b4508         mov eax,[ebp+08]
>>>> [00001108][00111c8d][00001102] 50             push eax
>>>> [00001109][00111c8d][00001102] 8b4d08         mov ecx,[ebp+08]
>>>> [0000110c][00111c89][00001102] 51             push ecx
>>>> [0000110d][00111c85][00001112] e8a0ffffff     call 000010b2
>>>> H: Infinite Recursion Detected Simulation Stopped
>>>>
>>>> [00001134][00101c15][00000000] 83c408         add esp,+08
>>>> [00001137][00101c11][00000000] 50             push eax
>>>> [00001138][00101c0d][00000463] 6863040000     push 00000463
>>>> [0000113d][00101c0d][00000463] e840f3ffff     call 00000482
>>>> Input_Halts = 0
>>>> [00001142][00101c15][00000000] 83c408         add esp,+08
>>>> [00001145][00101c15][00000000] 33c0           xor eax,eax
>>>> [00001147][00101c19][00000018] 5d             pop ebp
>>>> [00001148][00101c1d][00000000] c3             ret
>>>> Number of Instructions Executed(2195) == 33 Pages
>>>>
>>>
>>
>

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

On 8/30/22 8:52 PM, olcott wrote:
> On 8/30/2022 7:40 PM, Richard Damon wrote:
>> On 8/30/22 7:46 PM, olcott wrote:
>>> On 8/30/2022 5:37 PM, Richard Damon wrote:
>>>> IF Px REALLY does call Simulate, whether it is the simulate you show
>>>> (which doesn't actually simulates, but just calls its input), then
>>>> Yes, THAT Px is Non-Halting.
>>>>
>>>
>>> Great an honest reply. Now if H(P,P) was supposed to predict the
>>> behavior of a correct and complete simulation of its input as if H
>>> was Simulate, then H(P,P) would be correct return return 0.
>>
>> Nope.
>>
>> You didn't read the rest.
>>
>
> If H is supposed to predict whether or not a pure simulation of its
> input performed by Simulate (instead of H) will never stop running and H
> returns 0 then H is necessarily correct no matter what process that H
> uses to make this determination.

But remember, P doesn't call simulate, it calls H.

Just because H uses simulation to make its decision, doesn't make it an
equivalenet for Simulate.

You are adding words to the definition to make it different.

H is supposed to predict what Simulate would do when given the exact
same input as H was given.

There is no "Instead of", no word that even imply you change the input.

THe input P STILL needs to call H, and that H needs to behave exactly
like the H that is doing the deciding.

The only thing the Simulate does is provide a test and a definition of
what the answer would be.

Since H(P,P) will, by your definitions return 0, then Simulate(P,P) will
see P(P) call H(P,P) and that then awhile later return 0 and then P will
Halt.

That means that H was wrong.

If H wants to avoid being wrong, it can keep on simulating. As long as
it doesn't give an answer, it won't be wrong. The problem it runs into
is that because P(P) calls H(P,P), it is ABLE to do the opposite of what
H does say, thus it makes it so no answer that H can give will be right,
so the only way to avoid being wrong is to not answer, but that makes it
wrong a different way.

There is actually nothing wrong with this fact, and for any given H,
there IS an answer to the question of will the input to H(P,P) Halt when
completely simulated, that answer will just always be the opposite of
whatever H says (or non-halting if H just refuses to answer), so the
quesiton isn't the Liar's paradox.

What IS related to the Liar's paradox is the DESIGN question for H, that
one has no answer, which just shows again that a correct H can not exist.

>
>> P DOESN'T call Simulate, it calls H, so H needs to simulate the input
>> that is actually there, and that call H and we know that H will return
>> 0, so P WILL halt.
>>
>> H may need to predict the behavior of the complete simulation, but it
>> isn't actually allowed to do a complete simulation if it can't finish
>> it in finite time.
>>
>>
>>>
>>>> Just to cut your apparent deception off, When you change Px to call
>>>> H, H can't put the SImulate back, becuase H is not the same as
>>>> Simulate, even if it is supppsed to simulate its input until it can
>>>> prove the input to be non-halting.
>>>>
>>>> That is because such an H is Halting, but Simulate of the same input
>>>> is non-halting, thus they are different functions, and not equivalent.
>>>>
>>>>
>>>> On 8/30/22 11:04 AM, olcott wrote:
>>>>> // direct execution of x(y) derives equivalent
>>>>> // behavior to the simulation of x(y)
>>>>> u32 Simulate(ptr x, ptr y)
>>>>> {
>>>>>    x(y);
>>>>>    return 1;
>>>>> }
>>>>>
>>>>> void Px(ptr x)
>>>>> {
>>>>>    Simulate(x, x);
>>>>>    return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>    Output("Input_Halts = ", H(Px, Px));
>>>>> }
>>>>>
>>>>> _Simulate()
>>>>> [000010b2](01) 55             push ebp
>>>>> [000010b3](02) 8bec           mov ebp,esp
>>>>> [000010b5](03) 8b450c         mov eax,[ebp+0c]
>>>>> [000010b8](01) 50             push eax
>>>>> [000010b9](03) ff5508         call dword [ebp+08]
>>>>> [000010bc](03) 83c404         add esp,+04
>>>>> [000010bf](05) b801000000     mov eax,00000001
>>>>> [000010c4](01) 5d             pop ebp
>>>>> [000010c5](01) c3             ret
>>>>> Size in bytes:(0020) [000010c5]
>>>>>
>>>>> _Px()
>>>>> [00001102](01) 55             push ebp
>>>>> [00001103](02) 8bec           mov ebp,esp
>>>>> [00001105](03) 8b4508         mov eax,[ebp+08]
>>>>> [00001108](01) 50             push eax
>>>>> [00001109](03) 8b4d08         mov ecx,[ebp+08]
>>>>> [0000110c](01) 51             push ecx
>>>>> [0000110d](05) e8a0ffffff     call 000010b2
>>>>> [00001112](03) 83c408         add esp,+08
>>>>> [00001115](01) 5d             pop ebp
>>>>> [00001116](01) c3             ret
>>>>> Size in bytes:(0021) [00001116]
>>>>>
>>>>> _main()
>>>>> [00001122](01) 55             push ebp
>>>>> [00001123](02) 8bec           mov ebp,esp
>>>>> [00001125](05) 6802110000     push 00001102
>>>>> [0000112a](05) 6802110000     push 00001102
>>>>> [0000112f](05) e85efdffff     call 00000e92
>>>>> [00001134](03) 83c408         add esp,+08
>>>>> [00001137](01) 50             push eax
>>>>> [00001138](05) 6863040000     push 00000463
>>>>> [0000113d](05) e840f3ffff     call 00000482
>>>>> [00001142](03) 83c408         add esp,+08
>>>>> [00001145](02) 33c0           xor eax,eax
>>>>> [00001147](01) 5d             pop ebp
>>>>> [00001148](01) c3             ret
>>>>> Size in bytes:(0039) [00001148]
>>>>>
>>>>>   machine   stack     stack     machine    assembly
>>>>>   address   address   data      code       language
>>>>>   ======== ======== ======== ========= =============
>>>>> [00001122][00101c15][00000000] 55             push ebp
>>>>> [00001123][00101c15][00000000] 8bec           mov ebp,esp
>>>>> [00001125][00101c11][00001102] 6802110000     push 00001102
>>>>> [0000112a][00101c0d][00001102] 6802110000     push 00001102
>>>>> [0000112f][00101c09][00001134] e85efdffff     call 00000e92
>>>>> Address_of_H:e92
>>>>>
>>>>> H: Begin Simulation   Execution Trace Stored at:111cc1
>>>>> Address_of_H:e92
>>>>> [00001102][00111cad][00111cb1] 55             push ebp
>>>>> [00001103][00111cad][00111cb1] 8bec           mov ebp,esp
>>>>> [00001105][00111cad][00111cb1] 8b4508         mov eax,[ebp+08]
>>>>> [00001108][00111ca9][00001102] 50             push eax
>>>>> [00001109][00111ca9][00001102] 8b4d08         mov ecx,[ebp+08]
>>>>> [0000110c][00111ca5][00001102] 51             push ecx
>>>>> [0000110d][00111ca1][00001112] e8a0ffffff     call 000010b2
>>>>> [000010b2][00111c9d][00111cad] 55             push ebp
>>>>> [000010b3][00111c9d][00111cad] 8bec           mov ebp,esp
>>>>> [000010b5][00111c9d][00111cad] 8b450c         mov eax,[ebp+0c]
>>>>> [000010b8][00111c99][00001102] 50             push eax
>>>>> Calling:_Px()
>>>>> Decode_Control_Flow_Instruction([00000008][00111c9d][00001102])
>>>>> [000010b9][00111c95][000010bc] ff5508         call dword [ebp+08]
>>>>> [00001102][00111c91][00111c9d] 55             push ebp
>>>>> [00001103][00111c91][00111c9d] 8bec           mov ebp,esp
>>>>> [00001105][00111c91][00111c9d] 8b4508         mov eax,[ebp+08]
>>>>> [00001108][00111c8d][00001102] 50             push eax
>>>>> [00001109][00111c8d][00001102] 8b4d08         mov ecx,[ebp+08]
>>>>> [0000110c][00111c89][00001102] 51             push ecx
>>>>> [0000110d][00111c85][00001112] e8a0ffffff     call 000010b2
>>>>> H: Infinite Recursion Detected Simulation Stopped
>>>>>
>>>>> [00001134][00101c15][00000000] 83c408         add esp,+08
>>>>> [00001137][00101c11][00000000] 50             push eax
>>>>> [00001138][00101c0d][00000463] 6863040000     push 00000463
>>>>> [0000113d][00101c0d][00000463] e840f3ffff     call 00000482
>>>>> Input_Halts = 0
>>>>> [00001142][00101c15][00000000] 83c408         add esp,+08
>>>>> [00001145][00101c15][00000000] 33c0           xor eax,eax
>>>>> [00001147][00101c19][00000018] 5d             pop ebp
>>>>> [00001148][00101c1d][00000000] c3             ret
>>>>> Number of Instructions Executed(2195) == 33 Pages
>>>>>
>>>>
>>>
>>
>

Click here to read the complete article

On 8/30/2022 8:19 PM, Richard Damon wrote:
> On 8/30/22 8:52 PM, olcott wrote:
>> On 8/30/2022 7:40 PM, Richard Damon wrote:
>>> On 8/30/22 7:46 PM, olcott wrote:
>>>> On 8/30/2022 5:37 PM, Richard Damon wrote:
>>>>> IF Px REALLY does call Simulate, whether it is the simulate you
>>>>> show (which doesn't actually simulates, but just calls its input),
>>>>> then Yes, THAT Px is Non-Halting.
>>>>>
>>>>
>>>> Great an honest reply. Now if H(P,P) was supposed to predict the
>>>> behavior of a correct and complete simulation of its input as if H
>>>> was Simulate, then H(P,P) would be correct return return 0.
>>>
>>> Nope.
>>>
>>> You didn't read the rest.
>>>
>>
>> If H is supposed to predict whether or not a pure simulation of its
>> input performed by Simulate (instead of H) will never stop running and
>> H returns 0 then H is necessarily correct no matter what process that
>> H uses to make this determination.
>
> But remember, P doesn't call simulate, it calls H.
>
H(P,P) correctly predicts that Simulate(x,y) never halts:

H(ptr x, ptr y)
{ return 0;
}

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

On 8/30/22 9:35 PM, olcott wrote:
> On 8/30/2022 8:19 PM, Richard Damon wrote:
>> On 8/30/22 8:52 PM, olcott wrote:
>>> On 8/30/2022 7:40 PM, Richard Damon wrote:
>>>> On 8/30/22 7:46 PM, olcott wrote:
>>>>> On 8/30/2022 5:37 PM, Richard Damon wrote:
>>>>>> IF Px REALLY does call Simulate, whether it is the simulate you
>>>>>> show (which doesn't actually simulates, but just calls its input),
>>>>>> then Yes, THAT Px is Non-Halting.
>>>>>>
>>>>>
>>>>> Great an honest reply. Now if H(P,P) was supposed to predict the
>>>>> behavior of a correct and complete simulation of its input as if H
>>>>> was Simulate, then H(P,P) would be correct return return 0.
>>>>
>>>> Nope.
>>>>
>>>> You didn't read the rest.
>>>>
>>>
>>> If H is supposed to predict whether or not a pure simulation of its
>>> input performed by Simulate (instead of H) will never stop running
>>> and H returns 0 then H is necessarily correct no matter what process
>>> that H uses to make this determination.
>>
>> But remember, P doesn't call simulate, it calls H.
>>
> H(P,P) correctly predicts that Simulate(x,y) never halts:
>
> H(ptr x, ptr y)
> {
> return 0;
> }
>
>

But, assuming we are still talking about the P that calls H(P,P),
Simulate(P,P) does Halt if H(P,P) return 0, so that answer is wrong.

It doesn't matter that it gets H(Ps,Ps) right were Ps(x) calls
Simulate(x,x) since that isn't the "Impossible Program"

You are just showing how little you understand of what you are talking
about.

The execution trace from Simulate(P,P) is:

(1) Start P(P), which calls
(2) H(P,P) which start a simulation of
(3) P(P), which is simulated to call H(P,P)
(4) THe H(P,P) (from 2) then aborts its simulation of (3)
(5) The H(P,P) (from 2) then return 0 to the P(P) from (1)
(6) The P(P) (from 1) then Halts

Thus we show that Simulate(P,P) will Halt, and thus H(P,P) returning 0
is WRONG that it won't.

it seems that you H seems to think the call to H that it say in (3) was
actually a call to Simulate, which it isn't

Thus your H is NOT doing a "correct simulation of its ACTUAL input"
and thus fails to get the right answer.

So, maybe your H gets the right answer but it is to the wrong question.

On 8/30/2022 8:44 PM, Richard Damon wrote:
> On 8/30/22 9:35 PM, olcott wrote:
>> On 8/30/2022 8:19 PM, Richard Damon wrote:
>>> On 8/30/22 8:52 PM, olcott wrote:
>>>> On 8/30/2022 7:40 PM, Richard Damon wrote:
>>>>> On 8/30/22 7:46 PM, olcott wrote:
>>>>>> On 8/30/2022 5:37 PM, Richard Damon wrote:
>>>>>>> IF Px REALLY does call Simulate, whether it is the simulate you
>>>>>>> show (which doesn't actually simulates, but just calls its
>>>>>>> input), then Yes, THAT Px is Non-Halting.
>>>>>>>
>>>>>>
>>>>>> Great an honest reply. Now if H(P,P) was supposed to predict the
>>>>>> behavior of a correct and complete simulation of its input as if H
>>>>>> was Simulate, then H(P,P) would be correct return return 0.
>>>>>
>>>>> Nope.
>>>>>
>>>>> You didn't read the rest.
>>>>>
>>>>
>>>> If H is supposed to predict whether or not a pure simulation of its
>>>> input performed by Simulate (instead of H) will never stop running
>>>> and H returns 0 then H is necessarily correct no matter what process
>>>> that H uses to make this determination.
>>>
>>> But remember, P doesn't call simulate, it calls H.
>>>
>> H(P,P) correctly predicts that Simulate(x,y) never halts:
>>
>> H(ptr x, ptr y)
>> {
>> return 0;
>> }
>>
>>
>
> But, assuming we are still talking about the P that calls H(P,P),
> Simulate(P,P) does Halt if H(P,P) return 0, so that answer is wrong.
>
void Simulate(ptr x, ptr y)
{ x(y);
}

void Pz(ptr x)
{ Simulate(x, x);
}

If Fred is supposed to determine whether or not Simulate(Pz, Pz) halts:

u32 Fred()
{ return 0;
}

*Then Fred is necessarily correct*

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

On 8/30/22 9:53 PM, olcott wrote:
> On 8/30/2022 8:44 PM, Richard Damon wrote:
>> On 8/30/22 9:35 PM, olcott wrote:
>>> On 8/30/2022 8:19 PM, Richard Damon wrote:
>>>> On 8/30/22 8:52 PM, olcott wrote:
>>>>> On 8/30/2022 7:40 PM, Richard Damon wrote:
>>>>>> On 8/30/22 7:46 PM, olcott wrote:
>>>>>>> On 8/30/2022 5:37 PM, Richard Damon wrote:
>>>>>>>> IF Px REALLY does call Simulate, whether it is the simulate you
>>>>>>>> show (which doesn't actually simulates, but just calls its
>>>>>>>> input), then Yes, THAT Px is Non-Halting.
>>>>>>>>
>>>>>>>
>>>>>>> Great an honest reply. Now if H(P,P) was supposed to predict the
>>>>>>> behavior of a correct and complete simulation of its input as if
>>>>>>> H was Simulate, then H(P,P) would be correct return return 0.
>>>>>>
>>>>>> Nope.
>>>>>>
>>>>>> You didn't read the rest.
>>>>>>
>>>>>
>>>>> If H is supposed to predict whether or not a pure simulation of its
>>>>> input performed by Simulate (instead of H) will never stop running
>>>>> and H returns 0 then H is necessarily correct no matter what
>>>>> process that H uses to make this determination.
>>>>
>>>> But remember, P doesn't call simulate, it calls H.
>>>>
>>> H(P,P) correctly predicts that Simulate(x,y) never halts:
>>>
>>> H(ptr x, ptr y)
>>> {
>>> return 0;
>>> }
>>>
>>>
>>
>> But, assuming we are still talking about the P that calls H(P,P),
>> Simulate(P,P) does Halt if H(P,P) return 0, so that answer is wrong.
>>
> void Simulate(ptr x, ptr y)
> {
> x(y);
> }
>
> void Pz(ptr x)
> {
> Simulate(x, x);
> }
>
> If Fred is supposed to determine whether or not Simulate(Pz, Pz) halts:
>
> u32 Fred()
> {
> return 0;
> }
>
> *Then Fred is necessarily correct*
>
>
>

Right, H(Pz,Pz) is correct to say 0

H(P,P), where P(x) calls H(x,x) is NOT correct to return 0, because
Simulate(P,P) will Halt.

P is NOT Pz, so one answer doesn't say anything about the other.

You keep on trying to reframe the Halting Problem, which is EXACTLY that
H(p,d) needs to decide on the behavior of P(d) which is the same as
UTM(P,d) and if P(d) is defined to call H(d,d), then H needs to analyze
and answer about THAT machine, not one that call UTM instead of H.

It doesn't matter that the correct answer for H is based on UTM(P,d),
that doesn't mean H can treat calls to H as calls to UTM.

You are just proving how little you understand about this topic you have
supposedly been studying for 18 years.

Subject	Author
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Mr Flibble
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Mr Flibble
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Mr Flibble
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Mr Flibble
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Mr Flibble
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Mr Flibble
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Mr Flibble
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Mr Flibble
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Mr Flibble
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Mr Flibble
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Mr Flibble
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Mr Flibble
Does everyone agree with this halt status decision?	André G. Isaak
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	Paul N
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Paul N
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Paul N
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Paul N
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	Mr Flibble
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Ben Bacarisse
Does everyone agree with this halt status decision?	Mr Flibble
Does everyone agree with this halt status decision?	Ben Bacarisse
Does everyone agree with this halt status decision?	Mr Flibble
Does everyone agree with this halt status decision?	Ben Bacarisse
Does everyone agree with this halt status decision?	Mr Flibble
Does everyone agree with this halt status decision?	Ben Bacarisse
Does everyone agree with this halt status decision?	Mr Flibble
Does everyone agree with this halt status decision?	Ben Bacarisse
Does everyone agree with this halt status decision?	Mr Flibble
Does everyone agree with this halt status decision?	Ben Bacarisse
Does everyone agree with this halt status decision?	Andy Walker
Does everyone agree with this halt status decision?	Ben Bacarisse
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Richard Damon
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	olcott
Does everyone agree with this halt status decision?	Otto J. Makela