|
|
| Line 1: |
Line 1: |
| {{Expert-subject|Computing|talk=Copy edit not needed|date=January 2012}}
| | The writer is known as Wilber Pegues. My working day job is an information officer but I've currently applied for another one. I am truly fond of handwriting but I can't make it my occupation really. Ohio is exactly where my home is but my spouse desires us to transfer.<br><br>my blog: [http://kard.dk/?p=24252 online reader] |
| | |
| In [[descriptive complexity]], a branch of [[Computational complexity]] ''FO'' is a [[complexity class]] of structures which can be recognized by formulas of [[first-order logic]]. It is the foundation of the field of [[descriptive complexity]] and is equal to the complexity class [[AC0|AC<sup>0</sup>]]. Descriptive complexity uses [[First-order logic]] formalism, but does not use most of the usual notion associated to logic as proof theory or axiomatization.
| |
| | |
| When the predicates are restricted to a set ''X'', ''FO[X]'' correspond to some other class, and there exists specific sets ''X'' such ''FO[X]'' has some interesting properties. In particular, ''FO[<]'' is equal to the set of [[Star-free language]]s. Having two different definition, in term of logic and in term of regular expression, is a hint showing that this class may have some mathematical interest, and that we may use together methods for both domain to do proofs.
| |
| | |
| Similarly, various extensions of FO, formed by the addition of certain operators, give rise to other well-known complexity classes,<ref>N. Immerman ''Descriptive complexity'' (1999 Springer)</ref> allowing the complexity of some problems to be proven without having to look at them as [[algorithm]] problem.
| |
| | |
| == Definition and examples ==
| |
| | |
| === The idea ===
| |
| When we use the logic formalism to describe a computational problem, the input is a finite structure, and the elements of that structure are the [[domain of discourse]]. Usually the input is either a string (of bits or over an alphabet) the elements of which are positions of the string, or a graph of which the elements are vertices. The length of the input will be measured by the size of the respective structure.
| |
| Whatever the structure is, we can assume that there are relations that can be tested, for example "<math>E(x,y)</math> is true [[iff]] there is an edge from <math>x</math> to <math>y</math>" (in case of the structure being a graph), or "<math>P(n)</math> is true [[iff]] the <math>n</math>th letter of the string is 1." These relations are the predicates for the first-order logic system. We also have constants, which are special elements of the respective structure, for example if we want to check reachability in a graph, we will have to choose two constants s (start) and t (terminal).
| |
| | |
| In descriptive complexity theory we almost always suppose that there is a total order over the elements and that we can check equality between elements. This lets us consider elements as numbers: the element <math>x</math> represents the number <math>n</math> iff there are <math>(n-1)</math> elements <math>y</math> with <math>y<x</math>. Thanks to this we also may have the primitive predicate "bit", where <math>bit(x,k)</math> is true if only the <math>k</math>th bit of <math>x</math> is 1. (We can replace addition and multiplication by ternary relations such that <math>plus(x,y,z)</math> is true iff <math>x+y=z</math> and <math>times(x,y,z)</math> is true iff <math>x*y=z</math>).
| |
| | |
| === Formally ===
| |
| Let ''X'' be a set of predicate. The language ''FO[X]'' is defined as the closure by conjunction ( <math>\wedge</math>), negation (<math>\neg</math>) and universal quantification (<math>\forall</math>) over elements of the structures. We also often use existential quantification (<math>\exists</math>) and disjunction (<math>\vee</math>) but those can be defined by means of the first 3 symbols. The base case being the predicates of ''X'' applied to some variables. We always implicitely have a predicate <math>P_a(x)</math> for each letter <math>a</math> of our alphabet, stating that the letter at position <math>x</math> is an <math>a</math>.
| |
| | |
| The semantics of the formulae in FO is straightforward, <math>\neg A</math> is true iff <math>A</math> is false, <math>A\wedge B</math> is true iff <math>A</math> is true and <math>B</math> is true, and <math>\forall x P(x) </math> is true iff <math>P(v)</math> is true for all values <math>v</math> that <math>x</math> may take in the underlying universe. For ''P'' a ''c''-ary predicate, <math>P(x_1,\dots, x_c)</math> is true if and only if when <math>x_i</math> is interpreted as <math>n_i</math> <math>P(n_1,\dots, n_c)</math> is true.
| |
| | |
| == Property ==
| |
| | |
| === Warning ===
| |
| A query in FO will then be to check if a first-order formula is true over a given structure representing the input to the problem. One should not confuse this kind of problem with checking if a quantified boolean formula is true, which is the definition of [[Quantified Boolean formula problem|QBF]], which is [[PSPACE-complete]]. The difference between those two problems is that in QBF the size of the problem is the size of the formula and elements are just boolean values, whereas in FO the size of the problem is the size of the structure and the formula is fixed.
| |
| | |
| This is similar to [[Parameterized complexity]] but the size of the formula is not a fixed parameter.
| |
| | |
| === Normal form ===
| |
| Every formula is equivalent to a formula in [[prenex normal form]] (where all quantifiers are written first, followed a quantifier-free formula).
| |
| | |
| == Operators ==
| |
| | |
| === FO without any operators ===
| |
| | |
| In [[circuit complexity]], ''FO(ARB)'' where ''ARB'' is the set of every predicates, the logic where we can use arbitrary predicates, can be shown to be equal to [[AC0|AC<sup>0</sup>]], the first class in the [[AC (complexity)|AC]] hierarchy. Indeed, there is a natural translation from FO's symbols to nodes of circuits, with <math>\forall, \exists</math> being <math>\land</math> and <math>\lor</math> of size <math>n</math>.
| |
| | |
| ''FO(BIT)'' is the restriction of AC<sup>0</sup> family of circuit constructible in [[LH (complexity)|alternative logarithmic time]].
| |
| ''FO(<)'' is the set of [[Star-free language]]s.
| |
| | |
| === Partial fixed point is PSPACE ===
| |
| FO(PFP,X) is the set of boolean queries definable in FO(X) where we add a partial fixed point operator.
| |
| | |
| Let <math>k</math> be an integer, <math>x, y</math> be vectors of <math>k</math> variables, <math>P</math> be a second-order variable of arity <math>k</math>, and <math>\phi</math> be a FO(PFP,X) function using <math>x</math> and <math>P</math> as variables. We can iteratively define <math>(P_i)_{i\in N}</math> such that <math>P_0(x)=false</math> and <math>P_i(x)=\phi(P_{i-1},x)</math> (meaning <math>\phi</math> with <math>P_{i-1}</math> substituted for the second-order variable <math>P</math>). Then, either there is a fixed point, or the list of <math>(P_i)</math>s is cyclic.
| |
| | |
| PFP<math>(\phi_{P,x})(y)</math> is defined as the value of the fixed point of <math>(P_i)</math> on <math>y</math> if there is a fixed point, else as false. Since <math>P</math>s are properties of arity <math>k</math>, there are at most <math>2^{n^k}</math> values for the <math>P_i</math>s, so with a polynomial-space counter we can check if there is a loop or not.
| |
| | |
| It has been proven that FO(PFP,BIT) is equal to [[PSPACE]]. This definition is equivalent to FO(<math>2^{n^{O(1)}}</math>).
| |
| | |
| === Least Fixed Point is P ===
| |
| FO(LFP,X) is the set of boolean queries definable in FO(PFP,X) where the partial fixed point is limited to be monotone. That is, if the second order variable is <math>P</math>, then <math>P_i(x)</math> always implies <math>P_{i+1}(x)</math>.
| |
| | |
| We can guarantee monotonicity by restricting the formula <math>\phi</math> to only contain positive occurrences of <math>P</math> (that is, occurrences preceded by an even number of negations). We can alternatively describe LFP(<math>\phi_{P,x}</math>) as PFP(<math>\psi_{P,x}</math>) where <math>\psi(P,x)=\phi(P,x)\vee P(x)</math>.
| |
| | |
| Due to monotonicity, we only add vectors to the truth table of <math>P</math>, and since there are only <math>n^k</math> possible vectors we will always find a fixed point before <math>n^k</math> iterations. Hence it can be shown that FO(LFP,BIT)=[[P (complexity)|P]]. This definition is equivalent to FO(<math>n^{O(1)}</math>).
| |
| | |
| === Transitive closure is NL ===
| |
| FO(TC,X) is the set of boolean queries definable in FO(X) with a transitive closure (TC) operator.
| |
| | |
| TC is defined this way: let <math>k</math> be a positive integer and <math>u,v,x,y</math> be vector of <math>k</math> variables. Then TC<math>(\phi_{u,v})(x,y)</math> is true if there exist <math>n</math> vectors of variables <math>(z_i)</math> such that <math>z_1=x, z_n=y</math>, and for all <math>i<n</math>, <math>\phi(z_i,z_{i+1})</math> is true. Here, <math>\phi</math> is a formula written in FO(TC) and <math>\phi(x,y)</math> means that the variables <math>u</math> and <math>v</math> are replaced by <math>x</math> and <math>y</math>.
| |
| | |
| FO(TC,BIT) is equal to [[NL (complexity)|NL]].
| |
| | |
| === Deterministic transitive closure is L ===
| |
| FO(DTC,X) is defined as FO(TC,X) where the transitive closure operator is deterministic. This means that when we apply DTC(<math>\phi_{u,v}</math>), we know that for all <math>u</math>, there exists at most one <math>v</math> such that <math>\phi(u,v)</math>.
| |
| | |
| We can suppose that DTC(<math>\phi_{u,v}</math>) is [[syntactic sugar]] for TC(<math>\psi_{u,v}</math>) where <math>\psi(u,v)=\phi(u,v)\wedge \forall x, (x=v \vee \neg \psi(u,x))</math>.
| |
| | |
| It has been shown that FO(DTC,BIT) is equal to [[L (complexity)|L]].
| |
| | |
| ===Normal form ===
| |
| Any formula with a fixed point (resp. transitive cosure) operator can without loss of generality be written with exactly one application of the operators applied to 0 (resp. <math>0,(n-1)</math>)
| |
| | |
| == Iterating ==
| |
| | |
| We will define first-order with iteration, ''''FO[<math>t(n)</math>]''''; here <math>t(n)</math> is a (class of) functions from integers to integers, and for different classes of functions <math>t(n)</math> we will obtain different complexity classes FO[<math>t(n)</math>].
| |
| | |
| In this section we will write <math>(\forall x P) Q</math> to mean <math>(\forall x (P\Rightarrow Q))</math> and <math>(\exists x P) Q</math> to mean <math>(\exists x (P \vee Q))</math>. We first need to define quantifier blocks (QB), a quantifier block is a list <math>(Q_1 x_1, phi_1)...(Q_k x_k, phi_k)</math> where the <math>phi_i</math>s are quantifier-free [[#Complexity_Zoo:F#FO|FO]]-formulae and <math>Q_i</math>s are either <math>\forall</math> or <math>\exists</math>.
| |
| If <math>Q</math> is a quantifiers block then we will call <math>[Q]^{t(n)}</math> the iteration operator, which is defined as <math>Q</math> written <math>t(n)</math> time. One should pay attention that here there are <math>k*t(n)</math> quantifiers in the list, but only <math>k</math> variables and each of those variable are used <math>t(n)</math> times.
| |
| | |
| We can now define FO[<math>t(n)</math>] to be the FO-formulae with an iteration operator whose exponent is in the class <math>t(n)</math>, and we obtain those equalities:
| |
| *FO[<math>(\log n)^i</math>] is equal to FO-uniform [[AC (complexity)|AC<sup>i</sup>]], and in fact FO[<math>t(n)</math>] is FO-uniform AC of depth <math>t(n)</math>.
| |
| *FO[<math>(\log n)^{O(1)}</math>] is equal to [[#NC_(complexity)|NC]].
| |
| *FO[<math>n^{O(1)}</math>] is equal to [[P (complexity)|PTIME]], it is also another way to write |FO(LFP).
| |
| *FO[<math>2^{n^{O(1)}}</math>] is equal to [[PSPACE]], it is also another way to write [[#Complexity_Zoo:F#fopfp|FO(PFP)]].
| |
| | |
| ==Logic without arithmetical relations==
| |
| Let the successor relation, ''succ'', be a binary relation such that <math>\rm{succ}(x,y)</math> is true if and only if <math>x+1=y</math>.
| |
| | |
| Over first order logic, ''succ'' is strictly less expressive than <, which is less expressive than +, which is less expressive than ''bit''. + and <math>\times</math> are as expressive as ''bit''.
| |
| | |
| ===Using successor to define ''bit'' ===
| |
| It is possible to define the ''plus'' and then the ''bit'' relations with a deterministic transitive closure.
| |
| | |
| <math>\rm{plus}(a,b,c)=(\rm{DTC}_{v,x,y,z} \rm{succ}(v,y) \land
| |
| \rm{succ}(z,x)) (a,b,c,0)</math> and
| |
| | |
| <math>\rm{bit}(a,b)=(\rm{DTC}_{a,b,a',b'}\psi)(a,b,1,0)</math> with
| |
| | |
| <math>\psi=\text{if } b=0 \text{ then }
| |
| (\text{if } \exists m(a=m+m+1) \text{ then }(a'=1\land b'=0)\text{ else }
| |
| \bot)\text{ else } (\rm{succ}(b',b) \land (a+a=a'\lor
| |
| a+a+1=a')</math>
| |
| | |
| This just means that when we query for bit 0 we check the parity, and go to (1,0) if <math>a</math> is odd(which is an accepting state), else we reject. If we check a bit <math>b>0</math>, we divide <math>a</math> by 2 and check bit <math>b-1</math>.
| |
| | |
| Hence it makes no sense to speak of operators with successor alone, without the other predicates.
| |
| | |
| ===Logics without successor===
| |
| ''FO[LFP]'' and ''FO[PFP]'' are two logics without any predicates, apart from the equality predicates between variables and the letters predicates. They are equal respectively to ''relational-P'' and FO(PFP) is ''relational-PSPACE'', the classes P and PSPACE over [[relational machines]].<ref name="avv">Serge Abiteboul, [[Moshe Y. Vardi]], [[Victor Vianu]]: [http://portal.acm.org/citation.cfm?id=256295|Fixpoint logics, relational machines, and computational complexity] Journal of the ACM (JACM) archive, Volume 44 , Issue 1 (January 1997), Pages: 30-56, ISSN:0004-5411</ref>
| |
| | |
| The [[Abiteboul-Vianu Theorem]] states that FO(LFP)=FO(PFP) if and only if FO(<,LFP)=FO(<,PFP), hence if and only if P=PSPACE. This result has been extended to other fixpoints.<ref name="avv"/> This shows that the order problem in first order is more a technical problem than a fundamental one.
| |
| | |
| == References ==
| |
| * [[Ronald Fagin]], [http://www.almaden.ibm.com/cs/people/fagin/genspec.pdf Generalized First-Order Spectra and Polynomial-Time Recognizable Sets]. ''Complexity of Computation'', ed. R. Karp, SIAM-AMS Proceedings 7, pp. 27–41. 1974.
| |
| * Ronald Fagin, [http://www.almaden.ibm.com/cs/people/fagin/tcs93.pdf Finite model theory-a personal perspective]. Theoretical Computer Science 116, 1993, pp. 3–31.
| |
| * Neil Immerman. [http://www.cs.umass.edu/~immerman/pub/capture.pdf Languages Which Capture Complexity Classes]. ''15th ACM STOC Symposium'', pp. 347–354. 1983.
| |
| {{Reflist}}
| |
| | |
| == External links ==
| |
| * [http://www.cs.umass.edu/~immerman/descriptive_complexity.html Neil Immerman's descriptive complexity page], including a diagram
| |
| * [http://qwiki.stanford.edu/wiki/Complexity_Zoo:F#fo|Complexity zoo about FO], see the class under it also
| |
| | |
| {{DEFAULTSORT:Fo (Complexity)}}
| |
| [[Category:Descriptive complexity| ]]
| |
| [[Category:Finite model theory]]
| |
| [[Category:Complexity classes]]
| |