Re: The philosophy of computation reformulates existing ideas on a new basis --- EQUIVOCATION

On 11/2/2024 11:17 PM, Richard Damon wrote:

On 11/2/24 9:33 PM, olcott wrote:

On 11/2/2024 8:22 PM, Richard Damon wrote:

On 11/2/24 9:00 PM, olcott wrote:

On 11/2/2024 7:52 PM, Richard Damon wrote:

On 11/2/24 8:38 PM, olcott wrote:

On 11/2/2024 7:21 PM, Richard Damon wrote:

On 11/2/24 5:13 PM, olcott wrote:

On 11/2/2024 3:24 PM, Richard Damon wrote:

On 11/2/24 12:56 PM, olcott wrote:

On 11/2/2024 10:44 AM, Richard Damon wrote:

On 11/2/24 8:24 AM, olcott wrote:

>
When the main motive of people like Richard is to derail
any chance of mutual agreement I cannot proceed with all
of the steps achieving mutual agreement on each step one
at a time in their mandatory prerequisite order.

>
No, my "motive" is to hold cranks to the truth, or at least get them to admit that they are off in some other system, that they can define.
>
You keep on wanting to be in the system (since it provides the proof of the things you don't like) but can't hold yourself to actually be in the system.
>

>
void DDD()
{
   HHH(DDD);
   return;
}
>
_DDD()
[000020a2] 55         push ebp      ; housekeeping
[000020a3] 8bec       mov ebp,esp   ; housekeeping
[000020a5] 68a2200000 push 000020a2 ; push DDD
[000020aa] e8f3f9ffff call 00001aa2 ; call H0
[000020af] 83c404     add esp,+04   ; housekeeping
[000020b2] 5d         pop ebp       ; housekeeping
[000020b3] c3         ret           ; never gets here
Size in bytes:(0018) [000020b3]
>
DDD emulated by HHH according to the semantics of the x86
language cannot possibly reach its own "return" instruction
whether or not any HHH ever aborts its emulation of DDD.

>
Equivocation between looking at the behavor of DDD being the actual program (which include a particular version of HHH) and the behavior of a PARTIAL emulation of DDD by HHH, which ends up not having the property you want to show.
>
Partial doesn't lead to showing never.
>

>
In other words you continue to perpetually insist on
the ridiculously stupid idea of requiring the complete
emulation of a non-terminating input.
>
I don't think this is: stupidity, ignorance, ADD.
I don't know what this leaves besides dishonesty with malice.
>

>
No, you just need to know the RESULTS of the emulation of the input even if you emulate it for an unlimited number of steps.

>
Yes

>
So, you agree that the results of only the partial emulation done by HHH doesn't define the answer, only that of the infinte emulation OF THIS EXACT INPUT, defines the behavior, as shown by HHH1(DDD) which shows it halts.
>

You don't need to actually do it if you can prove what it would be.
>

>
*Yes and ChatGPT agrees*
>
<ChatGPT>
   Think of HHH as a "watchdog" that steps in during real
   execution to stop DDD() from running forever. But when
   HHH simulates DDD(), it's analyzing an "idealized" version
   of DDD() where nothing stops the recursion. In the simulation,
   DDD() is seen as endlessly recursive, so HHH concludes that
   it would not halt without external intervention.
</ChatGPT>
>
https://chatgpt.com/share/67158ec6-3398-8011-98d1-41198baa29f2

>
Just admitmits that HHH gets the wrong answer, because you lied, because the HHH that DDD calls will also abort and return to DDD, so DDD would halt.
>
Remember, you AGREED above that it is the behavior of the INFINITE emulation, not the finite emulation of HHH defines the answer.
>

>
A termination analyzer / halt decider must PREDICT
non terminating behavior not measure it.
>
If a termination analyzer / halt decider MEASURES
non-terminating behavior IT CANNOT REPORT THIS.
>

>

Of course, that is for this exact input, which uses the copy of H that does abort and return.
>

>
No it is not.
<ChatGPT>
   when HHH simulates DDD(), it's analyzing an
   "idealized" version of DDD() where nothing
   stops the recursion.
</ChatGPT>

>
In other words you are admitting that it isn't actually looking at the input it was given.
>

>
ChatGPT (using its own words) and I both agree that HHH
is supposed to predict the behavior of the infinite
emulation on the basis of its finite emulation.
>

>
Yes, but that behavior is DEFINED by the actual behavior of the actual machine.
>

>
No it is not. It is never based on the actual behavior
of the actual machine for any non-terminating inputs.

>
Then you don't undetstand the requirement for something to be a semantic property.
>

>
The actual behavior specified by the finite string input
to HHH does include HHH emulating itself emulating DDD
such that this DD *not some other DDD somewhere else*
cannot possibly reach its own "return" instruction
whether HHH emulates DDD forever or some finite number
of times.

 But, since the HHH that DDD calls DOES abort its emulation, that logic is INVALID.
 

A non-terminating input is any input that would never terminate
unless aborted. DDD emulated by HHH would never terminate unless
aborted. The DDD that does terminate without being aborted is
a different DDD, not the one that HHH is reporting on.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer