%*****************************************
\chapter{State of the Art}\label{ch:sota}
%*****************************************

\section{Preliminaries}
\label{sec:prelim}

This section introduces the notation used in the rest of this
chapter. The exposition of the propositional logic is mainly based on
the work of Nieuwenhuis et al.~\cite{NOT06}. The exposition of the
first-order logic is based mainly on works of Enderton~\cite{End01}
and of Barrett et al.~\cite{BSST09}. Note that instead of following
the approach of Enderton to the first-order theories, we follow the
approach of Barrett et al. and define the theory as a set of
first-order \emph{structures}, rather than a set of first-order
sentences.

\subsection{Propositional formulas, assignments, and satisfaction}
\label{prelim:prop}

Let $\P$ be a fixed finite set of propositional variables. For every
variable $x \in \P$ there are two literals -- a \emph{positive
  literal} $x$ and a \emph{negative literal} $\overline{x}$. For a
given literal $l$, we define $\neg l$ as $\overline{l}$ if $l = x$ for
a variable $x$ and as $x$ if $l = \overline{x}$ for a variable
x. Literals $l$ and $\neg l$ are called \emph{complementary}. A
\emph{clause} is a finite disjunction of literals. The empty clause is
denoted by $\bot$. A formula in the \emph{conjunctive normal form}
(\cnf) is a finite conjunction of clauses. If convenient, we use
idempotence and commutativity of disjunction and view clauses as sets
of literals and therefore ignore the order and multiple occurrences of
literals. Similarly, if convenient, we view \cnf formulas as sets of
clauses. For example, we write the formula
$(x \vee \overline{y}) \wedge (\overline{x} \vee z)$ as the set
$\{ \{ x , \overline{y} \}, \{ \overline{x}, z \} \}$.

A \emph{partial assignment} $M$ is a set of literals that does not
contain complementary literals, i.e.
$\{ x, \overline{x} \} \not \subseteq M$ for all $x \in \P$. A literal
$l$ is \emph{true} in the assignment $M$ if $l \in M$, \emph{false} in
$M$ if $\neg l \in M$, and \emph{undefined} otherwise. A literal is
\emph{defined} in $M$ if it is true or false in $M$. We call an
assignment $M$ \emph{total} over $\P$ if all literals of $\P$ are
defined in $M$. A clause is \emph{true} in $M$ if at least one of its
literals is true in $M$ and a \cnf formula is \emph{true} in $M$ if
all of its clauses are true in $M$. A clause that is false for a given
assignment $M$ is called a \emph{conflict clause} for $M$. If, for a
given assignment, all literals of a clause are false except of one
literal that is undefined, the clause is called \emph{unit} in that
assignment.

%For a clause
%$C = x_1 \vee \ldots x_n$, the notation $\neg C$ stands for the
%formula $\neg x_1 \wedge \ldots \wedge x_n$.

If a formula $\varphi$ is true in $M$, we call $M$ a \emph{model} of
$\varphi$ and denote it as $M \models \varphi$. A formula is
\emph{satisfiable} if it has a model and \emph{unsatisfiable}
otherwise. If every model of a formula $\varphi$ is also a model of a
formula $\psi$, we say that the formula $\psi$ is \emph{entailed} by
the formula $\varphi$ and denote it as $\varphi \models
\psi$. Formulas $\varphi$ and $\psi$ are called \emph{equisatisfiable}
if $\varphi$ is satisfiable precisely if $\psi$ is satisfiable.

\subsection{First-order logic and theories}

A \emph{signature} $\Sigma$ consists of a set of \emph{function
  symbols} $\Sigma^f$, a set of \emph{predicate symbols} $\Sigma^p$,
and for each of these symbols of a non-negative number called its
\emph{arity}. Given a signature $\Sigma$, \emph{$\Sigma$-terms},
\emph{$\Sigma$-atoms}, \emph{$\Sigma$-literals},
\emph{$\Sigma$-clauses}, \emph{$\Sigma$-formulas}, and
\emph{$\Sigma$-formulas in \cnf} are defined as usual. We are using
the logic with equality, i.e. the set of $\Sigma$-atoms contains
elements $t_1 = t_2$ for each pair of $\Sigma$-terms $t_1, t_2$.  We
call $\Sigma$-terms and $\Sigma$-formulas \emph{ground} if they
contain no free variables.

A \emph{$\Sigma$-structure} $\mathcal{A}$ consists of a non-empty set
$A$, the \emph{universe} of the structure, and an assignment
$(\_)^\mathcal{A}$, which to each variable $x$ assigns an element
$x^\mathcal{A} \in A$, to each function symbol $f \in \Sigma^f$ of
arity $n$ assigns a function $f^\mathcal{A} \colon A^n \rightarrow A$,
and to each predicate symbol $P \in \Sigma^p$ of arity $n$ assigns a
relation $P^\mathcal{A} \subseteq A^n$. Given a $\Sigma$-structure
$\mathcal{A}$, there exists a unique homomorphic extension of
$(\_)^\mathcal{A}$ to $\Sigma$-terms, which to each $\Sigma$-term $t$
assigns an element $t^\mathcal{A} \in A$. In turn, using standard
definitions, the assignment $(\_)^\mathcal{A}$ can be further extended
to assign a truth value $\varphi^\mathcal{A} \in \{ \true, \false \}$
to each $\Sigma$-formula $\varphi$. A $\Sigma$-structure $\mathcal{A}$
is said to \emph{satisfy} a $\Sigma$-formula $\varphi$ if
$\varphi^\mathcal{A} = \true$. In such case, the structure
$\mathcal{A}$ is also called a \emph{model} of the formula $\varphi$.

A \emph{$\Sigma$-theory} $\mathcal{T}$ is a class of
$\Sigma$-structures closed under isomorphisms and variable
reassignment. A $\Sigma$-formula is said to be \emph{satisfiable in
  the $\Sigma$-theory $\mathcal{T}$}, or
