Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it)

28 views
Skip to first unread message

olcott

unread,
Jul 14, 2022, 3:19:59 PMJul 14
to
This is an explanation of a key new insight into the halting problem
provided in the language of software engineering. Technical computer
science terms are explained using software engineering terms. No
knowledge of the halting problem is required.

It is based on fully operational software executed in the x86utm
operating system. The x86utm operating system (based on an excellent
open source x86 emulator) was created to study the details of the
halting problem proof counter-examples at the much higher level of
abstraction of C/x86.

typedef void (*ptr)();
int H(ptr p, ptr i); // simulating halt decider

void P(ptr x)
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return;
}

int main()
{
Output("Input_Halts = ", H(P, P));
}

When simulating halt decider H(P,P) simulates its input we can see that:
(1) Function H() is called from P().
(2) With the same arguments to H().
(3) With no instructions in P preceding its invocation of H(P,P).

The above shows that the simulated P cannot possibly terminate normally.
Because H can see the same (1)(2)(3) that we see H aborts its simulation
of P and rejects P as non-halting.

In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program
and an input, whether the program will finish running, or continue
to run forever. Alan Turing proved in 1936 that a general
algorithm to solve the halting problem for all possible program-
input pairs cannot exist.

For any program H that might determine if programs halt, a
"pathological" program P, called with some input, can pass its own
source and its input to H and then specifically do the opposite of
what H predicts P will do. No H can exist that handles this case.
https://en.wikipedia.org/wiki/Halting_problem

H and P implement the exact pathological relationship to each other as
described above. Because H(P,P) does handle this case the above halting
problem undecidable input template has been refuted.

*When this halt deciding principle understood to be correct*
A halt decider must compute the mapping from its inputs to an accept or
reject state on the basis of the actual behavior that is actually
specified by these inputs.

*Then (by logical necessity) this implements that principle*
Every simulating halt decider that correctly simulates its input until
it correctly predicts that this simulated input would never terminate
normally, correctly rejects this input as non-halting.

*H is a Pure function*
https://en.wikipedia.org/wiki/Pure_function

thus implements a *Computable function*
https://en.wikipedia.org/wiki/Computable_function

Thus H is Turing computable.

*Halting problem proofs refuted on the basis of software engineering*
https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering



--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

Mr Flibble

unread,
Jul 14, 2022, 3:29:02 PMJul 14
to
You forgot to mention infinite recursion which I suppose is progress.

/Flibble

olcott

unread,
Jul 14, 2022, 4:02:39 PMJul 14
to
I have proved that H(P,P) == 0 is correct.

I have shown that H/P does implement the HP's "impossible input" template.

Therefore I have refuted all of the halting problem proofs that rely on
this template.

Mr Flibble

unread,
Jul 14, 2022, 4:22:46 PMJul 14
to
Equating pathological input with non-halting is erroneous: you are only
doing that because your broken solution treats it as "infinite
recursion". There is no recursion in [Strachey 1965] and the HP proofs
based on it.

/Flibble

Chris M. Thomasson

unread,
Jul 14, 2022, 4:27:40 PMJul 14
to
On 7/14/2022 12:19 PM, olcott wrote:
> This is an explanation of a key new insight into the halting problem
> provided in the language of software engineering. Technical computer
> science terms are explained using software engineering terms. No
> knowledge of the halting problem is required.
>
> It is based on fully operational software executed in the x86utm
> operating system. The x86utm operating system (based on an excellent
> open source x86 emulator) was created to study the details of the
> halting problem proof counter-examples at the much higher level of
> abstraction of C/x86.
>
> typedef void (*ptr)();
> int H(ptr p, ptr i); // simulating halt decider
>
> void P(ptr x)
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H(P, P));
> }

Where is the guts of function H?

Richard Harnden

unread,
Jul 14, 2022, 4:53:13 PMJul 14
to
On 14/07/2022 21:27, Chris M. Thomasson wrote:
> On 7/14/2022 12:19 PM, olcott wrote:
>>
>> int H(ptr p, ptr i); // simulating halt decider
>
> Where is the guts of function H?

This doesn't exist. It never has, it never will.



olcott

unread,
Jul 14, 2022, 5:02:55 PMJul 14
to
There is no recursion in any of the conventional proofs only because no
one ever previously bothered to fully examine how a simulating halt
decider would address these otherwise "impossible" inputs.

I first addressed this here: comp.theory (more than five years ago)
[Solution to one instance of the Halting Problem]
On 3/14/2017 9:05 AM, peteolcott wrote:

