Here is the latest version of my paper "Getting Around the Halting
Problem." It is much more concise than the previous versions.

https://www.researchgate.net/publication/316562253_Getting_around_the_Halting_Problem

Comments appreciated.

Abstract:
There are numbers k and s and a URM program A(n,m) satisfying the
following conditions.
1. If A(n,m) halts, then C_n(m) diverges.
2. For all n, C_k(n) = A(n,n) and C_s(n) = C_k(s).
3. A(k,s) halts and for all n, A(s,n) diverges.
Here C_n(_) is a program with index n in some exhaustive enumeration of
all possible programs.

This has implications for solving the liar paradox and for
generalization of Gödel’s incompleteness theorem to formal systems other
than PA.

Newberry <newberryxy@gmail.com> writes:

> Here is the latest version of my paper "Getting Around the Halting Problem." It is much more concise than the previous versions.
>
> https://www.researchgate.net/publication/316562253_Getting_around_the_Halting_Problem
>
> Comments appreciated.

There is something very odd about your notation, and/or the explanation
is lacking.

The C_k are some enumeration of the programs in some model of
computation. You then define C_k(n) =def A(n,n). And you write it in
code as well:

C_k(n) { A(n,n) }

How can this be? In general, when i =/= j, C_i(n) =/= C_j(n) because
C_i and C_j are different programs.

I am aware that you are considering only halting and divergence -- the
=/= between C_i(n) =/= C_j(n) means they have (in general) different
halting behaviour.

--
Ben.

Ben wrote:
> Newberry <newberryxy@gmail.com> writes:
>
>> Here is the latest version of my paper "Getting Around the Halting Problem." It is much more concise than the previous versions.
>>
>> https://www.researchgate.net/publication/316562253_Getting_around_the_Halting_Problem
>>
>> Comments appreciated.
>
> There is something very odd about your notation, and/or the explanation
> is lacking.
>
> The C_k are some enumeration of the programs in some model of
> computation. You then define C_k(n) =def A(n,n). And you write it in
> code as well:
>
> C_k(n) { A(n,n) }
>
> How can this be? In general, when i =/= j, C_i(n) =/= C_j(n) because
> C_i and C_j are different programs.
>
> I am aware that you are considering only halting and divergence -- the
> =/= between C_i(n) =/= C_j(n) means they have (in general) different
> halting behaviour.

A(n,m) is a function. C_k(n) calls A(n,n). There is a compilable and
executable program in the appendix that does just that. C_k(n) is
somewhere in the list, and k is its index.

Newberry <newberryxy@gmail.com> writes:

> Ben wrote:
>> Newberry <newberryxy@gmail.com> writes:
>>
>>> Here is the latest version of my paper "Getting Around the Halting Problem." It is much more concise than the previous versions.
>>>
>>> https://www.researchgate.net/publication/316562253_Getting_around_the_Halting_Problem
>>>
>>> Comments appreciated.
>>
>> There is something very odd about your notation, and/or the explanation
>> is lacking.
>>
>> The C_k are some enumeration of the programs in some model of
>> computation. You then define C_k(n) =def A(n,n). And you write it in
>> code as well:
>>
>> C_k(n) { A(n,n) }
>>
>> How can this be? In general, when i =/= j, C_i(n) =/= C_j(n) because
>> C_i and C_j are different programs.
>>
>> I am aware that you are considering only halting and divergence -- the
>> =/= between C_i(n) =/= C_j(n) means they have (in general) different
>> halting behaviour.
>
> A(n,m) is a function. C_k(n) calls A(n,n).

Yes. The question is how can this make sense? Writing

C_k(n) { A(n,n) }

suggests that every computation is identical. That can't be what you
mean.

> There is a compilable and
> executable program in the appendix that does just that. C_k(n) is
> somewhere in the list, and k is its index.

I am glad that there is an explanation somewhere (if I have time I'll go
look), but I would think you'd want to avoid a reader having the
reaction I did within the first few lines of the paper. But maybe I am
not in your target readership.

--
Ben.

Ben wrote:
> Newberry <newberryxy@gmail.com> writes:
>
>> Ben wrote:
>>> Newberry <newberryxy@gmail.com> writes:
>>>
>>>> Here is the latest version of my paper "Getting Around the Halting Problem." It is much more concise than the previous versions.
>>>>
>>>> https://www.researchgate.net/publication/316562253_Getting_around_the_Halting_Problem
>>>>
>>>> Comments appreciated.
>>>
>>> There is something very odd about your notation, and/or the explanation
>>> is lacking.
>>>
>>> The C_k are some enumeration of the programs in some model of
>>> computation. You then define C_k(n) =def A(n,n). And you write it in
>>> code as well:
>>>
>>> C_k(n) { A(n,n) }
>>>
>>> How can this be? In general, when i =/= j, C_i(n) =/= C_j(n) because
>>> C_i and C_j are different programs.
>>>
>>> I am aware that you are considering only halting and divergence -- the
>>> =/= between C_i(n) =/= C_j(n) means they have (in general) different
>>> halting behaviour.
>>
>> A(n,m) is a function. C_k(n) calls A(n,n).
>
> Yes. The question is how can this make sense? Writing
>
> C_k(n) { A(n,n) }
>
> suggests that every computation is identical. That can't be what you
> mean.

That IS what I mean, i.e. for all n, C_k(n) = A(n,n).

>> There is a compilable and
>> executable program in the appendix that does just that. C_k(n) is
>> somewhere in the list, and k is its index.
>
> I am glad that there is an explanation somewhere (if I have time I'll go
> look), but I would think you'd want to avoid a reader having the
> reaction I did within the first few lines of the paper. But maybe I am
> not in your target readership.
>

Newberry <newberryxy@gmail.com> writes:

> Ben wrote:
>> Newberry <newberryxy@gmail.com> writes:
>>
>>> Ben wrote:
>>>> Newberry <newberryxy@gmail.com> writes:
>>>>
>>>>> Here is the latest version of my paper "Getting Around the Halting Problem." It is much more concise than the previous versions.
>>>>>
>>>>> https://www.researchgate.net/publication/316562253_Getting_around_the_Halting_Problem
>>>>>
>>>>> Comments appreciated.
>>>>
>>>> There is something very odd about your notation, and/or the explanation
>>>> is lacking.
>>>>
>>>> The C_k are some enumeration of the programs in some model of
>>>> computation. You then define C_k(n) =def A(n,n). And you write it in
>>>> code as well:
>>>>
>>>> C_k(n) { A(n,n) }
>>>>
>>>> How can this be? In general, when i =/= j, C_i(n) =/= C_j(n) because
>>>> C_i and C_j are different programs.
>>>>
>>>> I am aware that you are considering only halting and divergence -- the
>>>> =/= between C_i(n) =/= C_j(n) means they have (in general) different
>>>> halting behaviour.
>>>
>>> A(n,m) is a function. C_k(n) calls A(n,n).
>>
>> Yes. The question is how can this make sense? Writing
>>
>> C_k(n) { A(n,n) }
>>
>> suggests that every computation is identical. That can't be what you
>> mean.
>
> That IS what I mean, i.e. for all n, C_k(n) = A(n,n).

I don't know what to say. There is no sane model of computation in
which all programs are the same.

--
Ben.

On 4/12/2022 7:22 PM, Ben wrote:
> Newberry <newberryxy@gmail.com> writes:
>
>> Ben wrote:
>>> Newberry <newberryxy@gmail.com> writes:
>>>
>>>> Ben wrote:
>>>>> Newberry <newberryxy@gmail.com> writes:
>>>>>
>>>>>> Here is the latest version of my paper "Getting Around the Halting Problem." It is much more concise than the previous versions.
>>>>>>
>>>>>> https://www.researchgate.net/publication/316562253_Getting_around_the_Halting_Problem
>>>>>>
>>>>>> Comments appreciated.
>>>>>
>>>>> There is something very odd about your notation, and/or the explanation
>>>>> is lacking.
>>>>>
>>>>> The C_k are some enumeration of the programs in some model of
>>>>> computation. You then define C_k(n) =def A(n,n). And you write it in
>>>>> code as well:
>>>>>
>>>>> C_k(n) { A(n,n) }
>>>>>
>>>>> How can this be? In general, when i =/= j, C_i(n) =/= C_j(n) because
>>>>> C_i and C_j are different programs.
>>>>>
>>>>> I am aware that you are considering only halting and divergence -- the
>>>>> =/= between C_i(n) =/= C_j(n) means they have (in general) different
>>>>> halting behaviour.
>>>>
>>>> A(n,m) is a function. C_k(n) calls A(n,n).
>>>
>>> Yes. The question is how can this make sense? Writing
>>>
>>> C_k(n) { A(n,n) }
>>>
>>> suggests that every computation is identical. That can't be what you
>>> mean.
>>
>> That IS what I mean, i.e. for all n, C_k(n) = A(n,n).
>
> I don't know what to say. There is no sane model of computation in
> which all programs are the same.
>

He does make sense to bring up the Liar Paradox.

--
Copyright 2022 Pete Olcott

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

Ben wrote:
> Newberry <newberryxy@gmail.com> writes:
>
>> Ben wrote:
>>> Newberry <newberryxy@gmail.com> writes:
>>>
>>>> Ben wrote:
>>>>> Newberry <newberryxy@gmail.com> writes:
>>>>>
>>>>>> Here is the latest version of my paper "Getting Around the Halting Problem." It is much more concise than the previous versions.
>>>>>>
>>>>>> https://www.researchgate.net/publication/316562253_Getting_around_the_Halting_Problem
>>>>>>
>>>>>> Comments appreciated.
>>>>>
>>>>> There is something very odd about your notation, and/or the explanation
>>>>> is lacking.
>>>>>
>>>>> The C_k are some enumeration of the programs in some model of
>>>>> computation. You then define C_k(n) =def A(n,n). And you write it in
>>>>> code as well:
>>>>>
>>>>> C_k(n) { A(n,n) }
>>>>>
>>>>> How can this be? In general, when i =/= j, C_i(n) =/= C_j(n) because
>>>>> C_i and C_j are different programs.
>>>>>
>>>>> I am aware that you are considering only halting and divergence -- the
>>>>> =/= between C_i(n) =/= C_j(n) means they have (in general) different
>>>>> halting behaviour.
>>>>
>>>> A(n,m) is a function. C_k(n) calls A(n,n).
>>>
>>> Yes. The question is how can this make sense? Writing
>>>
>>> C_k(n) { A(n,n) }
>>>
>>> suggests that every computation is identical. That can't be what you
>>> mean.
>>
>> That IS what I mean, i.e. for all n, C_k(n) = A(n,n).
>
> I don't know what to say. There is no sane model of computation in
> which all programs are the same.

C_k(n) and A(n,n) are TWO programs, not all programs.

olcott wrote:
> On 4/12/2022 7:22 PM, Ben wrote:
>> Newberry <newberryxy@gmail.com> writes:
>>
>>> Ben wrote:
>>>> Newberry <newberryxy@gmail.com> writes:
>>>>
>>>>> Ben wrote:
>>>>>> Newberry <newberryxy@gmail.com> writes:
>>>>>>
>>>>>>> Here is the latest version of my paper "Getting Around the
>>>>>>> Halting Problem." It is much more concise than the previous
>>>>>>> versions.
>>>>>>>
>>>>>>> https://www.researchgate.net/publication/316562253_Getting_around_the_Halting_Problem
>>>>>>>
>>>>>>>
>>>>>>> Comments appreciated.
>>>>>>
>>>>>> There is something very odd about your notation, and/or the
>>>>>> explanation
>>>>>> is lacking.
>>>>>>
>>>>>> The C_k are some enumeration of the programs in some model of
>>>>>> computation. You then define C_k(n) =def A(n,n). And you write
>>>>>> it in
>>>>>> code as well:
>>>>>>
>>>>>> C_k(n) { A(n,n) }
>>>>>>
>>>>>> How can this be? In general, when i =/= j, C_i(n) =/= C_j(n) because
>>>>>> C_i and C_j are different programs.
>>>>>>
>>>>>> I am aware that you are considering only halting and divergence --
>>>>>> the
>>>>>> =/= between C_i(n) =/= C_j(n) means they have (in general) different
>>>>>> halting behaviour.
>>>>>
>>>>> A(n,m) is a function. C_k(n) calls A(n,n).
>>>>
>>>> Yes. The question is how can this make sense? Writing
>>>>
>>>> C_k(n) { A(n,n) }
>>>>
>>>> suggests that every computation is identical. That can't be what you
>>>> mean.
>>>
>>> That IS what I mean, i.e. for all n, C_k(n) = A(n,n).
>>
>> I don't know what to say. There is no sane model of computation in
>> which all programs are the same.
>>
>
> He does make sense to bring up the Liar Paradox.

I am basically accepting Gaifman's solution of the paradox albeit with
some modifications.

On 4/12/2022 10:58 PM, Newberry wrote:
> olcott wrote:
>> On 4/12/2022 7:22 PM, Ben wrote:
>>> Newberry <newberryxy@gmail.com> writes:
>>>
>>>> Ben wrote:
>>>>> Newberry <newberryxy@gmail.com> writes:
>>>>>
>>>>>> Ben wrote:
>>>>>>> Newberry <newberryxy@gmail.com> writes:
>>>>>>>
>>>>>>>> Here is the latest version of my paper "Getting Around the
>>>>>>>> Halting Problem." It is much more concise than the previous
>>>>>>>> versions.
>>>>>>>>
>>>>>>>> https://www.researchgate.net/publication/316562253_Getting_around_the_Halting_Problem
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> Comments appreciated.
>>>>>>>
>>>>>>> There is something very odd about your notation, and/or the
>>>>>>> explanation
>>>>>>> is lacking.
>>>>>>>
>>>>>>> The C_k are some enumeration of the programs in some model of
>>>>>>> computation.  You then define C_k(n) =def A(n,n).  And you write
>>>>>>> it in
>>>>>>> code as well:
>>>>>>>
>>>>>>>     C_k(n) { A(n,n) }
>>>>>>>
>>>>>>> How can this be?  In general, when i =/= j, C_i(n) =/= C_j(n)
>>>>>>> because
>>>>>>> C_i and C_j are different programs.
>>>>>>>
>>>>>>> I am aware that you are considering only halting and divergence --
>>>>>>> the
>>>>>>> =/= between C_i(n) =/= C_j(n) means they have (in general) different
>>>>>>> halting behaviour.
>>>>>>
>>>>>> A(n,m) is a function. C_k(n) calls A(n,n).
>>>>>
>>>>> Yes.  The question is how can this make sense?  Writing
>>>>>
>>>>>     C_k(n) { A(n,n) }
>>>>>
>>>>> suggests that every computation is identical.  That can't be what you
>>>>> mean.
>>>>
>>>> That IS what I mean, i.e. for all n, C_k(n) = A(n,n).
>>>
>>> I don't know what to say.  There is no sane model of computation in
>>> which all programs are the same.
>>>
>>
>> He does make sense to bring up the Liar Paradox.
>
> I am basically accepting Gaifman's solution of the paradox albeit with
> some modifications.
>

