|
|
| (One intermediate revision by one other user not shown) |
| Line 1: |
Line 1: |
| {{lead too short|date=January 2013}}
| | Greetings! I'm Emilie though I don't really like being called like regarding. The job she has been occupying walkman from sony is a human being resources assistant and she might not put it back anytime briefly. For a while she's experienced Ohio and she or he loves every day living right. To do archery is something I won't ever give . You can find my website here: http://squalet.com/collections/best-sellers/products/squalet<br><br>Also visit my blog post :: [http://squalet.com/collections/best-sellers/products/squalet toilet step stool] |
| In [[computability theory]], '''Rice's theorem''' states that, for any non-trivial property of [[partial functions]], there is no general and effective method to [[decision problem|decide]] whether an [[algorithm]] computes a partial function with that property. Here, a property of partial functions is called ''trivial'' if it holds for all [[partial computable function]]s or for none, and an effective decision method is called ''general'' if it decides correctly for every algorithm.
| |
| The theorem is named after [[Henry Gordon Rice]], and is also known as the '''Rice-Myhill-Shapiro theorem''' after Rice, [[John Myhill]], and [[Norman Shapiro]]. | |
| | |
| ==Introduction==
| |
| Another way of stating Rice's theorem that is more useful in [[Computability theory (computer science)|computability theory]] follows.
| |
| | |
| Let ''S'' be a set of [[Formal language|languages]] that is nontrivial, meaning
| |
| # there exists a Turing machine that recognizes a language in ''S''
| |
| # there exists a Turing machine that recognizes a language not in ''S''
| |
| Then, it is [[decision problem|undecidable]] to determine whether the language decided by an arbitrary [[Turing machine]] lies in ''S''.
| |
| | |
| In practice, this means that there is no machine that can always decide whether the language of a given Turing machine has a particular nontrivial property. Special cases include the undecidability of whether a Turing machine accepts a particular string, whether a Turing machine recognizes a particular recognizable language, and whether the language recognized by a Turing machine could be recognized by a nontrivial simpler machine, such as a [[Finite state machine|finite automaton]].
| |
| | |
| It is important to note that Rice's theorem does not say anything about those properties of machines or programs that are not also properties of functions and languages. For example, whether a machine runs for more than 100 steps on some input is a decidable property, even though it is non-trivial. Implementing exactly the same language, two different machines might require a different number of steps to recognize the same input. Similarly, whether a machine has more than 5 states is a decidable property of the machine, as the number of states can simply be counted. Where a property is of the kind that either of the two machines may or may not have it, while still implementing exactly the same language, the property is of the machines and not of the language, and Rice's Theorem does not apply.
| |
| | |
| Using [[Hartley Rogers, Jr|Rogers]]' characterization of [[Roger's equivalence theorem|acceptable programming system]]s, Rice's Theorem may essentially be generalized from Turing machines to most computer [[programming language]]s: there exists no automatic method that decides with generality non-trivial questions on the behavior of computer programs.
| |
| | |
| As an example, consider the following variant of the [[halting problem]]. Let ''P'' be the following property of partial functions '''F''' of one argument: ''P''('''F''') means that '''F''' is defined for the argument '1'. It is obviously non-trivial, since there are partial functions that are defined at 1, and others that are undefined at 1. The ''1-halting problem'' is the problem of deciding of any algorithm whether it defines a function with this property,
| |
| i.e., whether the algorithm halts on input 1. By Rice's theorem, the 1-halting problem is undecidable. Similarly the question of whether a Turing machine ''T'' terminates on an initially empty tape (rather than with an initial word ''w'' given as second argument in addition to a description of ''T'', as in the full halting problem) is still undecidable.
| |
| | |
| ==Formal statement==
| |
| Let <math>\phi\colon \mathbb{N} \to \mathbf{P}^{(1)}</math> be a [[Gödel number]]ing of the [[computable function]]s; a map from the [[natural numbers]] to the class <math>\mathbf{P}^{(1)}</math> of unary (partial) computable functions.
| |
| Denote by <math>\phi_e:=\phi(e)</math> the {{math|<var>e</var>}}th (partial) computable function.
| |
| | |
| We identify each ''property'' that a computable function may have with the subset of <math>\mathbf{P}^{(1)}</math> consisting of the functions with that property.
| |
| Thus given a set <math>F \subseteq \mathbf{P}^{(1)}</math>, a computable function <math>\phi_e</math> has property ''F'' if and only if <math>\phi_e \in F</math>. For each property <math>F \subseteq \mathbf{P}^{(1)}</math> there is an associated [[decision problem]] <math>D_F</math> of determining, given ''e'', whether <math>\phi_e \in F</math>.
| |
| | |
| '''Rice's theorem''' states that the decision problem <math>D_F</math> is [[recursive set|decidable]] (also called recursive or computable) if and only if <math>F = \emptyset</math> or <math>F = \mathbf{P}^{(1)}</math>.
| |
| | |
| ==Examples==
| |
| According to Rice's theorem, if there is at least one computable function in a particular class ''C'' of computable functions and another computable function not in ''C'' then the problem of deciding whether a particular program computes a function in ''C'' is undecidable. For example, Rice's theorem shows that each of the following sets of computable functions is undecidable:
| |
| * The class of computable functions that return ''0'' for every input, and its complement.
| |
| * The class of computable functions that return ''0'' for at least one input, and its complement.
| |
| * The class of computable functions that are constant, and its complement.
| |
| | |
| ==Proof by Kleene's recursion theorem==
| |
| [[Kleene's recursion theorem#Application to quines|A corollary]] to [[Kleene's recursion theorem]] states that for every [[Gödel number]]ing <math>\phi\colon \mathbb{N} \to \mathbf{P}^{(1)}</math> of the [[computable function]]s and every computable function <math>Q(x,y)</math>, there is an index <math>e</math> such that <math>\phi_e(y)</math> returns <math>Q(e,y)</math>. (In the following, we will say that <math>f(x)</math> "returns" <math>g(x)</math> if either <math>f(x)=g(x)</math>, or both <math>f(x)</math> and <math>g(x)</math> are undefined.) Intuitively, <math>\phi_e</math> is a [[Quine (computing)|quine]], a function that returns its own source code (Gödel number), except that rather than returning it directly, <math>\phi_e</math> passes its Gödel number to <math>Q</math> and returns the result.
| |
| | |
| Let <math>F</math> be a set of computable functions such that <math>\emptyset \neq F \neq \mathbf{P}^{(1)}</math>. Then there are computable functions <math>f \in F</math> and <math>g \notin F</math>. Suppose that the set of indices <math>x</math> such that <math>\phi_x \in F</math> is decidable; then, there exists a function <math>Q(x,y)</math> that returns <math>g(y)</math> if <math>\phi_x \in F</math>, and <math>f(y)</math> otherwise. By the corollary to the recursion theorem, there is an index <math>e</math> such that <math>\phi_e(y)</math> returns <math>Q(e,y)</math>. But then, if <math>\phi_e \in F</math>, then <math>\phi_e</math> is the same function as <math>g</math>, and therefore <math>\phi_e \notin F</math>; and if <math>\phi_e \notin F</math>, then <math>\phi_e</math> is <math>f</math>, and therefore <math>\phi_e \in F</math>. In both cases, we have a contradiction.
| |
| | |
| ==Proof by reduction from the halting problem==
| |
| | |
| ===Proof sketch===
| |
| Suppose, for concreteness, that we have an algorithm for examining a program ''p'' and determining infallibly whether ''p'' is an implementation of the squaring function, which takes an integer ''d'' and returns ''d''<sup>2</sup>. The proof works just as well if we have an algorithm for deciding any other nontrivial property of programs, and will be given in general below.
| |
| | |
| The claim is that we can convert our algorithm for identifying squaring programs into one which identifies functions that halt. We will describe an algorithm which takes inputs ''a'' and ''i'' and determines whether program ''a'' halts when given input ''i''.
| |
| | |
| The algorithm for deciding this is conceptually simple: it constructs (the description of) a new program ''t'' taking an argument ''n'' which (1) first executes program ''a'' on input ''i'' (both ''a'' and ''i'' being hard-coded into the definition of ''t''), and (2) then returns the square of ''n''. If ''a''(''i'') runs forever, then ''t'' will never get to step (2), regardless of ''n''. Then clearly, ''t'' is a function for computing squares if and only if step (1) terminates. Since we've assumed that we can infallibly identify programs for computing squares, we can determine whether ''t'', which depends on ''a'' and ''i'', is such a program, and that for every ''a'' and ''i''; thus we have obtained a program that decides whether program ''a'' halts on input ''i''. Note that our halting-decision algorithm never executes ''t'', but only passes its description to the squaring-identification program, which by assumption always terminates; since the construction of the description of ''t'' can also be done in a way that always terminates, the halting-decision cannot fail to halt either.
| |
| | |
| halts (a,i) {
| |
| define t(n) {
| |
| a(i)
| |
| '''return''' n×n
| |
| }
| |
| '''return''' is_a_squaring_function(t)
| |
| }
| |
| | |
| This method doesn't depend specifically on being able to recognize functions that compute squares; as long as ''some'' program can do what we're trying to recognize, we can add a call to ''a'' to obtain our ''t''. We could have had a method for recognizing programs for computing square roots, or programs for computing the monthly payroll, or programs that halt when given the input <tt>"Abraxas"</tt>, or programs that commit array bounds errors; in each case, we would be able to solve the halting problem similarly.
| |
| | |
| ===Formal proof===
| |
| [[Image:Rice reduction.svg|thumb|If we have an algorithm which decides a non-trivial property, we can construct a Turing machine which decides the halting problem.]]
| |
| | |
| For the formal proof, algorithms are presumed to define partial functions over [[string (computer science)|strings]] and are themselves represented by strings. The partial function computed by the algorithm represented by a string ''a'' is denoted '''F'''<sub>''a''</sub>. This proof proceeds by [[reductio ad absurdum]]: we assume that there is a non-trivial property that is decided by an algorithm, and then show that it follows that we can decide the [[halting problem]], which is not possible, and therefore a contradiction.
| |
| | |
| Let us now assume that ''P''(''a'') is an algorithm that decides some non-trivial property of '''F'''<sub>''a''</sub>. Without loss of
| |
| generality we may assume that ''P''(''no-halt'') = "no", with ''no-halt'' being the representation of an algorithm that never halts. If this is not true, then this will hold for the negation of the property. Since ''P'' decides a non-trivial property, it follows that there is a string ''b'' that represents an algorithm and ''P''(''b'') = "yes". We can then define an algorithm ''H''(''a'', ''i'') as follows:
| |
| | |
| :1. construct a string ''t'' that represents an algorithm ''T''(''j'') such that
| |
| :* ''T'' first simulates the computation of '''F'''<sub>''a''</sub>(''i'') | |
| :* then ''T'' simulates the computation of '''F'''<sub>''b''</sub>(''j'') and returns its result.
| |
| :2. return ''P''(''t'').
| |
| | |
| We can now show that ''H'' decides the halting problem:
| |
| | |
| * Assume that the algorithm represented by ''a'' halts on input ''i''. In this case '''F'''<sub>''t''</sub> = '''F'''<sub>''b''</sub> and, because ''P''(''b'') = "yes" and the output of ''P''(''x'') depends only on '''F'''<sub>''x''</sub>, it follows that ''P''(''t'') = "yes" and, therefore ''H''(''a'', ''i'') = "yes".
| |
| | |
| * Assume that the algorithm represented by ''a'' does not halt on input ''i''. In this case '''F'''<sub>''t''</sub> = '''F'''<sub>''no-halt''</sub>, i.e., the partial function that is never defined. Since ''P''(''no-halt'') = "no" and the output of ''P''(''x'') depends only on '''F'''<sub>''x''</sub>, it follows that ''P''(''t'') = "no" and, therefore ''H''(''a'', ''i'') = "no".
| |
| | |
| Since the halting problem is known to be undecidable, this is a contradiction and the assumption that there is an algorithm ''P''(''a'') that decides a non-trivial property for the function represented by ''a'' must be false.
| |
| | |
| ==Rice's theorem and index sets==
| |
| Rice's theorem can be succinctly stated in terms of index sets:
| |
| | |
| :<blockquote>Let <math>\mathcal{C}</math> be a class of partial recursive functions with [[index set (recursion theory)|index set]] <math>C</math>. Then <math>C</math> is recursive if and only if <math>C = \emptyset</math> or <math>C = \mathbb{N}</math>.</blockquote>
| |
| | |
| where <math>\mathbb{N}</math> is the set of [[natural numbers]], including [[zero]].
| |
| | |
| ==An analogue of Rice's theorem for recursive sets==
| |
| One can regard Rice's theorem as asserting the impossibility of effectively deciding for any ''recursively enumerable'' set
| |
| whether it has a certain nontrivial property.<ref>A set <math>S\subseteq \mathbb{N}</math> is '''[[Recursively enumerable set|recursively enumerable]]''' if
| |
| <math>S=W_e:=\textrm{dom}\, \phi_e:=\{x: \phi_e(x)\downarrow \}</math> | |
| for some <math>e</math>, where <math>W_e</math> is the domain <math>\textrm{dom}\, \phi_e</math>
| |
| (the set of inputs <math>x</math> such that
| |
| <math>\phi_e(x)</math> is defined) of <math>\phi_e</math>.
| |
| The result for recursively enumerable sets can be obtained from that for (partial) computable functions by
| |
| considering the class <math>\{\phi_e: \textrm{dom}\, \phi_e \in C\}</math>, where <math>C</math> is a class of
| |
| recursively enumerable sets.</ref>
| |
| In this section, we give an analogue of Rice's theorem for ''recursive sets,'' instead of recursively enumerable sets.<ref>A recursively enumerable
| |
| set <math>S\subseteq \mathbb{N}</math> is '''[[Recursive set|recursive]]''' if its complement is recursively enumerable.
| |
| Equivalently, <math>S</math> is recursive if its characteristic function is computable.</ref>
| |
| Roughly speaking, the analogue says that if one can effectively determine for any ''recursive'' set whether it has a certain property,
| |
| then finitely many integers determine whether a recursive set has the property.
| |
| This result is analogous to the original Rice's theorem because both assert that a property is "decidable"
| |
| only if one can determine whether a set has that property by examining ''for at most finitely many <math>i</math>''
| |
| (for no <math>i</math>, for the original theorem), if <math>i</math> belongs to the set.
| |
| | |
| Let <math>W</math> be a class (called a ''simple game'' and thought of as a property) of recursive sets.
| |
| If <math>S</math> is a recursive set, then for some <math>e</math>, computable function <math>\phi_e</math>
| |
| is the characteristic function of <math>S</math>. We call <math>e</math> a '''characteristic index''' for <math>S</math>.
| |
| (There are infinitely many such <math>e</math>.)
| |
| Let's say the class <math>W</math> is ''computable'' if there is an algorithm (computable function) that decides
| |
| for any nonnegative integer <math>e</math> (not necessarily a characteristic index),
| |
| * if <math>e</math> is a characteristic index for a recursive set belonging to <math>W</math>, then the algorithm gives "yes";
| |
| * if <math>e</math> is a characteristic index for a recursive set not belonging to <math>W</math>, then the algorithm gives "no".
| |
| | |
| A set <math>S\subseteq \mathbb{N}</math> ''extends'' a string <math>\tau</math> of 0's and 1's
| |
| if for any <math>k< |\tau|</math> (the length of <math>\tau</math>),
| |
| the <math>k</math>th element of <math>\tau</math> is 1 if <math>k\in S</math>; is 0 otherwise.
| |
| For example, <math>S=\{1,3,4,7, \ldots \}</math> extends string <math>01011001</math>.
| |
| A string <math>\tau</math> is ''winning determining'' if any recursive set extending <math>\tau</math> belongs to <math>W</math>.
| |
| A string <math>\tau</math> is ''losing determining'' if no recursive set extending <math>\tau</math> belongs to <math>W</math>.
| |
| | |
| We can now state the following '''analogue of Rice's theorem'''
| |
| (Kreisel, Lacombe, and Shoenfield, 1959,<ref>{{cite book |last=Kreisel |first=G. |last2=Lacombe |first2=D. |last3=Shoenfield |first3=J. R. |year=1959 |chapter=Partial recursive functionals and effective operations |editor-last=Heyting |editor-first=A. |title=Constructivity in Mathematics |series=Studies in Logic and the Foundations of Mathematics |publisher=North-Holland |location=Amsterdam |pages=290–297 |isbn= }}</ref> Kumabe and Mihara, 2008<ref name= kumabe-m08jme>{{cite doi | 10.1016/j.jmateco.2007.05.012}}</ref>):
| |
| | |
| A class <math>W</math> of recursive sets is computable
| |
| if and only if there are a recursively enumerable set <math>T_0</math> of losing determining strings
| |
| and a recursively enumerable set <math>T_1</math> of winning determining strings such that
| |
| any recursive set extends a string in <math>T_0\cup T_1</math>.
| |
| | |
| This result has been applied to foundational problems in [[computational social choice]] (more broadly, [[algorithmic game theory]]).
| |
| For instance, Kumabe and Mihara (2008,<ref name= kumabe-m08jme /> 2008<ref>{{cite doi | 10.1007/s00355-008-0300-5}}</ref>)
| |
| apply this result to an investigation of the [[Nakamura number]]s for simple games in [[Cooperative game|cooperative game theory]] and [[social choice theory]].
| |
| | |
| ==See also==
| |
| | |
| * [[Gödel's incompleteness theorems]]
| |
| * [[Halting Problem]]
| |
| * [[Rice-Shapiro theorem]]
| |
| * [[Recursion theory]]
| |
| | |
| ==Notes==
| |
| <references/>
| |
| | |
| ==References==
| |
| | |
| * {{Cite document | last1=Hopcroft | first1=John | author1-link=John Hopcroft | last2=Ullman | first2=Jeffrey | author2-link=Jeffrey Ullman | title=[[Introduction to automata theory, languages, and computation]] | publisher=[[Addison-Wesley]] | year=1979 | pages=185–192 | postscript=<!-- Bot inserted parameter. Either remove it; or change its value to "." for the cite to end in a ".", as necessary. -->}}.
| |
| *Rice, H. G. "[http://links.jstor.org/sici?sici=0002-9947%28195303%2974%3A2%3C358%3ACORESA%3E2.0.CO%3B2-N Classes of Recursively Enumerable Sets and Their Decision Problems]." Trans. Amer. Math. Soc. '''74''', 358-366, 1953.
| |
| *{{Cite document | last1=Rogers | first1=Hartley | title=Theory of recursive functions and effective computability | publisher=[[McGraw-Hill]] | location=New York | year=1967 | postscript=<!-- Bot inserted parameter. Either remove it; or change its value to "." for the cite to end in a ".", as necessary. -->}}.
| |
| | |
| ==External links==
| |
| *{{MathWorld|urlname=RicesTheorem|title=Rice's theorem}}
| |
| | |
| [[Category:Articles containing proofs]]
| |
| [[Category:Articles with inconsistent citation formats]]
| |
| [[Category:Mathematical theorems in theoretical computer science]]
| |
| [[Category:Theorems in the foundations of mathematics]]
| |
| [[Category:Theory of computation]]
| |