Prior to this I made this discovery:
"It looks like the original specification provided in the Linz text may
be infinitely recursive in that each TM requires its own input."

In this Researchgate paper:
Self Modifying Turing Machine (SMTM) Solution to the Halting Problem
(concrete example) August 2016 (almost six years ago)


This revision that I made today is much simpler than all the rest:

olcott

unread,
Jul 14, 2022, 5:06:50 PMJul 14
to
I have to refactor about 50 pages of code before I can publish it.
My current paper is so simple that H can be validated as correct without
any need to see its source-code.

olcott

unread,
Jul 14, 2022, 5:09:40 PMJul 14
to
Try carefully studying the first page of my paper and see if you still
feel the same way. I have revised this paper thousands of times based on
many thousands or reviews. It is finally simple enough that most
everyone here can validate it.

Chris M. Thomasson

unread,
Jul 14, 2022, 5:16:47 PMJul 14
to
Well, does refactor mean porting to another language/machine and/or
changing the actual logic of function H?

Chris M. Thomasson

unread,
Jul 14, 2022, 5:21:17 PMJul 14
to
On 7/14/2022 2:09 PM, olcott wrote:
> On 7/14/2022 3:53 PM, Richard Harnden wrote:
>> On 14/07/2022 21:27, Chris M. Thomasson wrote:
>>> On 7/14/2022 12:19 PM, olcott wrote:
>>>>
>>>> int H(ptr p, ptr i); // simulating halt decider
>>>
>>> Where is the guts of function H?
>>
>> This doesn't exist.  It never has, it never will.
>>
>>
>>
>
> Try carefully studying the first page of my paper and see if you still
> feel the same way. I have revised this paper thousands of times based on
> many thousands or reviews. It is finally simple enough that most
> everyone here can validate it.
>
> *Halting problem proofs refuted on the basis of software engineering*
> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
>
>

Can I code up H by reading the paper?

olcott

unread,
Jul 14, 2022, 5:25:00 PMJul 14
to
No the actual code for H is clean, correct, complete and finally (after
nine months of work) Turing computable. It is the 50 pages of the x86utm
operating system that are still quite messy.

>>
>> *Halting problem proofs refuted on the basis of software engineering*
>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
>>
>>
>


Chris M. Thomasson

unread,
Jul 14, 2022, 5:32:18 PMJul 14
to
Slap a copyright on H, and state that it is as it is, and post it?

Say the docs are soon to come?

olcott

unread,
Jul 14, 2022, 5:32:34 PMJul 14
to
No but you can verify that H(P,P) correctly determines the halt status
of the halting problem's "impossible" input by carefully studying the
first page of the paper.

Example 03 (on another page) has the annotated x86 source-code of P()
and main() the execution trace of main and the execution trace of P()
simulated by H().

In Example 03 I annotated the x86 source-code to make it much easier for
C programmers. I explain how each line of x86 code corresponds to its C
source.

olcott

unread,
Jul 14, 2022, 5:35:29 PMJul 14
to
I want to hold that back so that academic journals have something brand
new never seen before that they can publish.

It really is very easy to validate my work without seeing the
source-code for H.

>
>>
>>>>
>>>> *Halting problem proofs refuted on the basis of software engineering*
>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
>
>
>
>


Chris M. Thomasson

unread,
Jul 14, 2022, 5:40:13 PMJul 14
to
On 7/14/2022 2:24 PM, olcott wrote:
> On 7/14/2022 4:16 PM, Chris M. Thomasson wrote:
>> On 7/14/2022 2:06 PM, olcott wrote:
>>> On 7/14/2022 3:27 PM, Chris M. Thomasson wrote:
>>>> On 7/14/2022 12:19 PM, olcott wrote:
[...]
>>>> Where is the guts of function H?
>>>>
>>>
>>> I have to refactor about 50 pages of code before I can publish it.
>>> My current paper is so simple that H can be validated as correct
>>> without any need to see its source-code.
>>
>> Well, does refactor mean porting to another language/machine and/or
>> changing the actual logic of function H?
>>
>
> No the actual code for H is clean, correct, complete and finally (after
> nine months of work) Turing computable. It is the 50 pages of the x86utm
> operating system that are still quite messy.
[...]

Humm... I still think I have a new fractal because I posted my ideas and
code about it, and so far... No hits about "I have seen this before".
You should just post your H code, and say the fifty pages of doc's are
well in progress. Fwiw, here is my code for said fractal:

https://fractalforums.org/fractal-mathematics-and-new-theories/28/experimental-tangent-fractal/4817/msg34795#new

read all. Can you get to the link? Also, just because docs are not 100%
in order, it can be interesting to post them anyway. To show progress in
a history, so to speak:

http://funwithfractals.atspace.cc/ct_cipher/

Click here:

http://fractallife247.com/test/hmac_cipher/ver_0_0_0_1?ct_hmac_cipher=b8dfbc29229ce2a681ac17429316ce6e230066676e14f824acc106436f2ae64cd7d2535f41ecfc9aa189a486e568c232061ed41d9e59b015cc30b2f6df5fe99529b96f1c000005e56b839f1299fd3baf4353

;^)

Chris M. Thomasson

unread,
Jul 14, 2022, 5:45:48 PMJul 14
to
On 7/14/2022 12:19 PM, olcott wrote:
Step by step docs, lol. By me. Why do you sort of seem a bit "afraid" to
post your own "cool" work:

https://github.com/ChrisMThomasson/fractal_cipher/blob/master/FFE/Pre-Alpha%20Rough%20Draft%20FFE%20Tutorial.pdf

olcott

unread,
Jul 14, 2022, 5:46:14 PMJul 14
to
Another reason that I will not post the code is "Pearls before swine".
It really is easy to see that H(P,P) does correctly determine the halt
status of the halting problem's "impossible" input template on the first
page of my paper. People not willing to do that have not demonstrated
enough sincerity in the desire for an honest dialogue.

olcott

unread,
Jul 14, 2022, 5:57:49 PMJul 14
to
It loses all patent rights once it is published.

Chris M. Thomasson

unread,
Jul 14, 2022, 6:21:36 PMJul 14
to
Are you referring to transferring ownership to public domain?

Mr Flibble

unread,
Jul 14, 2022, 6:30:43 PMJul 14
to
On Thu, 14 Jul 2022 16:02:35 -0500
I have shown that a simulating halt decider needn't be recursive in
nature:

https://github.com/i42output/halting-problem/blob/main/README.txt

/Flibble

olcott

unread,
Jul 14, 2022, 6:37:29 PMJul 14
to
No. Because the halting problem proofs have withstood the test of 87
years of scrutiny my simple solution would pass the patent office's
requirement that a solution not be obvious.

olcott

unread,
Jul 14, 2022, 6:41:25 PMJul 14
to
You sure do make it easy to review your work.

"When the simulator detects the call to H in P it forks
the simulation into a non-halting branch"

There is an infinite set of cases where this overly simplistic criteria
gets the wrong answer.

Chris M. Thomasson

unread,
Jul 14, 2022, 6:44:13 PMJul 14
to
When do you feel that you are in a position to go ahead and submit your
work to a patent office? Less than a year?

olcott

unread,
Jul 14, 2022, 6:55:03 PMJul 14
to
I could easily do it right now.
It only costs $100 to lock in patent rights for a year.

Chris M. Thomasson

unread,
Jul 14, 2022, 7:06:07 PMJul 14
to
Be careful, and watch out for challenges!

Chris M. Thomasson

unread,
Jul 14, 2022, 7:07:16 PMJul 14
to
Have you conducted a patent feasibility check, yet?

Chris M. Thomasson

unread,
Jul 14, 2022, 7:08:37 PMJul 14
to
Do not let what happened to me happen to you!

olcott

unread,
Jul 14, 2022, 7:12:28 PMJul 14
to
I have already prosecuted two of my own patents myself.
They are both currently in force. One of them seems to expire next
month. The other one is good until 2034.

olcott

unread,
Jul 14, 2022, 7:15:49 PMJul 14
to
I already know the whole process from prosecuting two of my own patents
myself. I was wrong it only costs $75 to lock in patent rights for a
year for a micro entity. A provisional patent can be the whole actual
patent.

Chris M. Thomasson

unread,
Jul 14, 2022, 7:17:32 PMJul 14
to
20070067770

Chris M. Thomasson

unread,
Jul 14, 2022, 7:18:33 PMJul 14
to
A challenge, by say IBM?

Chris M. Thomasson

unread,
Jul 14, 2022, 7:19:13 PMJul 14
to
Ever heard the term, my lawyers are bigger than yours?

olcott

unread,
Jul 14, 2022, 7:25:41 PMJul 14
to
I don't want to continue to stray off-topic for this group. I only want
to focus on validating the software engineering of my paper.

Chris M. Thomasson

unread,
Jul 14, 2022, 8:15:47 PMJul 14
to
Show code that we all can compile, show H?

Siri Cruise

unread,
Jul 14, 2022, 8:25:00 PMJul 14
to
In article <taqbj4$2revn$1...@dont-email.me>,
"Chris M. Thomasson" <chris.m.t...@gmail.com> wrote:

> Show code that we all can compile, show H?

Conjectures like Goldbach can be written as programs that halt
(on a counterexample) if false, and do not halt if true. Use a
halting decider to prove number theory conjectures, and I'll take
it seriously.

--
:-<> Siri Seal of Disavowal #000-001. Disavowed. Denied. Deleted. @
'I desire mercy, not sacrifice.' /|\
Discordia: not just a religion but also a parody. This post / \
I am an Andrea Chen sockpuppet. insults Islam. Mohammed

olcott

unread,
Jul 14, 2022, 8:33:34 PMJul 14
to
On 7/14/2022 7:24 PM, Siri Cruise wrote:
> In article <taqbj4$2revn$1...@dont-email.me>,
> "Chris M. Thomasson" <chris.m.t...@gmail.com> wrote:
>
>> Show code that we all can compile, show H?
>
> Conjectures like Goldbach can be written as programs that halt
> (on a counterexample) if false, and do not halt if true. Use a
> halting decider to prove number theory conjectures, and I'll take
> it seriously.
>

I already addressed this. A computer program that has infallible
mathematical reasoning has a broader scope that a program that can
correctly determine whether or not another program will normally
terminate on some fixed finite string input.

Chris M. Thomasson

unread,
Jul 14, 2022, 8:51:52 PMJul 14
to
On 7/14/2022 5:24 PM, Siri Cruise wrote:
> In article <taqbj4$2revn$1...@dont-email.me>,
> "Chris M. Thomasson" <chris.m.t...@gmail.com> wrote:
>
>> Show code that we all can compile, show H?
>
> Conjectures like Goldbach can be written as programs that halt
> (on a counterexample) if false, and do not halt if true. Use a
> halting decider to prove number theory conjectures, and I'll take
> it seriously.
>

Is a program that halts or not based on a random number, coin toss so to
speak, well, is that a valid program or not?

olcott

unread,
Jul 14, 2022, 9:00:37 PMJul 14
to
All software random number generators are pseudo-random and depend on a
defined process. Hardware random number generators exist, yet are
outside the scope of pure mathematical analysis.

Richard Damon

unread,
Jul 14, 2022, 9:22:13 PMJul 14
to

On 7/14/22 4:02 PM, olcott wrote:

> I have proved that H(P,P) == 0 is correct.

No, you haven't. You have used unsound logic to make the claim. H(P,P)
returning 0 can't be correct, because P(P) Halts if H(P,P) returns 0,
and the behavior of the input to H(P,P) is the behavior of P(P) since
that is what P is asking about when it calls H)P,P).

>
> I have shown that H/P does implement the HP's "impossible input" template.

No, since P calls H(P,P) to ask it about P(P), but you claim that isn't
what it means. Therefore, you haven't implemented the "impossib;e input"
template.

Therefore either you are a Liar, or incompetent.

>
> Therefore I have refuted all of the halting problem proofs that rely on
> this template.
>
>

Nope, just prved you don't understand the template.

Siri Cruise

unread,
Jul 14, 2022, 9:28:18 PMJul 14
to
In article <taqdmr$2rk1e$2...@dont-email.me>,
"Chris M. Thomasson" <chris.m.t...@gmail.com> wrote:

> On 7/14/2022 5:24 PM, Siri Cruise wrote:
> > In article <taqbj4$2revn$1...@dont-email.me>,
> > "Chris M. Thomasson" <chris.m.t...@gmail.com> wrote:
> >
> >> Show code that we all can compile, show H?
> >
> > Conjectures like Goldbach can be written as programs that halt
> > (on a counterexample) if false, and do not halt if true. Use a
> > halting decider to prove number theory conjectures, and I'll take
> > it seriously.
> >
>
> Is a program that halts or not based on a random number, coin toss so to
> speak, well, is that a valid program or not?

That's Microsoft Widows.

Chris M. Thomasson

unread,
Jul 14, 2022, 9:28:27 PMJul 14
to
On 7/14/2022 6:00 PM, olcott wrote:
> On 7/14/2022 7:51 PM, Chris M. Thomasson wrote:
>> On 7/14/2022 5:24 PM, Siri Cruise wrote:
>>> In article <taqbj4$2revn$1...@dont-email.me>,
>>>   "Chris M. Thomasson" <chris.m.t...@gmail.com> wrote:
>>>
>>>> Show code that we all can compile, show H?
>>>
>>> Conjectures like Goldbach can be written as programs that halt
>>> (on a counterexample) if false, and do not halt if true. Use a
>>> halting decider to prove number theory conjectures, and I'll take
>>> it seriously.
>>>
>>
>> Is a program that halts or not based on a random number, coin toss so
>> to speak, well, is that a valid program or not?
>
> All software random number generators are pseudo-random and depend on a
> defined process. Hardware random number generators exist, yet are
> outside the scope of pure mathematical analysis.
>