\emph{$\mathcal{T}$-satisfiable}, if there exists a $\Sigma$-structure
$\mathcal{A} \in \mathcal{T}$ such that $\mathcal{A}$ satisfies
$\varphi$. The structure $\mathcal{A}$ is then called a
\emph{$\mathcal{T}$-model} of $\varphi$. If $\varphi$ is a
$\Sigma$-formula and $\Gamma$ is a set of $\Sigma$-formulas, we say
that \emph{$\Gamma$ entails $\varphi$ in $\mathcal{T}$}, written
$\Gamma \models_\mathcal{T} \varphi$, if every $\Sigma$-structure that
satisfies all formulas in $\Gamma$ also satisfies $\varphi$. If
$\emptyset \models_\mathcal{T} \varphi$, the formula $\varphi$ is
called \emph{$\mathcal{T}$-valid} or a \emph{theory lemma}. A set
$\Gamma$ of $\Sigma$-formulas is called
\emph{$\mathcal{T}$-inconsistent}, if
$\Gamma \models_{\mathcal{T}} \bot$.

% If $\varphi$
% and $\psi$ are ground $\Sigma$-formulas such that
% $\varphi \wedge \neg \psi$ is $\mathcal{T}$-unsatisfiable, we say that
% \emph{$\varphi$ entails $\psi$ in $\mathcal{T}$} and write it as
% . A $\Sigma$-formula $\varphi$ such that
% $\neg \varphi$ is $\mathcal{T}$-unsatisfiable is called a \emph{theory
%   lemma}.

For two signatures $\Sigma$ and $\Omega$, we call $\Omega$ a
\emph{sub-signature} of $\Sigma$ if $\Omega^f \subseteq \Sigma^f$ and
$\Omega^p \subseteq \Sigma^p$. Given a $\Sigma$-structure
$\mathcal{A}$ and a signature $\Omega$ that is a sub-signature of
$\Sigma$, the \emph{reduct} of $\mathcal{A}$ to a sub-signature
$\Omega$ is an $\Omega$-structure $\mathcal{A}'$ that has the same
universe as $\mathcal{A}$ and coincides with $\mathcal{A}$ on all
symbols from $\Omega$. For a $\Sigma_1$-theory $\mathcal{T}_1$ and a
$\Sigma_2$-theory $\mathcal{T}_2$, their \emph{combination}
$\mathcal{T}_1 + \mathcal{T}_2$ is the largest
$(\Sigma_1 \cup \Sigma_2)$-theory that contains all
$(\Sigma_1 \cup \Sigma_2)$-structures $\mathcal{A}$ for which the
reduct of $\mathcal{A}$ to $\Sigma_1$ is in $\mathcal{T}_1$ and the
reduct of $\mathcal{A}$ to $\Sigma_2$ is in $\mathcal{T}_2$.

We use the notation $\varphi[x_1, \ldots, x_n]$ for a formula whose
free variables are from the set $\{x_1, \ldots, x_n \}$. If
$\varphi[x_1, \ldots, x_n]$ is a formula and $t_1, \ldots, t_n$ are
terms, $\varphi[t_1, \ldots, t_n]$ denotes a results of the
simultaneous substitution of every free variable $x_i$ in $\varphi$ by
the term $t_i$.

In the rest of this chapter, we consider only theories for which the
satisfiability of conjunctions of $\Sigma$-literals is decidable and
we call any decision procedure for conjunctions of $\Sigma$-literals a
$\mathcal{T}$-\emph{solver}. Moreover, if the signature or the theory
is clear from the context, we drop the respective $\Sigma$- or
$\mathcal{T}$- prefixes.

\subsection{Many-sorted logic}

For some theories, it can be convinient to distinguish several types
of objects instead of having only one universe. This can be achieved
by using a \emph{many-sorted logic}. In contrast with a single-sorted
signature, defined in the previous subsection, a \emph{many-sorted
  signature $\Sigma$} additionally contains a set of \emph{sort
  symbols} $\Sigma^S$. Arities in a many-sorted logic are also
modified. Arity of a symbol determines not only a number of its
arguments, but also their types -- each function symbol has assigned
$(n+1)$-tuple of sort symbols for a non-negative integer $n$ and each
predicate symbols has assigned a $n$-tuple of sort symbols for a
non-negative integer $n$. Simultaneous inductive definition of terms
of a sort $S \in \Sigma^S$ and definitions of atoms, literals, clauses
and formulas are straightforward and can be found for example in
Enderton~\cite{End01}.

For a many-sorted signature $\Sigma$, a \emph{$\Sigma$-structure}
$\mathcal{A}$ consists of an assignment $(\_)^\mathcal{A}$, which to
each sort symbol $S \in \Sigma^S$ assigns a non-empty set
$S^\mathcal{A}$, caled the \emph{domain of S in $\mathcal{A}$}, to
each variable $x$ of sort $S$ assigns an element
$x^\mathcal{A} \in S^\mathcal{A}$, to each function symbol
$f \in \Sigma^f$ of an arity $(S_1, \ldots, S_n, S_{n+1})$ assigns a
function
$f^\mathcal{A} \colon S_1^\mathcal{A} \times \ldots \times
S_n^\mathcal{A} \rightarrow S_{n+1}^\mathcal{A}$, and to each
predicate symbol $P \in \Sigma^p$ of an arity $(S_1, \ldots, S_n)$
assigns a relation
$P^\mathcal{A} \subseteq S_1^\mathcal{A} \times \ldots \times
S_n^\mathcal{A}$. Definitions of many-sorted satisfiability, models,
entailment, and so on are also straightforward and can also be found
in Enderton~\cite{End01}.

\section{Propositional satisfiability}
\label{sec:sat}

A \emph{propositional satisfiability problem} (\sat) is to decide for
a given formula $\varphi$ in \cnf, whether it is satisfiable. The
restriction to formulas in \cnf is without a loss of generality, as
the Tseytin transformation can be used to transform every formula to
an equisatisfiable formula in \cnf with only linear increase of its
size~\cite{Tse68}.

\subsection{Davis--Putnam--Logemann--Loveland algorithm}

Historically, the first procedure to solve \sat without explicitly
computing the truth table of the formula was proposed by Davis and
Putnam~\cite{DP60}. During the Davis--Putnam procedure (\dppr) the
propositional variables of the input formula are successively
eliminated using the resolution inference rule~\cite{Rob65}. If the
resolution yields the empty clause, the formula is unsatisfiable; on
the other hand, if after elimination of all variables no clauses
remain, the formula is satisfiable. The main problem of \dppr is its
space complexity, since the number of the clauses may grow
exponentially even for simple formulas. To alleviate this problem, the
refinement of \dppr algorithm was introduced in 1962 by Davis,
Logemann and Loveland~\cite{DPLL62}.

The Davis--Putnam--Logemann--Loveland \quotegraffito{If you don't know
  where you are going any road can take you there.}{Alice in
  Wonderland} algorithm (\dpll) iterativelly tries to build a
satisfying assignment by deciding values of the propositional
variables and it backtracks if any of the input clauses becomes false
in the current assignment. A key procedure guiding the \dpll search is
the \emph{unit clause rule}, which is based on the observation that if
a formula contains a clause $C$ that is unit in the current
assignment, the only way to build a satisfying assignment is to add
the sole undefined literal of $C$ to $M$. The iterated application of
the unit clause rule is called \emph{unit propagation} or
\emph{Boolean constraint propagation} (\bcp)~\cite{ZM88}. The \dpll
search consists of decision and propagation steps. In decision steps,
a variable and its new value are chosen and added to the current
partial assignment. After each decision step, the \bcp is performed to
set values of variables which are implied by the decision. The
backtracking used in \dpll is \emph{chronological}, i.e. after a
conflict the value of the last decided literal is changed.

%It has been observed that \dpll based solver spends the
%majority of its computation time by doing \bcp steps, a

\subsection{Conflict-Driven Clause Learning}

Although the \dpll algorithm is more efficient than the original \dppr
algorithm, it may unnecessarily explore parts of the search space that
contain no solution. This problem can be partially solved by a further
refinement of the \dpll algorithm called Conflict-Driven Clause
Learning (\cdcl), which was proposed by Marques-Silva and
Sakallah~\cite{MSS99} and is a base of almost all modern \sat
solvers~\cite{KSM11}. In addition to \dpll, \cdcl based \sat solvers
have mechanisms to analyze a conflict and learn a new clause from a
conflicting assignment. Moreover, in contrast to a chronological
backtracking, \cdcl solvers can perform \emph{non-chronological
  backtracking} to an earlier decision literal.

In particular, \cdcl based \sat solvers maintain an \emph{implication
  graph} during the search, which records reasons for assigning the
unit-propagated literals during the search. If a conflict clause is
found, a clause that captures the reason of the conflict is computed
by analyzing the implication graph or, equivalently, by the backwards
resolution process~\cite{BKS04}. After computing the clause $C$ that
explains the conflict, \cdcl based solvers \emph{learn} the clause
$C$, in order not to repeat the similar conflict in the future, and
change the value of the last decision literal that occurs in the
clause $C$. Note that this literal does not have to be the last
decision literal in the search and therefore a bigger region of the
search space can be ruled out from the search, as it is known not to
contain any solutions. There are multiple strategies of computing the
clausal reason for the conflict, but the majority of \cdcl based \sat
solvers are using the \emph{first unique implication point} based
learning scheme, which has been shown to produce small clauses in
practice~\cite{MMZZM01}.

Beside the learning, the efficiency of the most \cdcl based \sat
solvers relies on \emph{branching heuristics}, which select the next
decision variable during the search. Multiple branching heuristics
have been proposed~\cite{BF15branching} and the majority of modern
\sat solver are using \vsids heuristic~\cite{MMZZM01}, which prefers
branching on the variables that have appeared in the biggest number of
recent conflicts. More recently, new branching heuristics based on
learning rate have been proposed and shown to outperform the currently
used \vsids branching heuristic~\cite{LGPC16}.

Another important part of modern \sat solvers are dynamic restarts,
which allow restarting the search from scratch in hope that clauses
learned during the conflict analyses will guide the search from
regions of the search space that contain no
solutions~\cite{GSK98}. Although most commonly used heuristic to
decide when to restart the solver is based on the \emph{Luby
  sequence}~\cite{LSZ93}, the recent survey has shown that it is
outperformed by a heuristic based on the concept of exponential moving
averages~\cite{BF15restarts}.

In addition to the mentioned heuristics, an efficient implementation
of \cdcl based \sat solver relies on lazy data structures used in the
Boolean constraint propagation. This is important because it has been
observed that \sat solvers spend most of the computation time by
performing \bcp. Therefore, most of the modern \sat solvers use
\emph{two-watched literal scheme}~\cite{MMZZM01} to efficiently
identify clauses that have become unit during the search.

The contribution of all mentioned parts of the \cdcl based \sat
solvers to the overall performance of the MiniSAT
solver~\cite{Minisat} has been experimentally evaluated by Katebi,
Sakallah, and Marques-Silva~\cite{KSM11}. The experimental evaluation
shows that the most important from the mentioned techniques is
clause-learning, followed by the \vsids branching heuristic.

\subsection{Other approaches to \sat}
Aside from conflict-driven \sat algorithms, other variants of
approaches to \sat have been proposed. Most notable of those variants
are \emph{symbolic \sat solvers}~\cite{AV01, JS04, PV04, HD04} and
\emph{look-ahead based \sat solvers}~\cite{HM09}.

Symbolic algorithms rely on a compact representation of the set of
satisfying assignments using \emph{Binary Decision Diagrams} (\bdds)
-- a data structure proposed by Bryant to represent Boolean
functions~\cite{Bry86}. In particular, symbolic \sat algorithms are
using Reduced Ordered \bdds, which represent Boolean functions
\emph{canonically} and allow efficiently computing Boolean
combinations of the represented Boolean functions using the recursive
procedure \texttt{Apply}~\cite{Bry86}. The main idea of symbolic \sat
solvers is to convert a \cnf formula to the corresponding \robdd and
check the root of the resulting \bdd. If the resulting \bdd is
equivalent to the \bdd for the constant $0$ function, the formula is
unsatisfiable, and it is satisfiable otherwise. However, in order to
keep the size of the \bdd small, it is necessary to existentially
quantify the variables during the computation. This technique is known
as \emph{early quantification}~\cite{HKB96}. A simplified symbolic
\sat algorithm can be found for example in the survey of \sat solving
by Darwiche and Pipatsriswat~\cite{DP09}.

Look-ahead based algorithm, in contrast to the \cdcl, are employing
expensive heuristics to guide the \dpll search to a satisfying
assignment instead of using cheap heuristics and learning from the
conflicts~\cite{HD04}. Therefore, while \cdcl solvers are efficient on
large industrial formulas, look-ahead-based \sat solvers are efficient
on small hard problems, which require sophisticated
heuristics~\cite{HKWB11}. The strengths of these two approaches were
combined to a technique called \emph{cube-and-conquer}, in which a
look-ahead-based solver is used to partition the formula to many
simpler formulas, which are in turn solved by an efficient \cdcl
solver~\cite{HKWB11}. The cube-and-conquer approach has been shown to
be efficient in practice due to an easy parallelization and has been
recently used to solve a long-standing open problem in the Ramsey
theory~\cite{HKM16}.

