Re: Flibble’s Leap: Why Behavioral Divergence Implies a Type Distinction in the Halting Problem

On 5/11/2025 1:54 PM, olcott wrote:

On 5/11/2025 12:49 PM, dbush wrote:

On 5/11/2025 1:44 PM, olcott wrote:

On 5/11/2025 12:34 PM, dbush wrote:

On 5/11/2025 1:14 PM, olcott wrote:

On 5/11/2025 11:54 AM, dbush wrote:

On 5/11/2025 12:49 PM, olcott wrote:

The category error is actually the fact that everyone
here expects a termination analyzer to report on behavior
other than the behavior that its input finite string
actually specifies.

>
That's because it's whether or not the algorithm described by the input halts when executed directly.
>
No one cares what "the behavior that its input finite string specifies" because that's not what we asked about.

>
int sum(int x, int y) { return x + y ; }
when you ask about the sum of 5 + 7 using sum(3,2)
you are asking the wrong question.
>
HHH reports on the behavior that DDD specifies.
sum reports on the sum that its inputs specify.
>

>
Category error.  (2,3) is not (5,7), but (DDD) is (DDD).
>

>
DDD correctly emulated by HHH SPECIFIES RECURSIVE EMULATION
DDD correctly emulated by HHH1 DOES NOT SPECIFY RECURSIVE EMULATION
>
>
>

>
What DDD "specifies" is irrelevent.  What matters is what algorithm is described by DDD,

 Specifies means provides every single step
of the entire execution trace.
 Describes means to mention some details.
We could "describe" DDD by saying that DDD
has the name DDD.
 

False.  By definition, a description contains all information necessary to exactly replicate what was described.
"DDD" describes the fixed code of the function DDD, the fixed code of the function HHH, and the fixed code of every thing HHH calls down to the OS level.
That UTM(DDD) exactly replicates the behavior of DDD when executed directly proves this is an accurate description.
Which means that given the description "DDD", the response is required to be 1 to meet the requirements:
Given any algorithm (i.e. a fixed immutable sequence of instructions) X described as <X> with input Y:
A solution to the halting problem is an algorithm H that computes the following mapping:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed directly