Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]


Groups > comp.lang.c > #159093 > unrolled thread

Detecting infinite recursion

Started byolcott <NoOne@NoWhere.com>
First post2021-02-26 13:53 -0600
Last post2021-03-09 19:42 -0600
Articles 20 on this page of 51 — 11 participants

Back to article view | Back to comp.lang.c


Contents

  Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-02-26 13:53 -0600
    Re: Detecting infinite recursion Siri Cruise <chine.bleu@yahoo.com> - 2021-02-26 12:48 -0800
    Re: Detecting infinite recursion Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-02-26 21:37 +0000
      Re: Detecting infinite recursion Siri Cruise <chine.bleu@yahoo.com> - 2021-02-26 15:26 -0800
    Re: Detecting infinite recursion Kaz Kylheku <563-365-8930@kylheku.com> - 2021-02-27 01:58 +0000
    Re: Detecting infinite recursion Jeff Barnett <jbb@notatt.com> - 2021-02-26 21:32 -0700
    Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-02-28 13:08 -0600
      Re: Detecting infinite recursion (H_Hat is proved to be decidable) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-01 03:52 +0000
        Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-02-28 22:19 -0600
          Re: Detecting infinite recursion (H_Hat is proved to be decidable) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-01 02:06 -0800
            Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-01 08:24 -0600
              Re: Detecting infinite recursion (H_Hat is proved to be decidable) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-01 17:06 +0000
                Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-01 11:47 -0600
          Re: Detecting infinite recursion (H_Hat is proved to be decidable) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-03-01 13:10 +0000
            Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-01 08:30 -0600
          Re: Detecting infinite recursion (H_Hat is proved to be decidable) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-01 16:52 +0000
            Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-01 11:26 -0600
            Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-01 11:30 -0600
              Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-01 21:32 -0600
              Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-02 09:29 -0600
    Re: Detecting infinite recursion om@iki.fi (Otto J. Makela) - 2021-03-02 18:36 +0200
      Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-02 11:22 -0600
        Re: Detecting infinite recursion Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-02 17:46 +0000
          Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-02 13:00 -0600
            Re: Detecting infinite recursion Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-02 19:35 +0000
              Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-02 14:02 -0600
            Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-02 13:50 -0600
              Re: Detecting infinite recursion Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-02 19:57 +0000
                Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-02 14:20 -0600
                Re: Detecting infinite recursion Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2021-03-02 12:57 -0800
                  Re: Detecting infinite recursion gazelle@shell.xmission.com (Kenny McCormack) - 2021-03-03 02:17 +0000
        Re: Detecting infinite recursion Siri Cruise <chine.bleu@yahoo.com> - 2021-03-02 11:45 -0800
          Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-02 13:52 -0600
            Re: Detecting infinite recursion Siri Cruise <chine.bleu@yahoo.com> - 2021-03-02 12:04 -0800
              Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-02 14:49 -0600
            Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-03-02 15:52 -0500
              Re: Detecting infinite recursion is simple olcott <NoOne@NoWhere.com> - 2021-03-02 15:08 -0600
                Re: Detecting infinite recursion is simple Richard Damon <Richard@Damon-Family.org> - 2021-03-02 17:33 -0500
                  Re: Detecting infinite recursion is simple olcott <NoOne@NoWhere.com> - 2021-03-02 17:18 -0600
            Re: Detecting infinite recursion (credit where it is due) olcott <NoOne@NoWhere.com> - 2021-03-02 18:45 -0600
      Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-03 12:52 -0600
      Re: Detecting infinite recursion (rewritten) olcott <NoOne@NoWhere.com> - 2021-03-03 17:06 -0600
    Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-03 12:55 -0600
    Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-03 15:50 -0600
    Re: Detecting infinite recursion Bonita Montero <Bonita.Montero@gmail.com> - 2021-03-04 13:09 +0100
    Re: Detecting infinite recursion (pathological self-reference error) olcott <NoOne@NoWhere.com> - 2021-03-06 09:58 -0600
    Re: Detecting infinite recursion Bonita Montero <Bonita.Montero@gmail.com> - 2021-03-07 16:38 +0100
      Re: Detecting infinite recursion (halting problem) olcott <NoOne@NoWhere.com> - 2021-03-07 09:55 -0600
    Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 10:26 -0600
      Re: Refuting the halting problem proofs with fully operational code (pathological self-reference error) olcott <NoOne@NoWhere.com> - 2021-03-09 11:54 -0600
    Re: Detecting infinite recursion (2021-03-09) olcott <NoOne@NoWhere.com> - 2021-03-09 19:42 -0600

Page 2 of 3 — ← Prev page 1 [2] 3  Next page →


#159124

Fromom@iki.fi (Otto J. Makela)
Date2021-03-02 18:36 +0200
Message-ID<87czwhfr6s.fsf@tigger.extechop.net>
In reply to#159093
I'm a bit late to the discussion, but this sounds a lot like you're
trying to overturn Turing's proof that that a general algorithm to solve
the halting problem for all possible program-input pairs cannot exist.
-- 
   /* * * Otto J. Makela <om@iki.fi> * * * * * * * * * */
  /* Phone: +358 40 765 5772, ICBM: N 60 10' E 24 55' */
 /* Mail: Mechelininkatu 26 B 27,  FI-00100 Helsinki */
/* * * Computers Rule 01001111 01001011 * * * * * * */

[toc] | [prev] | [next] | [standalone]


#159126

Fromolcott <NoOne@NoWhere.com>
Date2021-03-02 11:22 -0600
Message-ID<uLSdnZF1Hv7L6aP9nZ2dnUU7-e3NnZ2d@giganews.com>
In reply to#159124
On 3/2/2021 10:36 AM, Otto J. Makela wrote:
> I'm a bit late to the discussion, but this sounds a lot like you're
> trying to overturn Turing's proof that that a general algorithm to solve
> the halting problem for all possible program-input pairs cannot exist.
> 

