Wednesday, March 3, 2021

Digest for comp.lang.c++@googlegroups.com - 7 updates in 3 topics

olcott <NoOne@NoWhere.com>: Mar 03 12:52PM -0600

On 3/3/2021 1:58 AM, David Brown wrote:
 
> You know, in the same way that non-physicists are not constrained by
> physical laws that they don't understand, and can thus make moon rockets
> in their garage powered by gravity-repulsive paint.
 
void H_Hat(u32 P)
{
u32 Input_Halts = Halts(P, P);
if (Input_Halts)
HERE: goto HERE;
return;
}
 
All of the halting problem proofs are based on the fact that it is
impossible for Halts() to return a correct halting decision to H_Hat()
because H_Hat() contradicts whatever value that Halts() returns.
 
All of these same proofs ignore the fact that every halt decider that
bases its halt decision on examining the execution trace of its own
simulation of its input never reaches the point in the execution trace
where it would return a value to H_Hat().
 
>> On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
>>> A computation that would not halt if its simulation were not
>>> halted is indeed a non-halting computation.
 
That I have shown how a halt decider could examine such an execution
trace to determine that its input would not halt unless the simulation
of this input was terminated proves that these computations are halt
decidable.
 
 
--
Copyright 2021 Pete Olcott
 
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
olcott <NoOne@NoWhere.com>: Mar 03 12:55PM -0600

On 3/3/2021 6:37 AM, Juha Nieminen wrote:
 
> There exist real numbers that cannot be defined (with a finite expression),
> and in fact almost all real numbers are like that, but pi is not one
> of them.
 
void H_Hat(u32 P)
{
u32 Input_Halts = Halts(P, P);
if (Input_Halts)
HERE: goto HERE;
return;
}
 
All of the halting problem proofs are based on the fact that it is
impossible for Halts() to return a correct halting decision to H_Hat()
because H_Hat() contradicts whatever value that Halts() returns.
 
All of these same proofs ignore the fact that every halt decider that
bases its halt decision on examining the execution trace of its own
simulation of its input never reaches the point in the execution trace
where it would return a value to H_Hat().
 
>> On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
>>> A computation that would not halt if its simulation were not
>>> halted is indeed a non-halting computation.
 
That I have shown how a halt decider could examine such an execution
trace to determine that its input would not halt unless the simulation
of this input was terminated proves that these computations are halt
decidable.
 
 
--
Copyright 2021 Pete Olcott
 
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
Juha Nieminen <nospam@thanks.invalid>: Mar 03 09:00PM

>>Let me ask it this way: Why do you consider a fraction, like 1/3,
>>to be a definable number?
 
> It has a quantifiable value.
 
What does that even mean?
 
I think you are making stuff up as you go.
Keith Thompson <Keith.S.Thompson+u@gmail.com>: Mar 03 02:18PM -0800


>> It has a quantifiable value.
 
> What does that even mean?
 
> I think you are making stuff up as you go.
 
I think he's making stuff up that has even less to do with C++ than the
original topic of this thread. I suggest not replying.
 
--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Working, but not speaking, for Philips Healthcare
void Void(void) { Void(); } /* The recursive call of the void */
olcott <NoOne@NoWhere.com>: Mar 03 05:06PM -0600

On 3/3/2021 4:18 PM, Keith Thompson wrote:
 
>> I think you are making stuff up as you go.
 
> I think he's making stuff up that has even less to do with C++ than the
> original topic of this thread. I suggest not replying.
 
Here is the original topic of this thread completely rewritten.
 
Criteria for deciding that H_Hat() calls Simulate() in infinite
recursion. I need to have this criteria validated.
 
(1) The execution trace of H_Hat() shows that it calls Simulate() from
the same machine address two times in sequence with the same data.
 
(2) It is assumed that Simulate() either directly invokes its input (as
shown below) or Simulate() emulates the execution of the x86 machine
language of its input (functionally equivalent to the direct execution
shown below).
 
Does everyone agree that the above criteria is sufficient to definitely
decide that H_Hat() is infinitely recursive?
 
 
#include <stdint.h>
#define u32 uint32_t
 
 
int Simulate(u32 P, u32 I)
{
((void(*)(u32))P)(I);
}
 
 
void H_Hat(u32 P)
{
Simulate(P, P);
}
 
 
int main()
{
Simulate((u32)H_Hat, (u32)H_Hat);
}
 
 
_Simulate()
[00000478](01) 55 push ebp
[00000479](02) 8bec mov ebp,esp
[0000047b](03) 8b450c mov eax,[ebp+0c]
[0000047e](01) 50 push eax
[0000047f](03) ff5508 call dword [ebp+08]
[00000482](03) 83c404 add esp,+04
[00000485](01) 5d pop ebp
[00000486](01) c3 ret
 
_H_Hat()
[00000868](01) 55 push ebp
[00000869](02) 8bec mov ebp,esp
[0000086b](03) 8b4508 mov eax,[ebp+08]
[0000086e](01) 50 push eax
[0000086f](03) 8b4d08 mov ecx,[ebp+08]
[00000872](01) 51 push ecx
[00000873](05) e800fcffff call 00000478
[00000878](03) 83c408 add esp,+08
[0000087b](01) 5d pop ebp
[0000087c](01) c3 ret
 