\section{Satisfiability modulo theories}
\label{sec:smt}

Similarly to \sat, the \emph{satisfiability modulo theories problem}
(\smt) is to decide for a given a \cnf formula $\varphi$ in a fixed
theory $\mathcal{T}$ whether it is
$\mathcal{T}$-satisfiable. Depending on the theory $\mathcal{T}$, the
complexity of the \smt problem ranges from polynomial to
undecidable. However, as the formula $\varphi$ can contain Boolean
connectives, the \smt problem is at least \NP-hard for non-trivial
theories.

Notable examples of decidable first-order theories include
\begin{itemize}
\item the theory of \emph{equality and uninterpreted functions}, which
  for a given signature contains all structures over this signature
  and therefore imposes no restriction on the interpretation of
  function and predicate symbols;
\item the theory of \emph{linear integer arithmetic} over the
  signature $\{ +, \leq \}$, which consists of all structures
  isomorphic to integers with the function $+$ and the relation
  $\leq$;
\item the theory of \emph{linear real arithmetic} over the signature
  $\{ +, \leq \}$, which consists of all structures isomorphic to real
  numbers with the function $+$ and the relation $\leq$;
\item the theory of \emph{real arithmetic} over the signature
  $\{ +, \times, \leq \}$, which consists of all structures isomorphic
  to real numbers with functions $+$ and $\times$ and the relation
  $\leq$;
\item the theory of \emph{arrays} over the signature
  $\{ \arread, \arwrite \}$, which consists of all structures isomorphic
  to the set of arrays with a binary function $\arread(a, i)$
  interpreted as a value on the index $i$ of the array $a$, and a
  ternary function $\arwrite(a, i, v)$ interpreted as an array $a$
  modified to contain the value $v$ on the index $i$;
\item the theory of \emph{fixed-size bit-vectors}, in which the
  structure contains set of all bit-vectors as an universe, bit-wise
  and arithmetic functions on those bit-vectors, and ordering
  relations on the corresponding integers. This theory is in detail
  described in section \ref{sec:qfbv}.
\end{itemize}
For a detailed description of these theories and implementation of the
respective $\mathcal{T}$-solvers, we refer the reader for example to the book of
Bradley and Manna~\cite{BM07}.

In pracitce, a satisfiability of formulas using a combination of
theories is often needed. For example, a single formula may be using
integers, arrays, and uninterpreted functions. In their seminal work,
Nelson and Oppen have shown that satisfiability of combination of
stably infinite theories with disjoint signatures can be solved by
using separate satisfiability solvers for the respective theories,
which interchange implied equalities and disequalities between shared
variables~\cite{NO79}. A theory $\mathcal{T}$ is \emph{stably
  infinite} if every $\mathcal{T}$-satisfiable formula has a
$\mathcal{T}$-model whose universe is infinite. For a theory over a
many-sorted logic, the theory is \emph{stably infinite} if every
$\mathcal{T}$-satisfiable formula has a model, whose every sort has an
infinite domain. Although almost all practically used theories are
stably infinite, this is not true for inherently finite theories like
the theory of bit-vectors. Therefore, variants of the theory
combination in which one of the theories does not have to be stably
infinite have been proposed~\cite{TZ05, RRZ05, JB10}.

\subsection{DPLL modulo theories}

Most of the \smt approaches can be classified as \emph{eager} or
\emph{lazy}~\cite{BSST09}. In the eager \smt approach, input formula
is directly translated to an equivalent propositional formula and an
off-the-shelf \sat solver is used to decide satisfiability of this
formula. The eager \smt approach is implemented for example in the
\smt solver \uclid for the combination of the theory of uninterpreted
functions and linear integer arithmetic~\cite{LS04}.

On the other hand, the lazy \smt approach uses a \sat solver to reason
about the Boolean structure of the formula and a specialized
$\mathcal{T}$-solver to reason about conjunctions of
$\Sigma$-literals. There are two variants of the lazy approach to the
\smt solving -- \emph{online} and \emph{offline}~\cite{FJOS03}.

\paragraph{Offline approach}
In the offline approach, the input formula $\varphi$ is first
converted to a propositional formula $\varphi^p$ called \emph{Boolean
  abstraction} by treating each atom as a propositional variable and
then a \sat solver is asked to decide satisfiability of
$\varphi^p$. If $\varphi^p$ is unsatisfiable, the input formula
$\varphi$ is also unsatisfiable. On the other hand, if $\varphi^p$ is
satisfiable, the \sat solver returns its propositional model $M^p$,
and the $\mathcal{T}$-solver can be used to determine
$\mathcal{T}$-satisfiability of the corresponding set of
$\Sigma$-literals $M$. If the $\mathcal{T}$-solver decides $M$ to be
$\mathcal{T}$-satisfiable, the formula $\varphi$ is also
$\mathcal{T}$-satisfiable. If the propositional model is not
$\mathcal{T}$-satisfiable, the corresponding theory lemma $\neg M^p$
is added to the formula and the procedure is repeated. This variant of
the lazy \smt approach is called offline, because it uses the \sat
solver as a black box and employs the $\mathcal{T}$-solver only to
check satisfiability of a complete Boolean assignment.

\paragraph{Online approach}
In contrast to the offline approach, the \sat and \smt solvers can
cooperate more tightly, resulting in an online variant of the lazy
\smt approach, which outperforms the offline approach in most of the
cases~\cite{FJOS03}. In the online variant, the \smt solver is used
not only to check validity of total Boolean assignments, but it is
also used to check the validity of partial assignments during the
\dpll search (known as \emph{early pruning}~\cite{ABCKS02}), to assign
values of literals which are $\mathcal{T}$-entailed by the current
assignment (known as \emph{theory propagation}~\cite{ACG99}), and to
provide smaller theory lemmas that explain the conflict. In order for
this combination to be efficient, the $\mathcal{T}$-solver should
provide several important features. Namely, it should be
\emph{incremental}, so it does not restart the computation after every
decided literal, it should be able to provide small theory lemmas
explaining conflicts and theory propagations, so the \sat solver can
backtrack to a relevant decision literal, and it should be able to
efficiently unassign the values of literals during backtracking. In
most of the cases, the $\mathcal{T}$-solver is also required to be
able to provide models for the satisfiable formulas.

This \smt approach, in which the $\mathcal{T}$-solver is used to guide
the search of the underlying \dpll solver has been named
\dpllt~\cite{NOT06}. For the detailed description of \dpllt and
further improvements, we refer the reader to survey on the
topic~\cite{Seb07}, or to the abstract description of the underlying
transition system~\cite{NOT06}. The \dpllt approach is used in the
majority of modern \smt solvers, including solvers
Barcelogic~\cite{Barcelogic}, CVC4~\cite{CVC4},
MathSAT~\cite{MathSAT}, OpenSMT~\cite{OpenSMT},
Simplify~\cite{Simplify}, Yices~\cite{Yices}, and Z3~\cite{Z3}.

\subsection{Natural domain \smt}
\label{ssec:natDomainSat}
Although the separation of the propositional and theory reasoning in
\dpllt allows the solver to be modular, it can be also restricting in
some cases. In particular, \dpllt-based solvers can not directly
reason about values of first-order variables, but have to rely on the
$\mathcal{T}$-solver guiding the search over Boolean valuations. While
there are some techniques like \emph{splitting on
  demand}~\cite{BNOT06} , which allow the $\mathcal{T}$-solver to add
new atoms to the formula and delegate the case splitting to the
underlying \sat solver, their performance depends on the internal
heuristics of the \sat solver. To overcome this issue, Cotton has
proposed \emph{Natural domain \smt} approach, which allows the \smt
solver to reason directly about the natural domains of variables like
integers or reals instead of merely choosing Boolean valuations of
existing literals~\cite{Cot10}. This has led to two main techniques of
\smt solving -- \emph{abstract conflict-driven clause learning} and
\emph{model-constructing satisfiability calculus}~\cite{Mon16}.

\paragraph{Abstract \cdcl} Abstract conflict-driven clause learning
(\acdcl) is based on the lattice-theoretic abstract interpretation
framework of Cusot and Cusot, widely used to reason about properties
of computer programs~\cite{CC79}. In order to reason about a behavior
of the computer program, its semantics is described as a fix point
expression over a \emph{concrete domain} equipped with a set of
\emph{concrete transformers}. An \emph{abstract domain} is then a
lattice equipped with over-approximations or under-approximations of
the concrete transformers, called \emph{abstract transformers}, which
can be used to approximate the set of program behaviors.

In recent years, \cdcl and \dpllt algorithms have been shown to be
instances of the abstract interpretation framework~\cite{SHK13,
  BSHGK13, DHK14}. In this setting, the concrete domain contains all
structures and is equipped with a \emph{model transformer}, computing
all models, and a \emph{conflict transformer}, computing all
counter-models. The satisfiability problem is then to compute whether
the greatest fixed point of the model transformer is different from
$\bot$. In the \cdcl algorithm, an abstract domain is then a lattice
of partial assignments, the unit propagation rule is an
over-approximation of the model transformer, \bcp is a greatest fixed
point computation of this abstract model transformer, decisions are
downward extrapolations, and a conflict analysis corresponds to
computing an under-approximation of the conflict transformer. Further,
clause learning can be seen as learning of a new transformer, which is
computed by the conflict analysis.

In thus specified framework, an abstract domain can be replaced by an
arbitrary domain that satisfies a certain set of requirements and this
yields an abstract conflict-driven clause learning \acdcl algorithm
using this particular domain. For example, Brain et al. have
implemented the \fpacdcl solver for the floating point arithmetic
using an abstract interval domain and have shown that on a certain
class of formulas it significantly outperforms state-of the art \smt
solvers based on the encoding floating point numbers into
bit-vectors~\cite{BSGHK14}.

\paragraph{Model-constructing satisfiability calculus} The other
approach to the natural \smt solving is the model-constructing
satisfiability calculus (\mcsat), proposed by de Moura and
Jovanović~\cite{MJ13, JMB13}. \mcsat is based on the \dpll style
search, but in addition to assigning values of Boolean variables, it
can assign the value of theory variables and it can generate new
literals not occurring in the original formula. De Moura et al. have
implemented the \mcsat solver supporting linear real arithmetic and
uninterpreted functions, which uses model-driven Fourier-Motzkin
elimination~\cite{Dan63} to learn new predicates from arithmetic
conflicts and model-driven Ackermannization~\cite{MB08, Ack54} to
learn new predicates from conflicts involving uninterpreted
functions. This solver has been shown to have performance comparable
with existing state-of-the-art \dpllt solvers~\cite{JMB13}.

%\subsection{Combination of theories}

\subsection{Additional features of \smt solvers}
Aside from using models for satisfiable formulas, algorithms using
\sat and \smt-based solvers often rely on additional features of
solvers. For example, several efficient formal verification algorithms
are using solvers' ability to provide small \emph{unsatisfiable cores}
for unsatisfiable formulas, or to compute \emph{Craig
  interpolants}~\cite{McM06, UltimateInterpol13, UltimateCores14}.

In the context of \sat and \smt solving, an unsatisfiable core is a
subset of clauses of an unsatisfiable formula that is already
unsatisfiable~\cite{CGS07}. Three main approaches are used for the
unsatisfiable core computation in \smt~\cite{BSST09}. In the first, if
a solver can compute resolution proofs for unsatisfiable formulas, the
clauses that occur in the proof can be returned as an unsatisfiable
core. In the second approach each clause can be represented by a fresh
selector variable and after a top level conflict, clauses whose
selector variable appears in the final conflict clause are returned as
an unsatisfiable core. Third approach consists in combination of an
\smt solver with an external propositional core
extractor~\cite{CGS07}.

A (Craig) interpolant for a pair of formulas $F$ and $G$ such that
$F \wedge G$ is unsatisfiable is a formula $I$ such that
$F \models_T I$, $G \wedge I$ is unsatisfiable, and all uninterpreted
symbols in $I$ are contained in both $F$ and $G$. Following the work
of Pudlák~\cite{Pud97} and McMillan~\cite{McM05}, an interpolant for
the pair $(F, G)$ over the theory $\mathcal{T}$ can be computed from a
resolution proof of unsatisfiability of $F \wedge G$ by using a
combination of a propositional interpolating algorithm and a theory
specific interpolation procedure, which computes interpolants of
theory lemmas. Such interpolation algorithms exist for linear real
arithmetic~\cite{CHN12}, linear integer arithmetic~\cite{KLR10, GLS11,
  BKRW11, CHN12} or quantified linear integer arithmetic with arrays