Yes. The key brand new insight that I had about this proof is that the 
actual execution trace never reaches the undecidable portion, thus 
making the conventional halting problem counter-examples {Linz, Sipser, 
Kozen} decidable.

// P has the machine address of H_Hat()
void H_Hat(u32 P)
{
   u32 Input_Halts = Halts(P, P);
   if (Input_Halts)
     HERE: goto HERE;
   return;
}

    "It looks like the original specification provided in
     the Linz text may be infinitely recursive in that each
     TM requires its own input."

Self Modifying Turing Machine (SMTM) Solution to the Halting Problem 
(concrete example) August 2016
https://www.researchgate.net/publication/307509556_Self_Modifying_Turing_Machine_SMTM_Solution_to_the_Halting_Problem_concrete_example 


Infinitely Recursive input on HP Proofs (March 11, 2017)
https://groups.google.com/g/comp.theory/c/NcFS02hKs1U/m/PlBF-1LRBAAJ



Linz, Peter 1990. An Introduction to Formal Languages and Automata. 
Lexington/Toronto: D. C. Heath and Company (315-320)

Sipser, Michael 1997. Introduction to the Theory of Computation. Boston: 
PWS Publishing Company (165-167)

Kozen, Dexter 1997. Automata and Computability. New York: 
Springer-Verlag. (231-234).


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#159127

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-03-02 17:46 +0000
Message-ID<20210302093944.475@kylheku.com>
In reply to#159126
On 2021-03-02, olcott <NoOne@NoWhere.com> wrote:
> On 3/2/2021 10:36 AM, Otto J. Makela wrote:
>> I'm a bit late to the discussion, but this sounds a lot like you're
>> trying to overturn Turing's proof that that a general algorithm to solve
>> the halting problem for all possible program-input pairs cannot exist.
>> 
>
> Yes. The key brand new insight that I had about this proof is that the 
> actual execution trace never reaches the undecidable portion, thus 

The program has no "undecidable portion". We know perfectly well
whether it terminates or not, because it is trivial.

All that is undecidable, in the context of computability, is the problem
of determining whether any program whatsoever on any input terminates.

"Undecidable

> making the conventional halting problem counter-examples {Linz, Sipser, 
> Kozen} decidable.

Each such example is individually decidable, and everybody knows this.

No example of anything even moderately hard to decide is ever presented
in the proofs.

> // P has the machine address of H_Hat()
> void H_Hat(u32 P)
> {
>    u32 Input_Halts = Halts(P, P);
>    if (Input_Halts)
>      HERE: goto HERE;
>    return;
> }

Everyone, including probably most CS undergrads by the time they reach
senior year, that if Halts decides that it's a good idea to "decide"
halting by simply running the code, runaway recursion will occur.

When I first encountered the halting problem concept, I remember that
the text I was reading mentioned this: if the decision function jus
executes the function, it precipitates into infinite regress, and
therefore does not terminate, in which case there is no decision.

You have not discovered anything.

Also, the idea of an insruction stream that has no branches corresponds
to the well-known concept of a basic block in program control flow
analysis, used in compilers. Again, something even CS undergrads know by
the time they graduate.

-- 
TXR Programming Language: http://nongnu.org/txr
Cygna: Cygwin Native Application Library: http://kylheku.com/cygnal

[toc] | [prev] | [next] | [standalone]


#159128

Fromolcott <NoOne@NoWhere.com>
Date2021-03-02 13:00 -0600
Message-ID<ErKdnaAPipewFqP9nZ2dnUU7-YfNnZ2d@giganews.com>
In reply to#159127
On 3/2/2021 11:46 AM, Kaz Kylheku wrote:
> On 2021-03-02, olcott <NoOne@NoWhere.com> wrote:
>> On 3/2/2021 10:36 AM, Otto J. Makela wrote:
>>> I'm a bit late to the discussion, but this sounds a lot like you're
>>> trying to overturn Turing's proof that that a general algorithm to solve
>>> the halting problem for all possible program-input pairs cannot exist.
>>>
>>
>> Yes. The key brand new insight that I had about this proof is that the
>> actual execution trace never reaches the undecidable portion, thus
> 
> The program has no "undecidable portion". We know perfectly well
> whether it terminates or not, because it is trivial.
> 

Daryl McCullough
https://groups.google.com/g/comp.theory/c/wgJjJR78FaU/m/_eWPqsSS8bEJ
I can finally give credit where credit is due. Daryl McCullough was the 
one that originally came up with this analogy in March of 2012.

When we ask Bill: Is your answer to this question "no" ?
Bill cannot possibly provide a correct answer because both answers of 
"yes" and "no" form a contradiction.

In this same way Halts() cannot possibly provide a correct return value 
indicating halting / non halting to H_Hat().

// P has the machine address of H_Hat()
void H_Hat(u32 P)
{
   u32 Input_Halts = Halts2(P, P);
   if (Input_Halts)
     HERE: goto HERE;
   return;
}