A rnd. No more, no less... So, your claims do not hold against it?

Chris M. Thomasson

unread,
Jul 14, 2022, 9:28:50 PMJul 14
to
On 7/14/2022 6:28 PM, Siri Cruise wrote:
> In article <taqdmr$2rk1e$2...@dont-email.me>,
> "Chris M. Thomasson" <chris.m.t...@gmail.com> wrote:
>
>> On 7/14/2022 5:24 PM, Siri Cruise wrote:
>>> In article <taqbj4$2revn$1...@dont-email.me>,
>>> "Chris M. Thomasson" <chris.m.t...@gmail.com> wrote:
>>>
>>>> Show code that we all can compile, show H?
>>>
>>> Conjectures like Goldbach can be written as programs that halt
>>> (on a counterexample) if false, and do not halt if true. Use a
>>> halting decider to prove number theory conjectures, and I'll take
>>> it seriously.
>>>
>>
>> Is a program that halts or not based on a random number, coin toss so to
>> speak, well, is that a valid program or not?
>
> That's Microsoft Widows.
>

LOL! :^)

Chris M. Thomasson

unread,
Jul 14, 2022, 9:29:17 PMJul 14
to
Do you have access to a coin? ;^)

Richard Damon

unread,
Jul 14, 2022, 9:32:43 PMJul 14
to
On 7/14/22 5:09 PM, olcott wrote:
> On 7/14/2022 3:53 PM, Richard Harnden wrote:
>> On 14/07/2022 21:27, Chris M. Thomasson wrote:
>>> On 7/14/2022 12:19 PM, olcott wrote:
>>>>
>>>> int H(ptr p, ptr i); // simulating halt decider
>>>
>>> Where is the guts of function H?
>>
>> This doesn't exist.  It never has, it never will.
>>
>>
>>
>
> Try carefully studying the first page of my paper and see if you still
> feel the same way. I have revised this paper thousands of times based on
> many thousands or reviews. It is finally simple enough that most
> everyone here can validate it.
>
> *Halting problem proofs refuted on the basis of software engineering*
> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
>
>

Your rule (3) is incorrect, because you omit some of the algorithm of P
that can break the loop.

Unless you can show some proof that allows you to use this rule the way
you are using it, it is just an unproved (actually disproven) claim.

Your repeating this claim after it has been pointed out without
providing any actual rebutal of the pointing out of error shows that you
don't know what you are talking about.

Chris M. Thomasson

unread,
Jul 14, 2022, 9:34:37 PMJul 14
to
On 7/14/2022 2:45 PM, olcott wrote:
> On 7/14/2022 4:39 PM, Chris M. Thomasson wrote:
>> On 7/14/2022 2:24 PM, olcott wrote:
>>> On 7/14/2022 4:16 PM, Chris M. Thomasson wrote:
>>>> On 7/14/2022 2:06 PM, olcott wrote:
>>>>> On 7/14/2022 3:27 PM, Chris M. Thomasson wrote:
>>>>>> On 7/14/2022 12:19 PM, olcott wrote:
>> [...]
>>>>>> Where is the guts of function H?
>>>>>>
>>>>>
>>>>> I have to refactor about 50 pages of code before I can publish it.
>>>>> My current paper is so simple that H can be validated as correct
>>>>> without any need to see its source-code.
>>>>
>>>> Well, does refactor mean porting to another language/machine and/or
>>>> changing the actual logic of function H?
>>>>
>>>
>>> No the actual code for H is clean, correct, complete and finally
>>> (after nine months of work) Turing computable. It is the 50 pages of
>>> the x86utm operating system that are still quite messy.
>> [...]
>>
>> Humm... I still think I have a new fractal because I posted my ideas
>> and code about it, and so far... No hits about "I have seen this
>> before". You should just post your H code, and say the fifty pages of
>> doc's are well in progress. Fwiw, here is my code for said fractal:
>>
>> https://fractalforums.org/fractal-mathematics-and-new-theories/28/experimental-tangent-fractal/4817/msg34795#new
>>
>>
>> read all. Can you get to the link? Also, just because docs are not
>> 100% in order, it can be interesting to post them anyway. To show
>> progress in a history, so to speak:
>>
>> http://funwithfractals.atspace.cc/ct_cipher/
>>
>> Click here:
>>
>> http://fractallife247.com/test/hmac_cipher/ver_0_0_0_1?ct_hmac_cipher=b8dfbc29229ce2a681ac17429316ce6e230066676e14f824acc106436f2ae64cd7d2535f41ecfc9aa189a486e568c232061ed41d9e59b015cc30b2f6df5fe99529b96f1c000005e56b839f1299fd3baf4353
>>
>>
>> ;^)
>
> Another reason that I will not post the code is "Pearls before swine".

If your work has any merit, let everybody see it! Right?

> It really is easy to see that H(P,P) does correctly determine the halt
> status of the halting problem's "impossible" input template on the first
> page of my paper. People not willing to do that have not demonstrated
> enough sincerity in the desire for an honest dialogue.
>

olcott

unread,
Jul 14, 2022, 9:44:18 PMJul 14
to
There is no sense continuing this dialogue until after you carefully
study the first page of my paper:
It really is easy to see that H(P,P) does correctly determine the halt
status of the halting problem's "impossible" input template on the
first page of my paper. People not willing to do that have not
demonstrated enough sincerity in the desire for an honest dialogue.



Chris M. Thomasson

unread,
Jul 14, 2022, 9:47:09 PMJul 14
to
How do I construct H?

Richard Damon

unread,
Jul 14, 2022, 9:53:40 PMJul 14
to
On 7/14/22 8:33 PM, olcott wrote:
> On 7/14/2022 7:24 PM, Siri Cruise wrote:
>> In article <taqbj4$2revn$1...@dont-email.me>,
>>   "Chris M. Thomasson" <chris.m.t...@gmail.com> wrote:
>>
>>> Show code that we all can compile, show H?
>>
>> Conjectures like Goldbach can be written as programs that halt
>> (on a counterexample) if false, and do not halt if true. Use a
>> halting decider to prove number theory conjectures, and I'll take
>> it seriously.
>>
>
> I already addressed this. A computer program that has infallible
> mathematical reasoning has a broader scope that a program that can
> correctly determine whether or not another program will normally
> terminate on some fixed finite string input.
>

