CURRENT THEORY

1 H(d d) returns LOOP
2 d(d) calls H(d d)
3 d(d) : H(d d) also returns LOOP
4 d(d) halts

3 must be true by elementary function theory H(d d) always returns the same value

H(a b) is just a CHUNK OF CODE

function D(x)
LET a=x
LET b=x
LET RESULT = *CHUNK OF CODE*

The chunk of code is the SAME!

===========================

NEW THEORY

H(a b) is not a pure function
it can return different values depending on what called it.

function H(a b)
RESULT = * calculates whether a(b) halts *
if (topstack==1) return RESULT
else return NOT(RESULT)

================================

LETS SEE HOW IT WORKS!

function d(x)
if (halt(x x)) d(x)

LET
halt(d d) = 0

PERSON ENTERS
?> HALT(d d) [ENTER] on keyboard

function H(a b)
RESULT = * calculates whether a(b) halts *
if (topstack==1) return RESULT
else return NOT(RESULT)

TOPSTACK=1 since its the top level function call
so
H(d d) returns 0

================

PERSON ENTERS
?> D(d) on keyboard

function d(x)
if (halt(x x)) d(x)

d(d)
==> if H(d d) d(d)

D(d) calls halt as a SUBROUTINE

function H(a b)
RESULT = * calculates whether a(b) halts *
if (topstack==1) return RESULT
else return NOT(RESULT)

TOPSTACK = 2
so this time H(d d) returns 1

SO D(d) LOOPS EXACTLY AS HALT PREDICTED

Similarly for when HALT(d d) returns TRUE

> The idea that a machine can tell if it is being run directly or being
> simulated is incorrect, as a properly simulated machine, by definition,
> can't tell it is being simulated, and a simulation that lets it know it
> is being simulated is by defintion not seeing the actual behavior of the
> machine it is simulating.

the tape looks like this for halt (say d is the 5th turing machine)

================================
0 | 1 | 1 | 1| 1 | 1 | 0 | 1 | 1 | 1 | 1 | 1 | 1 | 0
================================
HALT

Then you click start and the TM computes HALT (5 5) onto the tape

Halt can easily do a scan check on the tape to see its just 2 number input

The tape for d(d) looks entirely different

That a TM can emulate another TM perfectly is a flaw in computer science

Only simple languages can have pure simulations

Any reasonable language can check the depth of the recursion function call stack
and know which function called it

Stop relying on TM=recursively called pure functions

In pure function theory perhaps HALT gets a contradiction but this is overridable

PURE FUNCTIONS

CONTRAINT
ALL FUNCTIONS ADD AN EXTRA PARAMETER S

F(A B)
==>
F(S A B)

ALL FUNCTIONS INCREMENT S AS THE 1ST LINE

F(S A B)
S++
.... rest of function ..

Use this EQUVALENT MODEL OF COMPUTATION
and you can solve HALT