and uninterpreted functions~\cite{McM11}.

\section{Satisfiability of quantifier-free bit-vector formulas}
\label{sec:qfbv}

The \emph{theory of fixed sized bit-vectors (\BV)} is a many-sorted
first-order theory with infinitely many sorts $\sort{n}$ corresponding
to bit-vectors of length $n$. The only predicate symbols in the \BV
theory are $\leq_u$ and $\leq_s$, interpreted as inequality of
binary-encoded unsigned and signed integers, respectively. Function
symbols in the theory are $+$, $\times$, $\div$, $\&$, $\mid$,
$\oplus$, $\ll$, $\gg$, $\cdot$, $\extract{n}{p}$, interpreted as
addition, multiplication, unsigned division, bit-wise and, bit-wise
or, bit-wise exclusive or, left-shift, right-shift, concatenation, and
extraction of $n$ bits starting from the position $p$,
respectively. For the detailed description of the \BV theory syntax
and semantics, see for example Hadarean's PhD
thesis~\cite{Had15}. This section focuses on the problem of
satisfiability of the quantifier-free fragment of the \BV theory,
denoted \QFBV. The the full \BV logic is treated in the next section.

Current state-of-the-art \smt solvers for the \QFBV logic rely on
rewriting techniques used to simplify the formula during the
preprocessing, and eager or lazy translation of the bit-vector formula
to the equivalent propositional formula, which is subsequently solved
by a \sat solver. The transformation of a bit-vector formula to the
equivalent propositional formula is traditionally called
\emph{bit-blasting}~\cite{Kro08}. More lazy approach to the
bit-blasting is beneficial when the theory combination is
required. For example, solvers Z3 and Yices apply bit-blasting to all
operations except for the equality, which is handled by a specialized
solver, and dynamically add axioms of the array
theory~\cite{Z3,Yices}. Boolector applies bit-blasting to the
bit-vector operations and lazily instantiates definitions of macros
and array axioms~\cite{Boolector}. Furthermore, CVC4 uses lazy and
layered solver, which tries to decide the satisfiability using
possibly faster but incomplete sub-solvers for equality and inequality
reasoning and if the sub-solvers are not sufficient for deciding the
satisfiability of the formula, theory lemmas and propagated literals
generated by the sub-solvers are added to the formula and a lazy
\dpllt bit-blasting solver is employed~\cite{HBJBT14}.

\subsection{Word-level techniques}
Although bit-blasting is highly efficient for most of practical
problems, it can exhaust memory of the solver if the input formula
contains complex arithmetic or variables with large bit-width. Several
techniques that avoid the bit-blasting and work directly on the level
of individual bit-vectors (\emph{word level}) have been proposed to
alleviate this problem.

Some useful fragments of the bit-vector theory can be solved by
specialized algorithms for deciding satisfiability. For example,
conjunctions of literals in the \emph{core theory of bit-vectors}
consisting of equality, concatenation and extraction, are decidable in
polynomial time by reduction to the theory of equality~\cite{CMR97,
  BS09}. Additionally, Babić and Musuvathi have described algorithms
for solving linear and non-linear modular arithmetic, which can be
used for deciding satisfiability of bit-vector formulas that contain
only arithmetic and no bit-wise operations~\cite{BM05}.

Recently, an instance of the model-constructing satisfiability
calculus, which was introduced in subsection \ref{ssec:natDomainSat},
was implemented by Zeljić et al. in the solver
\mcbv~\cite{ZWR16}. Zeljić et al. have extended the \mcsat framework
by the ability to perform partial assignments and have proposed
heuristics for generalizing explanations of bit-vector conflicts. For
example, the solver \mcsat can perform the partial assignment
$\extract{2}{0}(x) \mapsto 10$, denoting that the two least
significant bits of $x$ are $10$. To be able to efficiently use such
partial assignments, the solver \mcbv maintains two
over-approximations of the set of models that are compatible with the
current partial assignment -- using \emph{bit-patterns} and
\emph{arithmetic intervals}. Bit-patterns are sequences of $0$, $1$
and $u$ (represents undefined bit), which constrain the values of
particular bits in the assignment. On the other hand, arithmetic
intervals are pairs of bit-vector values representing lower and upper
bounds and constrain integral values of bit-vectors. Both bit-patterns
and arithmetic intervals can be ordered to form a lattice in which the
solver performs a search for a more general explanation if a conflict
is detected.

Another word-level approach for the full bit-vector theory is
\emph{stochastic local search} (\sls), proposed for solving
bit-vectors by Fröhlich et al.~\cite{FBWH15} and subsequently improved
by Niemetz et al.~\cite{NPBF15,NPB16}. In the \sls approach, the
solver randomly chooses initial values of bit-vector variables and
tries to find a satisfying assignment by performing random bit flips,
which are guided by the scoring function based on the satisfaction of
subformulas of the input formula. Niemetz et al. have improved the
\sls technique with the \emph{path-based propagation}, which, instead
of relying solely on random bit modifications guided by the scoring
function, allows computing values of bit-vector variables that are
necessary to satisfy randomly selected subformulas. The \sls based
solver has been shown to be able to decide several formulas not
decided by bit-blasting solvers. To combine benefit of bit-blasting
and \sls approaches, the latest version of Boolector, which have won
the 2016 SMT competition in the category of quantifier-free
bit-vectors, uses a portfolio approach, which consists in first
running a \sls based solver for a short period of time and then
running a bit-blasting solver if the \sls solver fails to solve the
formula~\cite{BoolectorComp}.

\subsection{Preprocessing}
For both bit-blasting and word-level approaches, a preprocessing of
the input formula is crucial for the efficiency of the
solver. Therefore, modern \smt solvers employ hundreds of rewrite
rules in order to simplify the input formula~\cite{Fra10}. Franzén
describes several classes of simplification methods implemented in the
solver MathSAT5: canonization, unconstrained variables propagation,
packet splitting, and disjunctive partitioning~\cite{Fra10}.

The aim of the \emph{canonization} is converting subterms of the
formula to their canonical forms. For example, the term $x - x$ can be
rewritten to $0$. Although efficient algorithms exist for several
fragments of the \BV theory, like the core theory of bit-vectors, the
problem of computing the canonical form for the full \BV theory is
NP-hard~\cite{BDL98}. Therefore, SMT solvers usually do not compute
the canonical form, but rely on multiple heuristically chosen rewrite
rules that produce the canonical form for simple terms, but are not
required to produce the canonical form of all terms.

