Outline

• Other Complexity Classes
• Quiz
• SAT Algorithms

`coNP`

• If `L` is a language, then we denote by `bar L` the complement of `L`. That is, `bar L = {0,1}^star\\ L`.
  Definition. `coNP = {L | bar L in NP}`.
• Note `P` is in the `coNP`. So `NP cap coNP` is non-empty.
• `bar mbox(SAT)` is an example of a language in `coNP`. Here `bar mbox(SAT)` consists of those formulas that are not satisfiable.
• One can also give the following alternative definition of `coNP`:
  Definition. For every `L subseteq {0, 1}^star`, `L in coNP` if there exists a polynomial `p:NN -> NN` and a p-time TM `M` such that for every `x in {0, 1}^star`,
  `x in L iff forall u in {0, 1}^(p(|x|)), M(x, u) = 1`. Notice this is similar to the definition of `NP` except `exists` has been replaced by `forall`.
• You can define `coNP`-complete in the same fashion as `NP`-complete.
• Besides `bar mbox(SAT)`, perhaps the best-known coNP problem is: `mbox(TAUTOLOGY) = {phi | phi mbox( is a tautology ) }`.
  Here a tautology is a CNF formula that is satisfied by every assignment.

`bar mbox(SAT)` and `mbox(TAUTOLOGY)` are `coNP`-complete

• We already argued `bar mbox(SAT)` is in `coNP`. `mbox(TAUTOLOGY)` is in `coNP` from our second definition of `coNP`: Given a formula `phi` on `n` variables, we check for every assignment, the p-time property of whether it makes `phi` true.
• To see completeness of `bar mbox(SAT)`, suppose `L in coNP`, we want to show `L` `p`-time reduces to `bar mbox(SAT)`. To do this we compute the Cook-Levin reduction from `bar L` to `SAT`. For every input `x` that reduction produces a formula `phi_x` that is satisfiable iff `x in bar L`, so `x in L` iff `phi_x` is unsatisfiable. i.e., in `bar mbox(SAT)`.
• The `mbox(TAUTOLOGY)` reduction is the same idea. Suppose `L in coNP`, we want to show `L` `p`-time reduces to `mbox(TAUTOLOGY)`. To do this we compute the Cook-Levin reduction from `bar L` to `SAT`. For every input `x` that reduction produces a formula `phi_x` that is satisfiable iff `x in bar L`. Now consider `not phi_x`. If `phi_x` is in CNF, then `not phi_x` won't necessarily be in CNF, however, we can make an equivalent to `not phi_x` `CNF` formula, `bar{phi}_x`, by introducing new variables `c_i` for each clause `C_i` in `phi_x`, and by introducing a variable `z` whose value represent `phi_x`. `c_i iff C_i` can be expressed by taking the conjunction of the clauses `{bar{c_i}} \cup C_i` and `{\bar{l}_{i1},\bar{l}_{i2} ... \bar{l}_{it}, c_i}` where `l_{ij}` are the literals in `C_i`. We can express `z iff ^^_i c_i` as the set of clauses `{\bar{z}, c_i}` for each `i` together with `{bar{c_1}, ... bar{c}_m, z}`. We define `bar{phi}_x` as the conjunction over clauses for `c_i iff C_i` for each `i`, with `z iff ^^_i c_i`, and with the clause containing just `bar{z}`. From our discussion `bar{phi}_x` has value 1 iff `neg\phi_x` has value 1. Further `bar{phi}_x` is at most quadratic in the size of `not phi_x`. So `bar{phi}_x in mbox(TAUTOLOGY)` iff `x in L`, giving the reduction.

EXP versus NEXP

We have already defined the class `EXP = cup_(c ge 1) DTIME(2^(n^c))`. Similarly, we can define `NEXP` to be `cup_(c ge 1) NTIME(2^(n^c))`. It turns out the `EXP` versus `NEXP` question is connected with the `P` versus `NP` problem.

Theorem. If `EXP ne NEXP` then `P ne NP`.

