Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.lang.c > #159093 > unrolled thread
| Started by | olcott <NoOne@NoWhere.com> |
|---|---|
| First post | 2021-02-26 13:53 -0600 |
| Last post | 2021-03-09 19:42 -0600 |
| Articles | 20 on this page of 51 — 11 participants |
Back to article view | Back to comp.lang.c
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 →
| From | om@iki.fi (Otto J. Makela) |
|---|---|
| Date | 2021-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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-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]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-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]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-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]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-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]
| From | Keith Thompson <Keith.S.Thompson+u@gmail.com> |
|---|---|
| Date | 2021-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]
| From | gazelle@shell.xmission.com (Kenny McCormack) |
|---|---|
| Date | 2021-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]
| From | Siri Cruise <chine.bleu@yahoo.com> |
|---|---|
| Date | 2021-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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-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]
| From | Siri Cruise <chine.bleu@yahoo.com> |
|---|---|
| Date | 2021-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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-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]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-02 15:08 -0600 |
| Subject | Re: 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]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-03-02 17:33 -0500 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-02 17:18 -0600 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-02 18:45 -0600 |
| Subject | Re: 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