_main()
[00000888](01) 55 push ebp
[00000889](02) 8bec mov ebp,esp
[0000088b](05) 6868080000 push 00000868
[00000890](05) 6868080000 push 00000868
[00000895](05) e8defbffff call 00000478
[0000089a](03) 83c408 add esp,+08
[0000089d](02) 33c0 xor eax,eax
[0000089f](01) 5d pop ebp
[000008a0](01) c3 ret
 
 
Columns
(1) Sequence number
(2) Machine address of instruction
(3) Machine address of top of stack
(4) Value of top of stack after instruction executed
(5) Number of bytes of machine code
(6) Machine language bytes
(7) Assembly language text
 
(01)[00000888][00011194][00000000](01) 55 push ebp
(02)[00000889][00011194][00000000](02) 8bec mov ebp,esp
(03)[0000088b][00011190][00000868](05) 6868080000 push 00000868
(04)[00000890][0001118c][00000868](05) 6868080000 push 00000868
(05)[00000895][00011188][0000089a](05) e8defbffff call 00000478
(06)[00000868][00011178][00011184](01) 55 push ebp
(07)[00000869][00011178][00011184](02) 8bec mov ebp,esp
(08)[0000086b][00011178][00011184](03) 8b4508 mov eax,[ebp+08]
(09)[0000086e][00011174][00000868](01) 50 push eax
(10)[0000086f][00011174][00000868](03) 8b4d08 mov ecx,[ebp+08]
(11)[00000872][00011170][00000868](01) 51 push ecx
(12)[00000873][0001116c][00000878](05) e800fcffff call 00000478
 
Line (09) pushes second parameter to Simulate() machine address 0x878
Line (11) pushes first parameter to Simulate() machine address 0x878
Line (12) Calls Simulate(0x878, 0x878);
 
(13)[00000868][0001115c][00011168](01) 55 push ebp
(14)[00000869][0001115c][00011168](02) 8bec mov ebp,esp
(15)[0000086b][0001115c][00011168](03) 8b4508 mov eax,[ebp+08]
(16)[0000086e][00011158][00000868](01) 50 push eax
(17)[0000086f][00011158][00000868](03) 8b4d08 mov ecx,[ebp+08]
(18)[00000872][00011154][00000868](01) 51 push ecx
(19)[00000873][00011150][00000878](05) e800fcffff call 00000478
 
Line (16) pushes second parameter to Simulate() machine address 0x878
Line (18) pushes first parameter to Simulate() machine address 0x878
Line (19) Calls Simulate(0x878, 0x878);
 
(20)[00000868][00011140][0001114c](01) 55 push ebp
(21)[00000869][00011140][0001114c](02) 8bec mov ebp,esp
(22)[0000086b][00011140][0001114c](03) 8b4508 mov eax,[ebp+08]
(23)[0000086e][0001113c][00000868](01) 50 push eax
(24)[0000086f][0001113c][00000868](03) 8b4d08 mov ecx,[ebp+08]
(25)[00000872][00011138][00000868](01) 51 push ecx
(26)[00000873][00011134][00000878](05) e800fcffff call 00000478
 
Line (23) pushes second parameter to Simulate() machine address 0x878
Line (25) pushes first parameter to Simulate() machine address 0x878
Line (26) Calls Simulate(0x878, 0x878);
 
Now we have seen that Simulate() is invoked two times from the same
machine address of H_Hat() with the same data. We also know that
Simulate() either executes or emulates the machine language of its input
and nothing more. This seems to provide a sufficient basis for deciding
that H_Hat() is infinitely recursive, thus non-halting.
 
 
 
--
Copyright 2021 Pete Olcott
 
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
olcott <NoOne@NoWhere.com>: Mar 03 03:50PM -0600

On 3/3/2021 3:41 PM, Ben Bacarisse wrote:
> are still using your own criterion for what is a halting computation?
 
> I need to ask because you don't understand what I said, so your quoting
> it does not mean you agree with me.
 
To mean it means exactly what it says, did you intend it to not mean
exactly what it says?
 
When so ever it is known that a computation would not halt unless its
simulation was halted [exactly and precisely the above criteria]
 
the simulator can stop simulating its input and report not halting.
 
 
--
Copyright 2021 Pete Olcott
 
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
Brian Wood <woodbrian77@gmail.com>: Mar 03 11:15AM -0800

On Sunday, September 27, 2020 at 3:31:33 AM UTC-5, David Brown wrote:
> self-pitying martyrdom or narcissism as you have done so often in the
> past. Stick to technical posts about C++, and you'll be quite
> comfortable and welcome here.
 
https://www.dailywire.com/episode/ep-1207-the-book-burners-are-here-2
https://www.dailywire.com/news/dr-seuss-and-the-culture-of-fear
 
Are others interested in a C++ meeting in the St. Paul, Minnesota area?
 
 
Brian
You received this digest because you're subscribed to updates for this group. You can change your settings on the group membership page.
To unsubscribe from this group and stop receiving emails from it send an email to comp.lang.c+++unsubscribe@googlegroups.com.
Posted by at

No comments:

Post a Comment

Subscribe to: Post Comments (Atom)