Proof. We prove that if `P=NP` then `EXP = NEXP`. Suppose `L in NEXP` and is decided by NDTM `M`. We claim the language
`L_(mbox(pad)) = {langle x, 1^(2^(|x|^c)) rangle | x in L}`
is in NP. Here is an NDTM for `L_(mbox(pad))`: Given `y`, first check if there is a string `z` such that `y=langle z, 1^(2^(|z|^c)) rangle`. If not, output `0`. If `y` of this form, then simulate `M` on `z` for `2^(|z|^c)` steps and output its answer. The running time for this is polynomial in the input `|y|`, and hence `L_(mbox(pad)) in NP`. So if `P=NP`, then `L_(mbox(pad)) in P`. But if `L_(mbox(pad)) in P` then `L in EXP`: To determine whether an input `x in L`, we just pad the input and decide whether it is in `L_(mbox(pad))` using the `P` algorithm.

Quiz

Which of the following statements is true?

1. We defined a snapshot of Turing Machine M's execution on some input `y` at a particular step `i` as the triple `langle a, b, q rangle in Gamma times Gamma times Q` such that `a` and `b` are the symbols read by `M`'s heads and `q` is the state `M` is in at step `i`.
2. Our reduction of SAT to 3SAT didn't involve introducing new variables.
3. To prove dHAMPATH was NP-hard, we gave a reduction from any dHAMPATH problem to a problem in 3SAT.

SAT Algorithms

• Before we proceed further considering known structural properties of deterministic and nondeterministic time, I thought I'd have a little digression on techniques for dealing with NP problems when we really need to solve them.
• We have already proven five problems are NP-complete.
• Our in-class exercise last week mentioned the general clustering problem from AI is NP-complete.
• Since the first publication of NP-completeness, thousands of useful problems in a variety of domains have been shown to be NP-complete. For clustering, people often use a variety of heuristic approaches to try to find "good enough" clusters, but for other problems this kind of inexact approach is not sufficient.
• For example, in electronic design automation, we might one to formally verify that two circuits are equivalent, or check that a liveness property holds for some formal model of a protocol.
• Scheduling problems, are often NP-Complete, yet we still want to compute train schedules and the like which meet all of a variety of constraints.
• A "seems okay" solution does not cut it in these cases.
• Luckily, we have a very good reduction of any NP problem to SAT: we can use the reduction to find from certificates of SAT, certificates of the NP problem.
• So we can "compile", using this reduction, the NP-problem to SAT, and focus on optimizing our algorithms for SAT.

Special Cases of SAT

• Several special cases of SAT actually turn out to have p-time algorithms, so to start let's look at these...
• CASE 1: Suppose for each clause `C` in an instance of `phi` of SAT, if we look at only the variables in `C`, and we set them all to 1, then the clause's value is 1.
  • For example, `{{x_1, bar{x}_2}, {bar{x}_1, bar{x}_2, x_3}, {\bar{x}_1, x_2, bar{x}_3}}`
  • This condition is a polynomial time condition to check, and if it holds, the all `1` assignment will make `phi` true.
• CASE 2: Suppose for each clause `C` in an instance of `phi` of SAT, if we look at only the variables in `C`, and we set them all to 0, then the clause's value is 1.
  • Our example formula in Case 1 also has this property.
  • This condition again is a polynomial time condition to check, and if it holds, the all `0` assignment will make `phi` true.

Special Cases of SAT cont'd (2-SAT)

• CASE 3: Suppose all the clauses in an instance of `phi` of SAT have at most two literals.
  • Assume `phi` has `n` variables `x_1, ..., x_n`. Build a directed graph with `2n` vertices labeled `x_1, ..., x_n, bar{x_1}, ..., bar{x_n}`. For all vertices, for clause `{l_i, l_j}`, (here `l_i`, `l_j` are literals), and an edge between `bar{l_i}` and `l_j` and between `bar{l_j}` and `l_i`.
  • For example, the set of clauses `{{x_1, bar{x}_2},{bar{x}_1, bar{x}_2}, {x_2}}` yields edges `e_1 = (bar{x}_1, bar{x}_2)`, `e_2 = (x_2, x_1)`, `e_3 = (x_1, bar{x}_2)`, `e_4 = (x_2, bar{x}_1)`, and `e_5 = (bar{x}_2, x_2)` (from the clause containing just `x_2`).
  • We can view an edge `(l_i, l_j)` as the implication `l_i => l_j`.
  • A sequence `(l_{i_1}, l_{i_2}), (l_{i_2}, l_{i_3}), ..., (l_{i_{k-1}}, l_{i_k})` would entail `(l_{i_1}, l_{i_k})`
  • The formula `phi` will be satisfiable iff for each literal in `phi` either `l_i` is not connected to `bar{l_i}` or `bar{l_i}` is not connected to `l_i`.
  • This is because if both hold we have `l_i iff bar{l_i}` which cannot satisfied. On the other, if for each literal at least one of these two connection don't exist, we can make take our graph and make a new graph where we replace strongly connected components with single vertices, topologically sort these vertices, then pick the least vertex assign its literal a value, then label the implied vertices consistently. We then repeat this process by picking the least vertex from our sort that hasn't been assigned yet, until all the vertices, and hence variables, have a value.
  • So an algorithm for satisfiability is:

    Given a set of clauses F in n variables x[1], ... x[n].
    for (i = 1; i <= n; i++) {
        if (x[i] is reachable from ~x[i]
            and ~x[i] is reachable from x[i]) {
            output 0
            halt;
        } 
    }
    output 1
    halt
    

  • Reachability in a graph is p-time to check.
  • For our example above, we have a path from `bar{x}_2` to `x_2` using edges `e_5`. On the other hand, `e_2` followed by `e_3` is a path from `x_2` to `bar{x}_2` , so it is not satisfiable.

Special Cases of SAT cont'd (Horn Clauses)

• CASE 4: Horn Clauses. Call a clause Horn, if at most one variable in it is not negated. For example, `{bar{x}_1, bar{x}_2, x_3}` and `{bar{x}_4}` are both Horn. A collection of Horn clauses is called a Horn Program.
  • The generalization of Horn Programs where, rather than just allow boolean variables, we instead allow relations is called Datalog. Datalog is a restricted form of the Prolog language, that comes up in logical databases, and is known to be equivalent in query expressive power to the relational algebra.
  • To get an algorithm for Horn programs, we first consider the following method, called resolution, to derive new clauses: Given two existing clauses which share a variable but with opposite signs (top), we can add the clause on the bottom, without affecting satisfiability.
    `frac( L_1 vv ... vv L_m, quad neg L_m vv L_1' vv ...vv L_n')(L_1 vv ... vv L_(m-1) vv L_1' vv ... vv L_n')`
    If you are familiar with logic, then this can be considered a generalization of modus ponens.
  • Notice if the top two clauses are Horn, so is the derived clause.
  • Recall an OR of literals is 1 if any literal can be made 1. So the empty clause, {}, being an empty OR cannot be made 1 and so is 0. An AND of 0 with anything is 0, so if we given a set of clauses if we can apply resolution and derive the empty clause, we know the original set of clauses is unsatisfiable.
  • Call a clause a unit clause, if it only involves one literal. Notice if a Horn program does not involve a unit clause, then it satisfies CASE 2, and so the all 0 assignment will make it true.
  • Using this the following is a p-time algorithm for Horn Programs:

    Let P be a Horn Program on n variables.
    Let S be its set of unit clauses. Let OldS be the empty set.
    while (S != OldS) {
       OldS = S
       Pick first literal L in S.
       if (~L does not appear in any clause) {
          delete clause L from P and S;
       } else {
          generate all clauses using resolution from clauses 
              involving ~L and add them to P;
          if (derive empty clause) {
             output 0;
             halt;
          }
          delete all clauses with L or ~L;
          update S according to unit clauses currently in P.
       }
    }
    output 1;
    halt
    

  • Note while loop can execute at most n times, so above is p-time.

Special Cases of SAT cont'd (dual Horn Clauses)

• CASE 5: dual Horn Clauses. Call a clause dual Horn, if at most one variable in it is negated. For example, `{x_1, x_2, bar{x}_3}` and `{x_4}` are both dual Horn. A collection of dual Horn clauses is called a dual Horn Program.
  • If a dual Horn program does not have any unit clauses, then it becomes a CASE 1 instance of satisfiability, and so the all 1 assignment will satisfy it.
  • The same algorithm as used for Horn clauses can be used to check satisfiability in this case.

Special Cases of SAT cont'd (Affine Formulas)

• Case 6: Affine Formulas. Suppose we only allow clauses which express affine linear equations mod 2. That is, equations of the form `x_{i_1} oplus x_{i_2} oplus cdots oplus x_{i_m} = c`. Let `R_i` be a set of clauses expressing such a formula, and suppose we only consider SAT instances of the form `^^_i R_i`.
  • If our clauses express a set of such relations, then we can use Gaussian elimination to find a solution in p-time.