The brand new insight that I documented that I came up with in 2016 was 
that a halt decider that examines the simulation of its input as the 
basis for its halting decision would never reach the point where it 
returns any value to H_Hat().


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#159129

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-03-02 19:35 +0000
Message-ID<20210302111744.595@kylheku.com>
In reply to#159128
["Followup-To:" header set to comp.lang.c.]
On 2021-03-02, olcott <NoOne@NoWhere.com> wrote:
> On 3/2/2021 11:46 AM, Kaz Kylheku wrote:
>> On 2021-03-02, olcott <NoOne@NoWhere.com> wrote:
>>> On 3/2/2021 10:36 AM, Otto J. Makela wrote:
>>>> I'm a bit late to the discussion, but this sounds a lot like you're
>>>> trying to overturn Turing's proof that that a general algorithm to solve
>>>> the halting problem for all possible program-input pairs cannot exist.
>>>>
>>>
>>> Yes. The key brand new insight that I had about this proof is that the
>>> actual execution trace never reaches the undecidable portion, thus
>> 
>> The program has no "undecidable portion". We know perfectly well
>> whether it terminates or not, because it is trivial.
>> 
>
> Daryl McCullough
> https://groups.google.com/g/comp.theory/c/wgJjJR78FaU/m/_eWPqsSS8bEJ
> I can finally give credit where credit is due. Daryl McCullough was the 
> one that originally came up with this analogy in March of 2012.
>
> When we ask Bill: Is your answer to this question "no" ?
> Bill cannot possibly provide a correct answer because both answers of 
> "yes" and "no" form a contradiction.

Since we are not part of the program, there is no contradiction in our
answer when we decide whether the example terminates or not.

If the example terminates and gives a result, that result may have
the interpretation that it is wrong; i.e. a contradiction.

If the program's is taken to mean "I do not halt", than that is wrong;
That has no bearing on the fact that the program has halted, and
that our own answer "it has halted" is right.

The decider is only shown wrong on that one example, not that it's
on all inputs. The decider is not absolutely contradicted.

> The brand new insight that I documented that I came up with in 2016 was 
> that a halt decider that examines the simulation of its input as the 
> basis for its halting decision would never reach the point where it 
> returns any value to H_Hat().

This is undergrad-level obvious that if the decider, instead of
implementing some actual decision algorithm, simply executes the input,
then if that input does not terminate, that "decision" will also not
terminate, and that it is victim to infinite regress.

The first time I learned about the halting problem, it was in a textbook
which noted this obvious fact.

You should be more humble in your claims that you have some brand new
result.

-- 
TXR Programming Language: http://nongnu.org/txr
Cygna: Cygwin Native Application Library: http://kylheku.com/cygnal

[toc] | [prev] | [next] | [standalone]


#159134

Fromolcott <NoOne@NoWhere.com>
Date2021-03-02 14:02 -0600
Message-ID<2I6dnQvHMtkqBKP9nZ2dnUU7-QvNnZ2d@giganews.com>
In reply to#159129
On 3/2/2021 1:35 PM, Kaz Kylheku wrote:
> ["Followup-To:" header set to comp.lang.c.]
> On 2021-03-02, olcott <NoOne@NoWhere.com> wrote:
>> On 3/2/2021 11:46 AM, Kaz Kylheku wrote:
>>> On 2021-03-02, olcott <NoOne@NoWhere.com> wrote:
>>>> On 3/2/2021 10:36 AM, Otto J. Makela wrote:
>>>>> I'm a bit late to the discussion, but this sounds a lot like you're
>>>>> trying to overturn Turing's proof that that a general algorithm to solve
>>>>> the halting problem for all possible program-input pairs cannot exist.
>>>>>
>>>>
>>>> Yes. The key brand new insight that I had about this proof is that the
>>>> actual execution trace never reaches the undecidable portion, thus
>>>
>>> The program has no "undecidable portion". We know perfectly well
>>> whether it terminates or not, because it is trivial.
>>>
>>
>> Daryl McCullough
>> https://groups.google.com/g/comp.theory/c/wgJjJR78FaU/m/_eWPqsSS8bEJ
>> I can finally give credit where credit is due. Daryl McCullough was the
>> one that originally came up with this analogy in March of 2012.
>>
>> When we ask Bill: Is your answer to this question "no" ?
>> Bill cannot possibly provide a correct answer because both answers of
>> "yes" and "no" form a contradiction.
> 
> Since we are not part of the program, there is no contradiction in our
> answer when we decide whether the example terminates or not.
> 
> If the example terminates and gives a result, that result may have
> the interpretation that it is wrong; i.e. a contradiction.
> 

Every halt decider that bases it halting decision on examining its own 
simulation of an input never reaches the point in its execution trace 
were it returns a value to H_Hat().

Now that its answer is not contradicted it can provide the correct answer.


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#159131

Fromolcott <NoOne@NoWhere.com>
Date2021-03-02 13:50 -0600
Message-ID<POednXfS7IB4C6P9nZ2dnUU78IfNnZ2d@giganews.com>
In reply to#159128
On 3/2/2021 1:00 PM, olcott wrote:
> On 3/2/2021 11:46 AM, Kaz Kylheku wrote:
>> On 2021-03-02, olcott <NoOne@NoWhere.com> wrote:
>>> On 3/2/2021 10:36 AM, Otto J. Makela wrote:
>>>> I'm a bit late to the discussion, but this sounds a lot like you're
>>>> trying to overturn Turing's proof that that a general algorithm to 
>>>> solve
>>>> the halting problem for all possible program-input pairs cannot exist.
>>>>
>>>
>>> Yes. The key brand new insight that I had about this proof is that the
>>> actual execution trace never reaches the undecidable portion, thus
>>
>> The program has no "undecidable portion". We know perfectly well
>> whether it terminates or not, because it is trivial.
>>

There is a much earlier attribution to the same person:

sci.logic   Daryl McCullough  June 25, 2004
On Friday, June 25, 2004 at 6:30:39 PM UTC-5, Daryl McCullough wrote:
 > You ask someone (we'll call him "Jack") to give a truthful
 > yes/no answer to the following question:
 > Will Jack's answer to this question be no?
 > Jack can't possibly give a correct yes/no answer to the question.

https://groups.google.com/g/sci.logic/c/4kIXI1kxmsI/m/hRroMoQZx2IJ

Jack cannot possibly provide a correct answer because both answers of 
"yes" and "no" form a contradiction.

> In this same way Halts() cannot possibly provide a correct return value 
> indicating halting / non halting to H_Hat().
> 
> // P has the machine address of H_Hat()
> void H_Hat(u32 P)
> {
>    u32 Input_Halts = Halts2(P, P);
>    if (Input_Halts)
>      HERE: goto HERE;
>    return;
> }
> 
> The brand new insight that I documented that I came up with in 2016 was 
> that a halt decider that examines the simulation of its input as the 
> basis for its halting decision would never reach the point where it 
> returns any value to H_Hat().
> 
> 


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#159133

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-03-02 19:57 +0000
Message-ID<20210302115219.467@kylheku.com>
In reply to#159131
On 2021-03-02, olcott <NoOne@NoWhere.com> wrote:
> On 3/2/2021 1:00 PM, olcott wrote:
>> On 3/2/2021 11:46 AM, Kaz Kylheku wrote:
>>> On 2021-03-02, olcott <NoOne@NoWhere.com> wrote:
>>>> On 3/2/2021 10:36 AM, Otto J. Makela wrote:
>>>>> I'm a bit late to the discussion, but this sounds a lot like you're
>>>>> trying to overturn Turing's proof that that a general algorithm to 
>>>>> solve
>>>>> the halting problem for all possible program-input pairs cannot exist.
>>>>>
>>>>
>>>> Yes. The key brand new insight that I had about this proof is that the
>>>> actual execution trace never reaches the undecidable portion, thus
>>>
>>> The program has no "undecidable portion". We know perfectly well
>>> whether it terminates or not, because it is trivial.
>>>
>
> There is a much earlier attribution to the same person:
>
> sci.logic   Daryl McCullough  June 25, 2004
> On Friday, June 25, 2004 at 6:30:39 PM UTC-5, Daryl McCullough wrote:
> > You ask someone (we'll call him "Jack") to give a truthful
> > yes/no answer to the following question:
> > Will Jack's answer to this question be no?
> > Jack can't possibly give a correct yes/no answer to the question.
>
> https://groups.google.com/g/sci.logic/c/4kIXI1kxmsI/m/hRroMoQZx2IJ
>
> Jack cannot possibly provide a correct answer because both answers of 
> "yes" and "no" form a contradiction.

What you're perpetually missing is that a mathematical or
computatational function isn't Jack. If it gives a "yes" answer for some
input, it can give no other answer. Functions don't have the choice of
re-evaluating their answer and changing it.

Much of your rhetoric in this direction is laced with
anthropomorphic fallacy.

If we edit a function to give a different answer for the same input,
we are creating a different function. Since the input is the function
itself, the input has changed too!

You continue to be confused by this point; your work history consists
of producing different versions of code under the same names, taking
different inputs under the same name, and speaking about it in terms as
if they are all one thing.

[toc] | [prev] | [next] | [standalone]


#159136

Fromolcott <NoOne@NoWhere.com>
Date2021-03-02 14:20 -0600
Message-ID<iK2dndfzIPBlAKP9nZ2dnUU7-WfNnZ2d@giganews.com>
In reply to#159133
On 3/2/2021 1:57 PM, Kaz Kylheku wrote:
> On 2021-03-02, olcott <NoOne@NoWhere.com> wrote:
>> On 3/2/2021 1:00 PM, olcott wrote:
>>> On 3/2/2021 11:46 AM, Kaz Kylheku wrote:
>>>> On 2021-03-02, olcott <NoOne@NoWhere.com> wrote:
>>>>> On 3/2/2021 10:36 AM, Otto J. Makela wrote:
>>>>>> I'm a bit late to the discussion, but this sounds a lot like you're
>>>>>> trying to overturn Turing's proof that that a general algorithm to
>>>>>> solve
>>>>>> the halting problem for all possible program-input pairs cannot exist.
>>>>>>
>>>>>
>>>>> Yes. The key brand new insight that I had about this proof is that the
>>>>> actual execution trace never reaches the undecidable portion, thus
>>>>
>>>> The program has no "undecidable portion". We know perfectly well
>>>> whether it terminates or not, because it is trivial.
>>>>
>>
>> There is a much earlier attribution to the same person:
>>
>> sci.logic   Daryl McCullough  June 25, 2004
>> On Friday, June 25, 2004 at 6:30:39 PM UTC-5, Daryl McCullough wrote:
>>> You ask someone (we'll call him "Jack") to give a truthful
>>> yes/no answer to the following question:
>>> Will Jack's answer to this question be no?
>>> Jack can't possibly give a correct yes/no answer to the question.
>>
>> https://groups.google.com/g/sci.logic/c/4kIXI1kxmsI/m/hRroMoQZx2IJ
>>
>> Jack cannot possibly provide a correct answer because both answers of
>> "yes" and "no" form a contradiction.
> 
> What you're perpetually missing is that a mathematical or
> computatational function isn't Jack. If it gives a "yes" answer for some
> input, it can give no other answer. Functions don't have the choice of
> re-evaluating their answer and changing it.
> 
> Much of your rhetoric in this direction is laced with
> anthropomorphic fallacy.
> 
> If we edit a function to give a different answer for the same input,
> we are creating a different function. Since the input is the function
> itself, the input has changed too!
> 
> You continue to be confused by this point; your work history consists
> of producing different versions of code under the same names, taking
> different inputs under the same name, and speaking about it in terms as
> if they are all one thing.
> 

// P has the machine address of H_Hat()
void H_Hat(u32 P)
{
   u32 Input_Halts = Halts(P, P);
   if (Input_Halts)
     HERE: goto HERE;
   return;
}

Although you may endlessly dodge this point it remains perfectly true 
that both possible Boolean return values from Halts() to H_Hat() would 
be made incorrect on the basis that they are contradicted.

It is also a verified fact that these return values are contradicted in 
the exact same pathological self-reference(Olcott 2004) way that makes 
it impossible for Jack to provide a correct answer to this question:
Is the answer to this question no?





-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#159139

FromKeith Thompson <Keith.S.Thompson+u@gmail.com>
Date2021-03-02 12:57 -0800
Message-ID<874khtjmtv.fsf@nosuchdomain.example.com>
In reply to#159133
Kaz Kylheku <563-365-8930@kylheku.com> writes:
> On 2021-03-02, olcott <NoOne@NoWhere.com> wrote:
[more of the same]

Kaz, olcott's article to which you replied was posted to
comp.theory, comp.lang.c, comp.lang.c++, and comp.software-eng,
with followups directed to comp.lang.c.  Your followup ignored the
"Followup-To: comp.theory" header line and cross-posted to all
four newsgroups.

Is your newsreader buggy, or are you deliberately making
inappropriate cross-posts, or is something else going on?

I've cross-posted this article and set followups to comp.theory only.

-- 
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Working, but not speaking, for Philips Healthcare
void Void(void) { Void(); } /* The recursive call of the void */

[toc] | [prev] | [next] | [standalone]


#159144

Fromgazelle@shell.xmission.com (Kenny McCormack)
Date2021-03-03 02:17 +0000
Message-ID<s1mrki$3dqs5$1@news.xmission.com>
In reply to#159139
In article <874khtjmtv.fsf@nosuchdomain.example.com>,
Keith Thompson  <Keith.S.Thompson+u@gmail.com> wrote:
>Kaz Kylheku <563-365-8930@kylheku.com> writes:
>> On 2021-03-02, olcott <NoOne@NoWhere.com> wrote:
>[more of the same]
>
>Kaz, olcott's article to which you replied was posted to
>comp.theory, comp.lang.c, comp.lang.c++, and comp.software-eng,
>with followups directed to comp.lang.c.  Your followup ignored the
>"Followup-To: comp.theory" header line and cross-posted to all
>four newsgroups.
>
>Is your newsreader buggy, or are you deliberately making
>inappropriate cross-posts, or is something else going on?
>
>I've cross-posted this article and set followups to comp.theory only.

Wow.  I'm so impressed.

-- 
People who want to share their religious views with you
almost never want you to share yours with them. -- Dave Barry

[toc] | [prev] | [next] | [standalone]


#159130

FromSiri Cruise <chine.bleu@yahoo.com>
Date2021-03-02 11:45 -0800
Message-ID<chine.bleu-63DDA9.11450102032021@reader.eternal-september.org>
In reply to#159126
In article <uLSdnZF1Hv7L6aP9nZ2dnUU7-e3NnZ2d@giganews.com>,
 olcott <NoOne@NoWhere.com> wrote:

> Yes. The key brand new insight that I had about this proof is that the 

It's easy to express some number theory conjectures as recursive 
procedures that either never halt if the conjecture is true or do 
halt (on a counterexample) if the conjecture is false. If you 
really can solve the halting problem, then solve these and be 
famous for solving all number theory conjectures and 
simultaneously proving number theory is w-inconsistent.

-- 
:-<> 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 Doria sockpuppet.                  insults Islam.  Mohammed

[toc] | [prev] | [next] | [standalone]


#159132

Fromolcott <NoOne@NoWhere.com>
Date2021-03-02 13:52 -0600
Message-ID<POednXbS7IAYCqP9nZ2dnUU78IednZ2d@giganews.com>
In reply to#159130
On 3/2/2021 1:45 PM, Siri Cruise wrote:
> In article <uLSdnZF1Hv7L6aP9nZ2dnUU7-e3NnZ2d@giganews.com>,
>   olcott <NoOne@NoWhere.com> wrote:
> 
>> Yes. The key brand new insight that I had about this proof is that the
> 
> It's easy to express some number theory conjectures as recursive
> procedures that either never halt if the conjecture is true or do
> halt (on a counterexample) if the conjecture is false. If you
> really can solve the halting problem, then solve these and be
> famous for solving all number theory conjectures and
> simultaneously proving number theory is w-inconsistent.
> 

My background is computer science not mathematics, I will leave the math 
aspects of this as an exercise for the reader on the basis of the 
computer science solution that I have provided.

-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#159135

FromSiri Cruise <chine.bleu@yahoo.com>
Date2021-03-02 12:04 -0800
Message-ID<chine.bleu-A0CA42.12040602032021@reader.eternal-september.org>
In reply to#159132
In article <POednXbS7IAYCqP9nZ2dnUU78IednZ2d@giganews.com>,
 olcott <NoOne@NoWhere.com> wrote:

> On 3/2/2021 1:45 PM, Siri Cruise wrote:
> > In article <uLSdnZF1Hv7L6aP9nZ2dnUU7-e3NnZ2d@giganews.com>,
> >   olcott <NoOne@NoWhere.com> wrote:
> > 
> >> Yes. The key brand new insight that I had about this proof is that the
> > 
> > It's easy to express some number theory conjectures as recursive
> > procedures that either never halt if the conjecture is true or do
> > halt (on a counterexample) if the conjecture is false. If you
> > really can solve the halting problem, then solve these and be
> > famous for solving all number theory conjectures and
> > simultaneously proving number theory is w-inconsistent.
> > 
> 
> My background is computer science not mathematics, I will leave the math 
> aspects of this as an exercise for the reader on the basis of the 
> computer science solution that I have provided.

I've already provided goldbach's conjecture. Try that.

-- 
:-<> 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 Doria sockpuppet.                  insults Islam.  Mohammed

[toc] | [prev] | [next] | [standalone]


#159137

Fromolcott <NoOne@NoWhere.com>
Date2021-03-02 14:49 -0600
Message-ID<AomdnR4aouR2OaP9nZ2dnUU7-fHNnZ2d@giganews.com>
In reply to#159135
On 3/2/2021 2:04 PM, Siri Cruise wrote:
> In article <POednXbS7IAYCqP9nZ2dnUU78IednZ2d@giganews.com>,
>   olcott <NoOne@NoWhere.com> wrote:
> 
>> On 3/2/2021 1:45 PM, Siri Cruise wrote:
>>> In article <uLSdnZF1Hv7L6aP9nZ2dnUU7-e3NnZ2d@giganews.com>,
>>>    olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> Yes. The key brand new insight that I had about this proof is that the
>>>
>>> It's easy to express some number theory conjectures as recursive
>>> procedures that either never halt if the conjecture is true or do
>>> halt (on a counterexample) if the conjecture is false. If you
>>> really can solve the halting problem, then solve these and be
>>> famous for solving all number theory conjectures and
>>> simultaneously proving number theory is w-inconsistent.
>>>
>>
>> My background is computer science not mathematics, I will leave the math
>> aspects of this as an exercise for the reader on the basis of the
>> computer science solution that I have provided.
> 
> I've already provided goldbach's conjecture. Try that.
> 

I am not interested in that. On the other hand The Tarski Undefinability 
theorem / 1931 Gödel Incompleteness directly pertain to the fundamental 
nature of analytical truth itself. Progress in AI will remain stymied 
until we fix those errors.

There is no sense in me working on any of that until after my halting 
problem proof refutation has been accepted because in the case of 
Tarski/Gödel I cannot simply write little computer program that provides 
every single detail of the 100% of the entire solution.

-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#159138

FromRichard Damon <Richard@Damon-Family.org>
Date2021-03-02 15:52 -0500
Message-ID<xAx%H.23763$OY.10789@fx38.iad>
In reply to#159132
On 3/2/21 2:52 PM, olcott wrote:
> 
> My background is computer science not mathematics, I will leave the math
> aspects of this as an exercise for the reader on the basis of the
> computer science solution that I have provided.

And I think this is the root of the problem, you don't nearly have
enough understand of the basis of the Mathematics you are trying to work
on to make a credible argument.

[toc] | [prev] | [next] | [standalone]


#159140 — Re: Detecting infinite recursion is simple

Fromolcott <NoOne@NoWhere.com>
Date2021-03-02 15:08 -0600
SubjectRe: Detecting infinite recursion is simple
Message-ID<ocCdnRtCmfi0NKP9nZ2dnUU7-fXNnZ2d@giganews.com>
In reply to#159138
On 3/2/2021 2:52 PM, Richard Damon wrote:
> On 3/2/21 2:52 PM, olcott wrote:
>>
>> My background is computer science not mathematics, I will leave the math
>> aspects of this as an exercise for the reader on the basis of the
>> computer science solution that I have provided.
> 
> And I think this is the root of the problem, you don't nearly have
> enough understand of the basis of the Mathematics you are trying to work
> on to make a credible argument.
> 

int Halts(u32 P, u32 I)
{
   ((void(*)(int))P)(I);
   return 1;
}

void H_Hat(u32 P)
{
   u32 Input_Halts = Halts(P, P);
   if (Input_Halts)
     HERE: goto HERE;
   return;
}

int main()
{
   u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
   Output("Input_Would_Halt = ", Input_Would_Halt);
}

It is very obvious that H_Hat() invokes Halts() in infinite recursion.
If we augment Halts() so that it simulates the execution of the x86 
machine language of H_Hat(), H_Hat() continues to invoke Halts() in 
infinite recursion.

If we augment Halts() so that it keeps track of the details of its 
simulated execution of the x86 machine language of H_Hat(), and examines 
this execution trace immediately after simulating the execution of each 
instruction of H_Hat() then Halts() can determine that H_Hat() is 
invoking it in infinite recursion.

All of this can be understood and verified on the basis of software 
engineering.

-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#159141 — Re: Detecting infinite recursion is simple

FromRichard Damon <Richard@Damon-Family.org>
Date2021-03-02 17:33 -0500
SubjectRe: Detecting infinite recursion is simple
Message-ID<V2z%H.2545$V21.1036@fx45.iad>
In reply to#159140
On 3/2/21 4:08 PM, olcott wrote:
> On 3/2/2021 2:52 PM, Richard Damon wrote:
>> On 3/2/21 2:52 PM, olcott wrote:
>>>
>>> My background is computer science not mathematics, I will leave the math
>>> aspects of this as an exercise for the reader on the basis of the
>>> computer science solution that I have provided.
>>
>> And I think this is the root of the problem, you don't nearly have
>> enough understand of the basis of the Mathematics you are trying to work
>> on to make a credible argument.
>>
> 
> int Halts(u32 P, u32 I)
> {
>   ((void(*)(int))P)(I);
>   return 1;
> }
> 
> void H_Hat(u32 P)
> {
>   u32 Input_Halts = Halts(P, P);
>   if (Input_Halts)
>     HERE: goto HERE;
>   return;
> }
> 
> int main()
> {
>   u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
>   Output("Input_Would_Halt = ", Input_Would_Halt);
> }
> 
> It is very obvious that H_Hat() invokes Halts() in infinite recursion.
> If we augment Halts() so that it simulates the execution of the x86
> machine language of H_Hat(), H_Hat() continues to invoke Halts() in
> infinite recursion.
> 
> If we augment Halts() so that it keeps track of the details of its
> simulated execution of the x86 machine language of H_Hat(), and examines
> this execution trace immediately after simulating the execution of each
> instruction of H_Hat() then Halts() can determine that H_Hat() is
> invoking it in infinite recursion.
> 
> All of this can be understood and verified on the basis of software
> engineering.
> 

If Halts is JUST a simulator or direct call execution (and thus badly
named) the yes, the call to Halts is infinitly recursive and will not
return.

But, if Halts is define as a Halt Decider, so will always return an
answer in finite time, NO call to Halts can be infinte recursion, as
infinte recursion takes longer than the finite time allowed.

Remember, Halt Decision MUST be based on what the program will ACTUALLY
do when run, not some funky would have done if I didn't do something.

The fact that Halts will terminate the simulation means that H_Hat is
NOT infinity recursive.

Presumably as a Software Engineer, you understand writing programs based
on their Requirements Documents and API guarantees. If Halts is DEFINED
as to always terminate its simulation, and return an answer in finite
time, the H_Hat can safely call it and not be able to be blamed itself
for infinite execution. (It only will do that if Halts predicts it will
stop)

[toc] | [prev] | [next] | [standalone]


#159142 — Re: Detecting infinite recursion is simple

Fromolcott <NoOne@NoWhere.com>
Date2021-03-02 17:18 -0600
SubjectRe: Detecting infinite recursion is simple
Message-ID<456dnRA7arEAWqP9nZ2dnUU7-WvNnZ2d@giganews.com>
In reply to#159141
On 3/2/2021 4:33 PM, Richard Damon wrote:
> On 3/2/21 4:08 PM, olcott wrote:
>> On 3/2/2021 2:52 PM, Richard Damon wrote:
>>> On 3/2/21 2:52 PM, olcott wrote:
>>>>
>>>> My background is computer science not mathematics, I will leave the math
>>>> aspects of this as an exercise for the reader on the basis of the
>>>> computer science solution that I have provided.
>>>
>>> And I think this is the root of the problem, you don't nearly have
>>> enough understand of the basis of the Mathematics you are trying to work
>>> on to make a credible argument.
>>>
>>
>> int Halts(u32 P, u32 I)
>> {
>>    ((void(*)(int))P)(I);
>>    return 1;
>> }
>>
>> void H_Hat(u32 P)
>> {
>>    u32 Input_Halts = Halts(P, P);
>>    if (Input_Halts)
>>      HERE: goto HERE;
>>    return;
>> }
>>
>> int main()
>> {
>>    u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
>>    Output("Input_Would_Halt = ", Input_Would_Halt);
>> }
>>
>> It is very obvious that H_Hat() invokes Halts() in infinite recursion.
>> If we augment Halts() so that it simulates the execution of the x86
>> machine language of H_Hat(), H_Hat() continues to invoke Halts() in
>> infinite recursion.
>>
>> If we augment Halts() so that it keeps track of the details of its
>> simulated execution of the x86 machine language of H_Hat(), and examines
>> this execution trace immediately after simulating the execution of each
>> instruction of H_Hat() then Halts() can determine that H_Hat() is
>> invoking it in infinite recursion.
>>
>> All of this can be understood and verified on the basis of software
>> engineering.
>>
> 
> If Halts is JUST a simulator or direct call execution (and thus badly
> named) the yes, the call to Halts is infinitly recursive and will not
> return.
> 
> But, if Halts is define as a Halt Decider, so will always return an
> answer in finite time, NO call to Halts can be infinte recursion, as
> infinte recursion takes longer than the finite time allowed.
> 

We have not gotten to that state of elaboration yet. In the current 
stage of elaboration Halts() is a halt determiner and not a halt decider.

> Remember, Halt Decision MUST be based on what the program will ACTUALLY
> do when run, not some funky would have done if I didn't do something.
> 

Because of the paradoxical difficulties with these issues we analyze 
Halts() as a halt determiner at this point in the dialogue and not a 
halt decider. After it is understood that Halts() did correctly 
determine non-halting then and only then do we proceed.

> The fact that Halts will terminate the simulation means that H_Hat is
> NOT infinity recursive.
> 

Halts() does not terminate the simulation and thus correctly determines 
that it has been and continues to be invoked in infinite recursion.

> Presumably as a Software Engineer, you understand writing programs based
> on their Requirements Documents and API guarantees. If Halts is DEFINED
> as to always terminate its simulation, and return an answer in finite
> time, the H_Hat can safely call it and not be able to be blamed itself
> for infinite execution. (It only will do that if Halts predicts it will
> stop)
> 


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#159143 — Re: Detecting infinite recursion (credit where it is due)

Fromolcott <NoOne@NoWhere.com>
Date2021-03-02 18:45 -0600
SubjectRe: Detecting infinite recursion (credit where it is due)
Message-ID<qpudnYflr7K3QaP9nZ2dnUU7-enNnZ2d@giganews.com>
In reply to#159132
On 3/2/2021 6:20 PM, Richard Damon wrote:
> On 3/2/21 5:59 PM, olcott wrote:
>> On 3/2/2021 4:50 PM, Richard Damon wrote:
>>> On 3/2/21 5:24 PM, olcott wrote:
>>>> On 3/2/2021 3:07 PM, Richard Damon wrote:
>>>>> On 3/2/21 3:41 PM, olcott wrote:
>>>>>> On 3/2/2021 2:01 PM, Malcolm McLean wrote:
>>>>>>> On Tuesday, 2 March 2021 at 19:52:39 UTC, olcott wrote:
>>>>>>>> On 3/2/2021 1:45 PM, Siri Cruise wrote:
>>>>>>>>> In article <uLSdnZF1Hv7L6aP9...@giganews.com>,
>>>>>>>>> olcott <No...@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> Yes. The key brand new insight that I had about this proof is
>>>>>>>>>> that the
>>>>>>>>>
>>>>>>>>> It's easy to express some number theory conjectures as recursive
>>>>>>>>> procedures that either never halt if the conjecture is true or do
>>>>>>>>> halt (on a counterexample) if the conjecture is false. If you
>>>>>>>>> really can solve the halting problem, then solve these and be
>>>>>>>>> famous for solving all number theory conjectures and
>>>>>>>>> simultaneously proving number theory is w-inconsistent.
>>>>>>>>>
>>>>>>>> My background is computer science not mathematics, I will leave the
>>>>>>>> math
>>>>>>>> aspects of this as an exercise for the reader on the basis of the
>>>>>>>> computer science solution that I have provided.
>>>>>>>>
>>>>>>> All you really need to know is that, if you could write a halt
>>>>>>> decider, then
>>>>>>> many problems considered by mathematicians to be insoluble would
>>>>>>> suddenly become soluble. That tells you that it's likely that there
>>>>>>> are issues
>>>>>>> in writing a halt decider which are at least as hard to resolve as
>>>>>>> finding
>>>>>>> solutions to all these previously insoluble maths problems. Otherwise
>>>>>>> mathematicians really aren't such a smart bunch.
>>>>>>>
>>>>>>> That's an informal argument, not a proof.
>>>>>>>
>>>>>>
>>>>>> I have been working on this for thousands and thousands of hours since
>>>>>> 2004. This is best documented in my thousands and thousands of
>>>>>> posts to
>>>>>> comp.theory.
>>>>>>
>>>>>> My solution is so simple that it is very obviously totally correct.
>>>>>> It is obvious that the standard halting problem proof counter-example
>>>>>> would infinitely invoke the halt decider.
>>>>>>
>>>>>> When the halt decider has been augmented to be able to see this
>>>>>> then it
>>>>>> can correctly decide halting on the conventional HP proof
>>>>>> counter-examples.
>>>>>>
>>>>>>
>>>>>> int Halts(u32 P, u32 I)
>>>>>> {
>>>>>>      ((void(*)(int))P)(I);
>>>>>>      return 1;
>>>>>> }
>>>>>>
>>>>>> void H_Hat(u32 P)
>>>>>> {
>>>>>>      u32 Input_Halts = Halts(P, P);
>>>>>>      if (Input_Halts)
>>>>>>        HERE: goto HERE;
>>>>>>      return;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>      u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
>>>>>>      Output("Input_Would_Halt = ", Input_Would_Halt);
>>>>>> }
>>>>>>
>>>>>>
>>>>
>>>> What was that counter-example that you presented that showed there was
>>>> an exception to the rule that when there is a sequence of two function
>>>> calls to the same function from the same machine address and no
>>>> conditional branch instructions inbetween that it might possibly not be
>>>> infinite recursion? This exception made me have to start looking at
>>>> inputs to function call.
>>>>
>>>>
>>>
>>> Ultimately the issue is that if you allow the use of any data base
>>> program flow control, even if not what you were calling a 'conditional
>>> jump' you can get the effect of a conditional jump.
>>>
>>> Since your simulation routine is in effect, such a program flow
>>> instruction (even if you don't want to call it that, especially inside
>>> you 'OS Code') I was able to defeat your incorrect rule (incorrect as it
>>> doesn't restrict the conditions enough) by entering one program with
>>> different data so it could use that data to create differing program
>>> flow after the call that you were detecting as recursive without
>>> conditional (because there WAS a conditional execution in the loop).
>>>
>>> Your modified rule is basicly roughly the detection of a loop by seeing
>>> the program return to a previous state with ALL the state being the same
>>> (which holds even with conditionals in the path). At the simulate call,
>>> assuming that you do block access to global variable, the state that
>>> crosses is limited, so is easier to check.
>>>
>>> Note that since it appears that Halts does have some access to global
>>> data, that condition isn't fully satisfied, but it may be you are
>>> preventing that information from leaking out enough for your purposes.
>>>
>>
>> That is not the specific concrete example that you previously provided.
>> Since I remember that this caused me to build the infrastructure to make
>> sure that I examined inputs to a function your concrete example had
>> different inputs. Maybe it was something like the second input was a
>> value used by a switch statement.
>>
> 
> That is an exact decsription of what I did (A switch would have been a
> conditional).
> 
> It worked by passing different values of the data parameter that the
> function use as the program parameter, thus getting the Halt Decider
> function to perform the conditional execution instruction cloaked behind
> your false wall of separation.
> 

OK, great. That was an important critique. It caused me to focus on 
examining to input to functions as a key element of halt deciding.

Assuming that what Malcolm said also applies to indirect recursion:
On 2/26/2021 2:41 PM, Malcolm McLean wrote:
 > If A calls itself with exactly the same data as it was
 > originally invoked with, then it must be infinitely recursive,
 > even if there are conditional branches. It always takes the
 > same branches.

Then detecting infinite recursion is made even simpler.

Noticing that the H_Hat() invocation of Halts() is infinitely recursive 
for every halt decider that bases it halt deciding decision on examining 
its own simulation of its input overcame the "impossible" aspect of 
refuting the halting problem proofs. (Copyright Pete Olcott 2016, 2017).

The feedback that you and Malcolm provided was important to implementing 
this halt decider. You corrected a key short-coming with the initial 
halt decider design and Malcolm eliminated an unnecessary step.

void H_Hat(u32 P)
{
   u32 Input_Halts = Halts(P, P);
   if (Input_Halts)
     HERE: goto HERE;
   return;
}

int main()
{
   u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
   Output("Input_Would_Halt = ", Input_Would_Halt);
}

-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


Page 2 of 3 — ← Prev page 1 [2] 3  Next page →

Back to top | Article view | comp.lang.c


csiph-web