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

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.

Only a knucklehead would think that HHH is supposed
to actually measure infinite behavior.

But it needs to actually prove that it would occur before it can claim it.
Your problem is you think it is ok to LIE if that is the best you know.

 

In other words, you are just lying about what you are doing.
>
DDD calls the HHH that aborts, not the idealized one, and thus your arguement ADMITS it is just lying.
>

>

That is the DEFINITION of a semantic property, the FINAL results of the execution (or complete emulation) of the program described by the input.
>
Something you new system doesn't seem to be able to handle.
>
>

>

>