From the remaining simplification techniques presented by Franzén, we
focus on propagation of unconstrained variables, as it is highly
relevant for software verification.

A variable $x$ in a formula is called \emph{unconstrained} if it
occurs only once in the formula. Brummayer~\cite{Brum10} and
Bruttomesso~\cite{Bru08} have independently observed that if an
unconstrained variable occurs as an argument to a function symbol that
can be \emph{inverted} with respect to this argument, replacing this
function with a fresh variable yields an equisatisfiable
formula. Moreover, unconstrained variables often occur in the
industrial benchmarks and especially in benchmarks produced during a
verification of programs in a single static assignment form, such as
LLVM bit-code.

With a slight abuse of notation which identifies function symbols with
their intended interpretations, a simple definition of invertibility
for binary function symbols is as follows. A binary function $f$ can
be inverted with respect to its first argument if for every two values
$a_i, a_o$ there exists a value $b$ such that $f(b,a_i) = a_o$. This
definition can be easily generalized to functions of different
arities. For example, as the addition is invertible with respect to
its first argument, the formula
$\varphi \equiv x + (y * y - 30 * z * y) = 0$ can be transformed to an
equisatisfiable formula $v = 0$, where $v$ is a fresh variable,
because $x$ is unconstrained in $\varphi$. Note that in contrast to
the theory of integers, the function $f(x) = k \times x$ is invertible
in bit-vectors precisely if $k$ is odd.

\section{Satisfiability of quantified bit-vector formulas}
\label{sec:bv}

Although the bit-vector theory admits quantifier elimination by
expanding all quantifiers with all possible bit-vector values of the
corresponding bit-width, this is rarely a practical approach. Instead,
the formula is usually converted to an equisatisfiable formula by
Skolemization and then instances of the universally quantified
formulas are lazily added to the formula until a model is found or the
formula is found to be unsatisfiable by a \QFBV solver. There are
multiple ways to choose quantifier instances that are sufficient to
decide the satisfiability of the formula. For the bit-vector theory,
the most widely used approach is the \emph{model-based quantifier
  instantiation}~\cite{GM09}, implemented in Z3, CVC4, and Yices,
combined with heuristics as \emph{E-matching} or \emph{symbolic
  quantifier instantiation}~\cite{WHD13,Dut15}. Additionally, for
dealing with quantifiers, CVC4 supports solving quantified formulas by
\emph{counter-example guided quantifier instantiation}~\cite{RDKT15}.
% and \emph{finite model finding}~\cite{RTG13}.
We describe only the model-based quantifier instantiation in detail,
as the counter-example guided quantifier instantiation considers all
functions as uninterpreted during the conflict search, and therefore
its performance on bit-vector formulas is limited.

\subsection{Model-based quantifier instantiation}
Given a closed formula with quantifiers, the first step is to convert
the formula to the negation normal form and apply Skolemization to
obtain equisatisfiable formula of the form
\[
   \varphi ~\wedge~ \forall x_1, x_2, \dots, x_n\, (\psi[x_1, \dots, x_n]),
\]
where $\varphi$ and $\psi$ are quantifier-free formulas. Then the
\QFBV solver is invoked to check the satisfiability of the formula
$\varphi$. If $\varphi$ is unsatisfiable, then the entire formula is
unsatisfiable. If $\varphi$ is satisfiable, the \QFBV solver returns
its model $M$ and another call to the \QFBV solver is made to
determine whether $M$ is also a~model of
$\forall x_1, x_2, \dots, x_n \, (\psi)$. This is achieved by asking
the solver whether the formula $\neg \widehat{\psi}$ is satisfiable,
where $\widehat{\psi}$ is the formula $\psi$ after substituting values
of all variables except for $x_1 \ldots x_n$ and uninterpreted
functions replaced by their values in $M$. If $\neg \widehat{\psi}$ is
not satisfiable, then the structure $M$ is indeed a model of the
formula $\forall x_1, x_2, \dots, x_n\,(\psi)$, therefore the entire
formula is satisfiable and $M$ is its model. If $\neg \widehat{\psi}$
is satisfiable, we get values $v_1, \dots, v_n$ such that
$\neg\widehat{\psi}[v_1, \dots, v_n]$ holds. To rule out $M$ as a
model of the input formula, the instance $\psi[v_1, \dots, v_n]$ of
the quantified formula is added to the quantifier-free part, i.e.~the
formula $\varphi$ is modified to
\[
   \varphi' ~\equiv~ \varphi \wedge \psi[v_1, \dots, v_n],
\]
and the procedure is repeated.

\begin{exmp} Consider the formula
  % \[
  %   3 < a ~\wedge~ \forall x\,(\neg (a = 2 \times x)).
  % \]
  $3 < a ~\wedge~ \forall x\,(\neg (a = 2 \times x))$.  The subformula
  $3 < a$ is satisfiable and $a = 4$ is its model. However, it is not
  a model of the formula $\forall x \,(\neg (a = 2 \times x))$, since
  the \QFBV solver called on the formula
  $\neg (\neg (4 = 2 \times x))$ returns $x = 2$ as a model.
  %
  The next step is to decide the satisfiability of the formula
  $3 < a ~\wedge~ \neg (a = 2 \times 2)$. This formula is satisfiable
  and $a = 5$ is its model. Moreover, it is also a model of
  $\forall x \,(\neg (a = 2 \times x))$ as %, because the formula
  $\neg (\neg (5 = 2 \times x))$ is unsatisfiable. Hence, the input
  formula is satisfiable and $a = 5$ is its model.
\end{exmp}

This algorithm is trivially terminating, since there is only a finite
number of distinct models $M$ of $\varphi$. However, in some cases
exponentially many such models have to be ruled out before the solver
is able to find a correct model or decide unsatisfiability of the
whole formula. To overcome this issue, state-of-the-art \smt solvers
do not use just instances of the form $\psi[v_1, \dots, v_n]$ with
concrete values, but employ mentioned heuristics such as E-matching or
symbolic quantifier instantiation to choose instances with ground
terms that can potentially rule out more spurious models and thus
significantly reduce the number of iterations of the algorithm. In
practice, suitable ground terms substituted for quantified variables
are selected only from subterms of the input formula.