And that is part of your problem, the Halting Problem isn't about
programs "normally terminating", but will the program terminate when it
is run. (on the "hardware" that such programs run is presumed idea so
the program won't stop unless it should stop).

It is NOT about anything else, in particular, not about what happens
when it is simulated by a program that doesn't EXACTLY replicate the
ideal hardware.

The fact that such a determination isn't actually prossible makes the
problem non-calculatable, not wrong.

This shows you claims about "not being the input" to be just dishonest
dodges, as the input (if done correctly) FULLY defines the behavior of
the machine, and thus all the behavior of that machine with that input
IS specified by the input, the machine just can't determine what it will
do in finite time as required to be a decider.

Mr Flibble

unread,
Jul 15, 2022, 2:23:50 AMJul 15
to
On Thu, 14 Jul 2022 17:41:06 -0500
olcott <No...@NoWhere.com> wrote:

> On 7/14/2022 5:30 PM, Mr Flibble wrote:
> > On Thu, 14 Jul 2022 16:02:35 -0500
> > olcott <No...@NoWhere.com> wrote:
> >
> >> On 7/14/2022 3:22 PM, Mr Flibble wrote:
> >>> On Thu, 14 Jul 2022 15:02:21 -0500
> >>> olcott <No...@NoWhere.com> wrote:
> >>>
> >>>> On 7/14/2022 2:28 PM, Mr Flibble wrote:
> >>>>> On Thu, 14 Jul 2022 14:19:38 -0500
> >>>>> olcott <No...@NoWhere.com> wrote:
> >>>>>
> >>>>>> This is an explanation of a key new insight into the halting
> >>>>>> problem provided in the language of software engineering.
> >>>>>> Technical computer science terms are explained using software
> >>>>>> engineering terms. No knowledge of the halting problem is
> >>>>>> required.
> >>>>>>
> >>>>>> It is based on fully operational software executed in the
> >>>>>> x86utm operating system. The x86utm operating system (based on
> >>>>>> an excellent open source x86 emulator) was created to study the
> >>>>>> details of the halting problem proof counter-examples at the
> >>>>>> much higher level of abstraction of C/x86.
> >>>>>>
> >>>>>> typedef void (*ptr)();
> >>>>>> int H(ptr p, ptr i); // simulating halt decider
> >>>>>>
> >>>>>> *Halting problem proofs refuted on the basis of software
> >>>>>> engineering*
> >>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
> >>>>>>
> >>>>>
> >>>>> You forgot to mention infinite recursion which I suppose is
> >>>>> progress.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> I have proved that H(P,P) == 0 is correct.
> >>>>
> >>>> I have shown that H/P does implement the HP's "impossible input"
> >>>> template.
> >>>>
> >>>> Therefore I have refuted all of the halting problem proofs that
> >>>> rely on this template.
> >>>
> >>> Equating pathological input with non-halting is erroneous: you are
> >>> only doing that because your broken solution treats it as
> >>> "infinite recursion". There is no recursion in [Strachey 1965]
> >>> and the HP proofs based on it.
> >>>
> >>> /Flibble
> >>>
> >>
> >> There is no recursion in any of the conventional proofs only
> >> because no one ever previously bothered to fully examine how a
> >> simulating halt decider would address these otherwise "impossible"
> >> inputs.
> >
> > I have shown that a simulating halt decider needn't be recursive in
> > nature:
> >
> > https://github.com/i42output/halting-problem/blob/main/README.txt
> >
> > /Flibble
> >
>
> You sure do make it easy to review your work.
>
> "When the simulator detects the call to H in P it forks
> the simulation into a non-halting branch"
>
> There is an infinite set of cases where this overly simplistic
> criteria gets the wrong answer.

That is neither an honest review or any kind of rebuttal: I have told
you before: assertions made without evidence can be dismissed without
evidence.

If you claim there are an infinite number of cases where it gets the
wrong answer then it shouldn't be too hard for to provide ONE case
backing up your claim.

/Flibble

olcott

unread,
Jul 15, 2022, 2:46:47 AMJul 15
to
Sure:

void P(ptr x)
{
static int count = 3;
count--;
if (!count) goto exit;
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
exit:
return;
}

int main()
{
Output("Input_Halts = ", H(P, P));
}


Chris M. Thomasson

unread,
Jul 15, 2022, 3:01:54 AMJul 15
to
On 7/14/2022 6:53 PM, Richard Damon wrote:
> On 7/14/22 8:33 PM, olcott wrote:
>> On 7/14/2022 7:24 PM, Siri Cruise wrote:
>>> In article <taqbj4$2revn$1...@dont-email.me>,
>>>   "Chris M. Thomasson" <chris.m.t...@gmail.com> wrote:
>>>
>>>> Show code that we all can compile, show H?
>>>
>>> Conjectures like Goldbach can be written as programs that halt
>>> (on a counterexample) if false, and do not halt if true. Use a
>>> halting decider to prove number theory conjectures, and I'll take
>>> it seriously.
>>>
>>
>> I already addressed this. A computer program that has infallible
>> mathematical reasoning has a broader scope that a program that can
>> correctly determine whether or not another program will normally
>> terminate on some fixed finite string input.
>>
>
> And that is part of your problem, the Halting Problem isn't about
> programs "normally terminating", but will the program terminate when it
> is run.

Right. Program A just might terminate sometime after the last star in
the universe burns out, some really old red dwarf. Program B will
continue on forever. A halting decider should tell me that A will halt,
or not. It depends on the logic of program A. So, if olcott has solved
it, well, that is interesting.

Richard Damon

unread,
Jul 15, 2022, 7:48:54 AMJul 15
to
I thought that program was illegal in your system as your system didn't
allow the use of static memory?

Note, P isn't a pure function, as there is a variable that affects it
that isn't an actual defined input.

Note, properly per a real definition of what a Halt Decider should do,
the H(P,P) needs to create a BRAND NEW instance of P to simulate, just
like starting a new program, so that P has ITS OWN copy of count, that
has been initialized to 3.

Remember, you have defined H to SIMULATE its input, which means that its
input is ISOLATED from the current environment, so it shouldn't be
accessing the count from the calling routine.

That is violating the concept of what is a computation.

Of course, you just don't understand ANY of that, which is why you think
you have actually acheived something when you haven't.


Remember, in the C context, Halting Deciders work on PROGRAMS, as
complete entities, because C functions don't represent represent the
Mathematical function BECAUSE they can cross communicate in ways that
aren't allowed.

WHen you try to translate that above code into a Turing Machine, you
will find out that if H sctually is a Turing Machine, based on using a
modified UTM to decide, the the P that the H will simulate will start
with its own value of count starting at 3.

Since P NEVER calls P, the first decrement from 3 to 2 is the ONLY
change in value that count will have.

H isn't allowed to access it to let its copy of P that it is simulating
to affect it.

You are just PROVING that you H isn't actually a Pure Function, as its
behavior is shown to be a changed by things other than its direct
parameters.

Richard Damon

unread,
Jul 15, 2022, 7:56:20 AMJul 15
to
On 7/15/22 3:01 AM, Chris M. Thomasson wrote:
> On 7/14/2022 6:53 PM, Richard Damon wrote:
>> On 7/14/22 8:33 PM, olcott wrote:
>>> On 7/14/2022 7:24 PM, Siri Cruise wrote:
>>>> In article <taqbj4$2revn$1...@dont-email.me>,
>>>>   "Chris M. Thomasson" <chris.m.t...@gmail.com> wrote:
>>>>
>>>>> Show code that we all can compile, show H?
>>>>
>>>> Conjectures like Goldbach can be written as programs that halt
>>>> (on a counterexample) if false, and do not halt if true. Use a
>>>> halting decider to prove number theory conjectures, and I'll take
>>>> it seriously.
>>>>
>>>
>>> I already addressed this. A computer program that has infallible
>>> mathematical reasoning has a broader scope that a program that can
>>> correctly determine whether or not another program will normally
>>> terminate on some fixed finite string input.
>>>
>>
>> And that is part of your problem, the Halting Problem isn't about
>> programs "normally terminating", but will the program terminate when
>> it is run.
>
> Right. Program A just might terminate sometime after the last star in
> the universe burns out, some really old red dwarf. Program B will
> continue on forever. A halting decider should tell me that A will halt,
> or not. It depends on the logic of program A. So, if olcott has solved
> it, well, that is interesting.
>
>

Right. Mathematics (or at least this part of this branch) isn't
concerend so much about "Practical", but Theoretical.

Part of the key is that "time" isn't a factor, it is the number of steps
done (is if finite or infinite).

In one sense, the sequence of states from a given machine and input
appear INSTANTLY when the question is posed, and the question is about
the length of that sequence of states, is it finite or infinite.

If it is finite, then there is a "Last" state that has the answer.

If it is infinite, then there is no "Last" state to have an answer.

Just as mathematics talks about numbers that are bigger then the number
of particles in the universe without problem (and considers that finite)
so to is the computation that uses more state than the univese could
hold might be halting.

Mr Flibble

unread,
Jul 15, 2022, 8:06:35 AMJul 15
to
On Fri, 15 Jul 2022 01:46:23 -0500
Nope; you seem to have forgotten that my decider is not recursive in
nature: my decider will correctly determine that that input is
pathological so will signal an exception.

/Flibble


olcott

unread,
Jul 15, 2022, 10:20:19 AMJul 15
to
The above terminates normally so your decider gets the wrong answer.

olcott

unread,
Jul 15, 2022, 10:22:48 AMJul 15
to
On 7/15/2022 2:01 AM, Chris M. Thomasson wrote:
> On 7/14/2022 6:53 PM, Richard Damon wrote:
>> On 7/14/22 8:33 PM, olcott wrote:
>>> On 7/14/2022 7:24 PM, Siri Cruise wrote:
>>>> In article <taqbj4$2revn$1...@dont-email.me>,
>>>>   "Chris M. Thomasson" <chris.m.t...@gmail.com> wrote:
>>>>
>>>>> Show code that we all can compile, show H?
>>>>
>>>> Conjectures like Goldbach can be written as programs that halt
>>>> (on a counterexample) if false, and do not halt if true. Use a
>>>> halting decider to prove number theory conjectures, and I'll take
>>>> it seriously.
>>>>
>>>
>>> I already addressed this. A computer program that has infallible
>>> mathematical reasoning has a broader scope that a program that can
>>> correctly determine whether or not another program will normally
>>> terminate on some fixed finite string input.
>>>
>>
>> And that is part of your problem, the Halting Problem isn't about
>> programs "normally terminating", but will the program terminate when
>> it is run.
>
> Right. Program A just might terminate sometime after the last star in
> the universe burns out, some really old red dwarf. Program B will
> continue on forever. A halting decider should tell me that A will halt,
> or not. It depends on the logic of program A. So, if olcott has solved
> it, well, that is interesting.
>
>

Mr Flibble

unread,
Jul 15, 2022, 10:32:25 AMJul 15
to
On Fri, 15 Jul 2022 09:19:59 -0500
It is a pathological input so neither halts nor doesn't halt:
pathological input is INVALID so the correct "answer" is to signal an
exception.

/Flibble

olcott

unread,
Jul 15, 2022, 11:07:55 AMJul 15