Re: Deciders are ONLY accountable for their actual inputs ---

On 2024-06-02 17:23:00 +0000, Richard Damon said:

On 6/2/24 9:46 AM, olcott wrote:

On 6/2/2024 2:56 AM, Mikko wrote:

On 2024-06-01 14:44:50 +0000, olcott said:
 

On 6/1/2024 2:56 AM, Mikko wrote:

On 2024-05-31 14:25:40 +0000, olcott said:
 

On 5/31/2024 2:50 AM, Fred. Zwarts wrote:

Op 31.mei.2024 om 00:01 schreef olcott:

On 5/30/2024 4:54 PM, joes wrote:

Am Thu, 30 May 2024 09:55:24 -0500 schrieb olcott:
 

typedef int (*ptr)();  // ptr is pointer to int function in C
00       int H(ptr p, ptr i);
01       int D(ptr p)
02       {
03         int Halt_Status = H(p, p);
04         if (Halt_Status)
05           HERE: goto HERE;
06         return Halt_Status;
07       }
08
09       int main()
10       {
11         H(D,D);
12         return 0;
13       }
 The left hand-side are line numbers of correct C code.
This code does compile and does conform to c17.
 Everyone with sufficient knowledge of C can easily determine that D
correctly emulated by any *pure function* H (using an x86 emulator)
cannot possibly reach its own simulated final state at line 06 and halt.

Yeah, of course not, if H doesn’t halt.
 

 To actually understand my words (as in an actual honest dialogue)
you must pay careful attention to every single word. Maybe you
had no idea that *pure functions* must always halt.
 Or maybe you did not know that every computation that never reaches
its own final state *DOES NOT HALT* even if it stops running because
it is no longer simulated.

 Since the claim is that H is also a computation, it holds for H, as well. That means that H *DOES NOT HALT* even if it stops running because it is no longer simulated.
 

 *pure function H definitely halts you are confused*

 A pure function does not halt (in C that means that a pure function
does not call exit). A pure function returns.
 

 When a pure function returns this is the equivalent of the theory
of computation halting.

 In ceratin sense, yes. But the term "pure function" is mainly used
in a different context where the word "halting" has a more specific
meaning.
 

 I need to maintain a constant mapping between theory of computation
terminology and software engineering terminology.
 Computable Function(comp sci) <is equivalent to> Pure function(SE)
I want it to be easy for software engineers to understand my proof.

 Nope. In Computation Theory, a "Computable Function" is just a mathematical concept of a Mapping (a, normally infinite, set of tuples of unique input values and output values) which happens to have a realizable algroith (aka Turing Machine) that can compute it.
 The closest equivalent to a SE "Pure Function" is a Turing Machine or Equivalent, or an "Algorithm"
 SE, to my knowledge, doesn't really have the equvalent of the Computation Theory "Computable Function", but something like it might be expressed in the requirements for the function. It is the specification of what outputs a given input SHOULD generate for the SE function to be correct.

Much of sofware engineering attempts to produce a computable function
that solves a particular problem. Usually the requirement is stronger
that mere computablity: there limits to the time and memory, sometimes
to electricity. There are also constraints on hardware.
For example, often the requirement is not that the computation halts
but that it halts in 100 microseconds (or in some other time).
--
Mikko