We also agree on what this means:
G := ~∃x(Prf(x, ⌜G⌝)

Which would be rejected by Prolog because it fails the occurs check.
This means that the above has an infinitely recursive structure.
https://www.swi-prolog.org/pldoc/man?predicate=unify_with_occurs_check/2

Here is another example:
https://www.researchgate.net/publication/350789898_Prolog_detects_and_rejects_pathological_self_reference_in_the_Godel_sentence

--
Copyright 2022 Pete Olcott

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

Newberry <newberryxy@gmail.com> writes:

> Ben wrote:
>> Newberry <newberryxy@gmail.com> writes:
>>
>>> Ben wrote:
>>>> Newberry <newberryxy@gmail.com> writes:
>>>>
>>>>> Ben wrote:
>>>>>> Newberry <newberryxy@gmail.com> writes:
>>>>>>
>>>>>>> Here is the latest version of my paper "Getting Around the Halting Problem." It is much more concise than the previous versions.
>>>>>>>
>>>>>>> https://www.researchgate.net/publication/316562253_Getting_around_the_Halting_Problem
>>>>>>>
>>>>>>> Comments appreciated.
>>>>>>
>>>>>> There is something very odd about your notation, and/or the explanation
>>>>>> is lacking.
>>>>>>
>>>>>> The C_k are some enumeration of the programs in some model of
>>>>>> computation. You then define C_k(n) =def A(n,n). And you write it in
>>>>>> code as well:
>>>>>>
>>>>>> C_k(n) { A(n,n) }
>>>>>>
>>>>>> How can this be? In general, when i =/= j, C_i(n) =/= C_j(n) because
>>>>>> C_i and C_j are different programs.
>>>>>>
>>>>>> I am aware that you are considering only halting and divergence -- the
>>>>>> =/= between C_i(n) =/= C_j(n) means they have (in general) different
>>>>>> halting behaviour.
>>>>>
>>>>> A(n,m) is a function. C_k(n) calls A(n,n).
>>>>
>>>> Yes. The question is how can this make sense? Writing
>>>>
>>>> C_k(n) { A(n,n) }
>>>>
>>>> suggests that every computation is identical. That can't be what you
>>>> mean.
>>>
>>> That IS what I mean, i.e. for all n, C_k(n) = A(n,n).
>>
>> I don't know what to say. There is no sane model of computation in
>> which all programs are the same.
>
> C_k(n) and A(n,n) are TWO programs, not all programs.

When I said "C_k(n) { A(n,n) } suggests that every computation is
identical. That can't be what you mean" you replied was "That IS what I
mean".

Anyway, I don't think you are writing for people like me. I wish you
well.

--
Ben.

On 4/13/22 12:07 AM, olcott wrote:
> On 4/12/2022 10:58 PM, Newberry wrote:
>> olcott wrote:
>>> On 4/12/2022 7:22 PM, Ben wrote:
>>>> Newberry <newberryxy@gmail.com> writes:
>>>>
>>>>> Ben wrote:
>>>>>> Newberry <newberryxy@gmail.com> writes:
>>>>>>
>>>>>>> Ben wrote:
>>>>>>>> Newberry <newberryxy@gmail.com> writes:
>>>>>>>>
>>>>>>>>> Here is the latest version of my paper "Getting Around the
>>>>>>>>> Halting Problem." It is much more concise than the previous
>>>>>>>>> versions.
>>>>>>>>>
>>>>>>>>> https://www.researchgate.net/publication/316562253_Getting_around_the_Halting_Problem
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Comments appreciated.
>>>>>>>>
>>>>>>>> There is something very odd about your notation, and/or the
>>>>>>>> explanation
>>>>>>>> is lacking.
>>>>>>>>
>>>>>>>> The C_k are some enumeration of the programs in some model of
>>>>>>>> computation.  You then define C_k(n) =def A(n,n).  And you write
>>>>>>>> it in
>>>>>>>> code as well:
>>>>>>>>
>>>>>>>>     C_k(n) { A(n,n) }
>>>>>>>>
>>>>>>>> How can this be?  In general, when i =/= j, C_i(n) =/= C_j(n)
>>>>>>>> because
>>>>>>>> C_i and C_j are different programs.
>>>>>>>>
>>>>>>>> I am aware that you are considering only halting and divergence --
>>>>>>>> the
>>>>>>>> =/= between C_i(n) =/= C_j(n) means they have (in general)
>>>>>>>> different
>>>>>>>> halting behaviour.
>>>>>>>
>>>>>>> A(n,m) is a function. C_k(n) calls A(n,n).
>>>>>>
>>>>>> Yes.  The question is how can this make sense?  Writing
>>>>>>
>>>>>>     C_k(n) { A(n,n) }
>>>>>>
>>>>>> suggests that every computation is identical.  That can't be what you
>>>>>> mean.
>>>>>
>>>>> That IS what I mean, i.e. for all n, C_k(n) = A(n,n).
>>>>
>>>> I don't know what to say.  There is no sane model of computation in
>>>> which all programs are the same.
>>>>
>>>
>>> He does make sense to bring up the Liar Paradox.
>>
>> I am basically accepting Gaifman's solution of the paradox albeit with
>> some modifications.
>>
>
> We also agree on what this means:
> G := ~∃x(Prf(x, ⌜G⌝)
>
> Which would be rejected by Prolog because it fails the occurs check.
> This means that the above has an infinitely recursive structure.
> https://www.swi-prolog.org/pldoc/man?predicate=unify_with_occurs_check/2
>
> Here is another example:
> https://www.researchgate.net/publication/350789898_Prolog_detects_and_rejects_pathological_self_reference_in_the_Godel_sentence
>
>

Which just shows that we aren't woring in a First-Order Logic, which we
knew. So your 'proof' means nothing.

Sorry charlie, you are just proving you don't know what you are talking
about and have just proved your over your head.

FAIL.