On May 14, 6:30 am, Chris Menzel <
cmen...@remove-this.tamu.edu> wrote:
> On Sun, 13 May 2012 10:15:08 -0500, Peter Olcott <OCR4Screen> said:
>
> > The Halting Problem proposes that it will always be impossible to
> > create a halting decider.
>
> The Halting Problem "proposes" no such thing. The Halting Problem is
> simply the problem of whether such a decider (in the form of a Turing
> machine, program, recursive function, what have you) exists. And as
> Turing himself proved, the answer is No. End of story (though of course
> the story is well worth learning).
The Halting Problem combined with the Church Turing Thesis does
suggest exactly that!
i.e. CTT = no new computational system can be more advanced than a
single TM
The Halting Problem may be solvable.
The problem is: Both the Godel Proof and Halting Proof are "copouts"!
"We can't program the function!", but we can formulate why we can't
find the solution instead!
The Godel proof begins...
Assume a PROOF() Predicate exists that inputs a theorem (GODEL NUMBER)
and outputs TRUE IFF a sequence of theorems in the theory conclude
with the final line equal to the input theorem under question.
i.e. a proof of the theorem exists by enumerable axiomatic modus
ponens.
The Proof concludes such a PROOF() Predicate doesn't exist!
Wait! Here it is!
PROOF(C) = C v (PROOF(A) ^ PROOF(B) ^ (A^B->C))
THE PROOF PREDICATE GODEL PROVED DOESN'T EXIST!
C is proven IF c is a theorem in the theory
OR C is derived from other theorems (A^B) in the theory!
It's slightly rearranged from the original specification, a dual tail
end recursive directed acyclic graph of binary deductions!
THEN the Godel Proof continues and INVENTS MULTIPLE PARALLEL THEORIES
...just to PROVE G and yet allow the statement to be TRUE ASWELL (i.e.
unproven in theory 2)
-------
CUT TO PREVIOUS POST..
Here is a Busy Beaver function that literally works to output the
"uncomputable" number sequence BB(1) BB(2) BB(3) ...
function BB(n) {
firstTM = get1stTM#ofSize(n)
lastTM = getlastTM#ofSize(n)
asymptote = 0
while(true) {
for (tm=firstTM, tm<=lastTM, tm++) {
retval = Run1Cycle(tm)
if !null(retval) {
if (find('0',retval)=0) { //unary output
if(retval>asymptote) {
asymptote=retval
display(asymptote)
}
}
}
}
}
}
********
Also, OMEGA can be computed the same way a GODEL STATEMENT IS PROVEN
in 'a different theory'.
The formula for a contradiction in a theory can be written
T |- A & T |- !A
A Godel statement true in theory T1 and proven in theory T2 is
T1 |- G & T2 |- PRV(G)
Programs could also be disjoint into 2.
P1 |- f(a) & P2 |- f(b)
Now we can express a meta-syntax of several parallel programs.
!EXIST(a) Pn |- H1(a) & Pn |- H2(a)
no single computer program can run H1() and H2() on the same input.
This is hard to detect as a pre-parsed syntax error since 'a' could be
a complex formula.
ALL(n,x,y) !(Pn |- H1(x) & Pn |- H2(y) )
That is, no program can call both H1 and H2, even if they are testing
different programs halt values where
T|-HALT(x) = P1|-H1() XOR P2|-H2()
i
.e. the HALT function is computed in a different program to where it
is calculated by functions H1() and H2()
***
Hiding the Halt value may not even be required, since the software is
tested by a DIFFERENT PROGRAM is easy to specify into the syntax,
something like:
T|-HALT(x) = P1|-H1() ^ P1|-H2() ^ P1|-H3() .. P1|-Hn()
where H1() H2() ... Hn() are PROGRAM STUBS inserted into the main
loops of the software to test.
***
SUMMARY OF ABOVE:
Use the GODEL - works in 1 theory and programmed in another method!
Herc