Note that Skolemization introduces uninterpreted functions to the
quantified formulas of form other than
$\exists^*\forall^*\varphi$. This class of formulas is usually called
\emph{exists/forall}, or simply $\exists\forall$. Therefore, for the
model-based quantifier instantiation approach to be usable for
formulas not from the exists/forall class, the underlying \QFBV solver
has to support reasoning about uninterpreted functions. In case of Z3,
this is achieved by \emph{template-based model finding} --
uninterpreted functions are assigned templates and the \QFBV solver is
used to find satisfying parameters of these templates. For example, an
uninterpreted function $f$ may be assigned a template for linear
functions $f(x) = ax + b$ and finding a satisfying function $f$
reduces to finding values $a$ and $b$.


\section{Computational complexity of bit-vector logics}
\label{sec:complexity}
The propositional satisfiability problem is well known from the
computational complexity perspective, as it is the first problem that
was shown to be \NP-complete. The complexity of the satisfiability
problems for various variants of bit-vector theory have been recently
studied and was shown to range from \NP-complete to
\NNEXPTIME-complete~\cite{KFB16}. In particular, interesting variants
of the bit-vector satisfiability problem differ in allowing
uninterpreted functions, allowing quantifiers, and in encoding of the
bit-widths (unary vs. binary). In the following, we follow the
notation of Kováznai et al.~\cite{KFB16} -- decision problems for
quantifier-free fragments are denoted by the prefix QF\_, the
combination with the theory of uninterpreted functions is denoted by
the prefix UF, and the problems with unary and binary encoded
bit-widths are denoted by suffixes 1 and 2, respectively. For example,
QF\_UFBV2 is the decision problem for quantifier-free formulas with
uninterpreted functions and binary encoded bit-widths. The completeness
results for these classes are summarized in table
\ref{tbl:complexity}, and briefly explained in the rest of this section.

\begin{table}
\checkoddpage
\edef\side{\ifoddpage l\else r\fi}
\makebox[\textwidth][\side]{
\begin{minipage}[bt]{\fullwidth}
  \begin{center}
    \setlength{\tabcolsep}{0.6em}
    \begin{tabularx}{\textwidth}{l l l l X l r}
      \toprule
      & & \multicolumn{5}{c}{Quantifiers} \\
      \cmidrule(l){3-7}
      & & \multicolumn{2}{c}{No} & & \multicolumn{2}{c}{Yes} \\
      \cmidrule(l){3-4}
      \cmidrule(l){6-7}
      & & \multicolumn{2}{c}{Uninterpreted functions} & & \multicolumn{2}{c}{Uninterpreted functions} \\
      & & \multicolumn{1}{c}{No} & \multicolumn{1}{c}{Yes} & & \multicolumn{1}{c}{No} & \multicolumn{1}{c}{Yes} \\
      \midrule
      \multirow{2}{*}{Encoding~} & Unary & \NP & \NP & & \PSPACE & \NEXPTIME \\
       & Binary\hspace{2em} & \NEXPTIME & \NEXPTIME & & ? & \NNEXPTIME \\
      \bottomrule
    \end{tabularx}
  \end{center}
  \caption{Completeness results for various bit-vector logics and encodings~\cite{FKB13}.}
  \label{tbl:complexity}
\end{minipage}}
\end{table}

\paragraph{Unary encoded bit-widths} The bit-blasting yields a
polynomial time reduction from QF\_BV1 to \sat, showing that QF\_BV1
is in NP. A similar reduction from BV1 to \qbf can show that BV is in
\PSPACE. For lower bounds, \NP-hardness of QF\_BV1 follows from a
simple reduction from \sat by encoding each propositional variable as
a bit-vector of bit-width 1. Similarly, BV1 can be shown to be
\PSPACE-hard by considering every bit-vector as a quantified variable
of bit-width 1.

In quantifier-free formulas, uninterpreted functions can be eliminated
by the Ackermann expansion with only quadratic increase in the size of
the formula. Therefore, QF\_UFBV1 is in \NP. As the set of QF\_UFBV1
formulas contains all QF\_BV1 formulas, QF\_UFBV1 is also NP-hard. The
case of UFBV1 is more involved. Wintersteiger et al. have shown that
UFBV1 is \NEXPTIME-complete by using \emph{effectively propositional}
fragment of the first-order logic, which is well known to be
\NEXPTIME-complete~\cite{WHD13}. The class of effectively
\marginpar{The class of effectively propositional formulas is also
  known as the Bernays--Schönfinkel class.} propositional formulas
consists only of formulas in the form $\exists^*\forall^*\varphi$,
where $\varphi$ does not contain any quantifiers or function symbols.

\paragraph{Binary encoded bit-widths}
For formulas with binary encoded bit-widths, the bit-blasting may
yield propositional formula that is exponentially larger than the
original input bit-vector formula, as the number of bits may be
exponential with respect to the size of the formula. Therefore,
bit-blasting shows that QF\_BV2 is in \NEXPTIME. On the other hand,
Kovásznai et al. have presented a polynomial time reduction of
satisfiability of \emph{dependent quantified Boolean formulas} (\dqbf)
to QF\_BV2. In contrast to \qbf, \dqbf formulas allow explicitly
stating on which variables can a quantified variable depend. Since
\dqbf is well known to be \NEXPTIME-complete, this reduction shows
\NEXPTIME-hardness of QF\_BV2~\cite{KFB12}. In contrast, the precise
complexity after adding quantifiers is not known. BV2 is known to be
in \EXPSPACE and because it contains all formulas from QF\_BV2, it is
also \NEXPTIME-hard.

Similarly to the case with the unary encoding, the complexity of the
quantifier-free fragment stays the same when the uninterpreted
functions are added -- QF\_UFBV2 can be shown to be in \NEXPTIME by
the Ackermann reduction and \NEXPTIME-hard by the simple reduction
from QF\_BV2. The complexity of the problem after adding quantifiers
and uninterpreted functions was investigated by Kovásznai et
al.~\cite{KFB12}. Reencoding of all bit-widths to unary shows that
UFBV2 is in \NNEXPTIME. For the lower bound, Kovásznai et al. present
a reduction of an instance of a \emph{domino tiling
  problem}~\cite{Chl84} that is known to be \NNEXPTIME-hard.

%*****************************************j
%*****************************************
%*****************************************
%*****************************************
%*****************************************

%%% Local Variables:
%%% mode: latex
%%% TeX-master: "../ClassicThesis"
%%% End:
