modern sat - solvers are famously efficient for solving the decision problem of satisfiability of propositional formulas , and we may wonder whether the ideas used in sat - solvers could be generalized to the first - order case .this paper addresses this question from a purely proof - theoretical perspective .we briefly recall the first - order resolution calculus ( in section [ sec : resolution ] ) , which is the theoretical foundation for many current state - of - the - art first - order theorem provers ( e.g. ) , and the dpll and cdcl procedures used by sat - solvers ( in section [ sec : dpllcdcl ] ) .the main contribution of this paper ( presented in section [ sec : uprcl ] ) is the _ conflict resolution _* cr*. it extends the first - order resolution calculus with _ decision literals _ and a new inference rule for _ clause learning _ and restricts the resolution rule in order to force it to behave like _unit propagation_. as discussed in subsection [ sec : isomorphism ] , a certain subclass of * cr*derivations is isomorphic to the abstract data structure known as _ conflict graphs _ or _ implication graphs _ and widely used to describe the procedures of modern sat - solvers .furthermore , as shown in section [ sec : splitting ] , whereas the _ splitting _ technique used by modern first - order provers must either be handled at an extra - logical level or lead to an unacceptable increase in proof size if simulated in the resolution calculus , its simulation by * cr * s decisions and clause learning is lean and straightforward .therefore , the new * cr*calculus provides a more adequate proof - theoretical foundation for procedures currently implemented by sat - solvers and first - order provers .  in * cr * , it becomes evident that decision literals are analogous to assumptions in natural deduction , whereas clause learning resembles natural deduction s implication introduction rule .this fact is crucial for the proof of soundness of* cr*(shown in section [ sec : soundness ] ) and it illustrates an insightful novelty of the calculus : while the resolution inference proposed by robinson ( ) can be regarded as a first - order generalization of modus ponens ( a.k.a .natural deduction s implication _ elimination _ ) by taking unification into account , the clause learning rule proposed here ( and inspired by the propositional cdcl technique ) can be considered a first - order generalization of implication _ introduction _ , as it discharges decision literals in a way that allows for unification .any resolution refutation can be translated into a refutation in the proposed calculus .therefore , * cr * s refutational completeness follows easily from the refutational completeness of the resolution calculus ( as demonstrated in section [ sec : completeness ] ) .a main motivation for the development of the conflict resolution calculus was that it might eventually serve as a theoretical common ground for existing first - order provers that try to harness or mimic the power of sat - solvers ( cf .section [ sec : relatedwork ] ) ) or as a starting point for the development of new provers , in the same way that the pure resolution calculus provided the basic foundation for several generations of automated theorem provers in the last decades . to achieve this goal ,the calculus is presented in a general way , avoiding premature optimizations and refinements , so that future work may easily build on it and explore various proof search strategies and implementation techniques ._ clauses _ ( denoted , possibly subscripted ) are disjunctions of literals . a _literal _ is either an atom or a negated atom , and an _ atom _ is a -ary predicate ( denoted or ) applied to terms .a _ term _ is either a constant ( denoted or ) , a variable ( denoted , , or ) or an -ary function ( denoted or ) applied to terms . variables in a clause are assumed to be implicitly universally quantified .a clause having a single literal is called _unit_. if is a literal , denotes its dual ( i.e. and ) .the nullary atoms ( _ verum _ ) and ( _ falsum _ ) have special meanings characterized by the following equations : and .all inference rules operating on clauses are assumed to be modulo disjunction s associativity and commutativity , modulo negation s involutivity and modulo the equations for and .the empty clause is logically equivalent to the clause containing only .therefore , slightly abusing notation , it is denoted by .substitutions ( denoted by , possibly sub- and superscripted ) are assumed to implicitly avoid variable capture .the empty ( i.e. identity ) substitution is denoted .the inference rules of the resolution calculus are shown in fig .[ fig : resolution ] . a resolution _proof _ of a clause from a set of clauses is a directed acyclic graph ( dag ) where leaves ( i.e. input nodes ) are clauses from , internal nodes are obtained from their parents through application of the inference rules and the sink node is the clause .a resolution _ refutation _ of a set of clauses is a proof of the empty clause ( denoted ) from .it is assumed that distinct input clauses do not share variables .furthermore , the inference rules implicitly generate fresh symbols for variables , thereby maintaining the invariant that distinct clauses do not share variables .proof dags are sometimes displayed as a collection of trees according to the following convention : nodes used as premises more than once are given names ( e.g. , or ) when they are used for the first time , and the names are used to refer to the nodes whenever they are used again . by naming and referring , wide proof trees can also be broken down in smaller displayable parts .consider a proof with the following non - tree form :    it can be displayed as the single tree with names and references below , where the second ( rightmost ) occurrence of the name is to be understood as a reference to the node named by the first ( leftmost ) occurrence of :  or it can also be displayed as the following forest , where the two occurrences of the name in the lower tree are to be understood as references to the node named in the upper tree :  given a set of clauses , a resolution prover exhaustively applies the inference rules , generating more and more clauses .if the initial clause set is unsatisfiable and a fair clause / rule selection strategy is used , the empty clause is eventually derived , because resolution is refutationally complete . if the set is satisfiable , the prover will either never terminate or will terminate in a state where the set of initial and derived clauses is saturated with respect to redundancy criteria ( i.e. only redundant clauses would still be derivable ) ( cf .  ) .one practical problem in this saturation approach is the vast number of clauses that are generated .this led to research on refinements of the resolution calculus , aiming at restricting the inference rules in order to generate fewer clauses , and on efficient ways to detect and delete redundant ( e.g. subsumed ) clauses .these efforts culminated in the _ _ superposition _ _ calculus , which extends the resolution calculus with a paramodulation rule for equality reasoning and refines it with ordering restrictions on terms and literals .  *resolution : * {(\gamma \vee\delta)~\sigma}{\gamma \vee \ell & \dual{\ell ' } \vee \delta}\ ] ]  where is a unifier of and .  * factoring : * {(\ell \vee \ell'_1 \vee \ldots \vee \ell'_m)~\sigma}{\ell_1 \vee \ldots \vee \ell_n \vee \ell'_1 \vee \ldots \vee \ell'_m}\ ] ]  where is a unifier of ,  and , for any .another practical problem is that the resolvent of a clause with literals and another clause with literals has literals .when iterated , this results in very long clauses and , consequently , a loss of efficiency .this practical problem has been solved with a technique known as _ splitting _ : if the current set of clauses is and the sets of variables of are mutually disjoint , then we can split the long clause into its variable - disjoint components and the clause set into the sets ( for ) .the disjointness of the sets of variables ensures that we can check the unsatisfiability of each resulting clause set independently : is unsatisfiable iff is unsatisfiable for every variable - disjoint component .  from a proof - theoretical perspective, splitting resembles the -rule of free - variable tableaux .therefore , superposition provers that implement splitting can be seen as hybrids combining resolution / superposition and tableaux .up to now , however , there has been no single pure proof system capable of characterizing what is going on inside a modern state - of - the - art first - order theorem prover .this gap between theory and practice is something that can be remedied with the adoption of the * cr*calculus proposed here ( cf . section [ sec : splitting ] ) .in the propositional case , davis , logemann and loveland had already noticed that the propositional resolution rule `` can easily increase the number and the lengths of the clauses '' and proposed to replace it by a form of splitting , which is , however , different from the later notion of splitting described in section [ sec : resolution ] . instead of splitting a clause into variable - disjoint components , we select a propositional atom and split the problem in two subproblems : one where is assumed to be true and the other where it is assumed to be false . nowadays ,the so - called dpll procedure is presented slightly differently , but equivalently .we _ decide _ to assign the truth value ` true ` ( or ` false ` ) to an atom ; then , through _ unit propagation _ , other atoms will be assigned truth values as well . repeating this process of decisions and propagations , we will either reach an assignment that satisfies all clauses ( if the clause set is satisfiable ) or we will reach a _ conflict _ where we are to assign both ` true ` and ` false ` to an atom . in the latter case , we backtrack some of our decisions , and try different assignments .in contrast to saturation - based theorem proving , dpll - based sat - solving does not generate any clause at all .but this is , of course , dependent on the fact that in propositional logic it suffices to consider only two truth - value assignments for each atom . in a nave adaptation of this ideato first - order logic , on the other hand , we would need to consider truth - value assignments for each instance of an atom containing variables .we would need to generate possibly several instances .  in practice, it has been found that it is , nevertheless , beneficial to generate _ some _ clauses when backtracking from conflicts .for example , suppose that the backtracking dppl procedure decided to assign ` true ` to and , and this led to a conflict .it is then forced to backtrack these decisions and try other decisions . without clause learning, it could happen that , after assigning truth values to other atoms , it would again consider the possibility of assigning ` true ` to and , even though it is clear ( from the previous conflict ) that and can not be both ` true ` , independently of later assignments to other atoms . to prevent this from happening , we can generate and add the clause to the set of clauses . then, whenever the procedure retries assigning , for instance , ` true ` to it will immediately conclude ( by unit propagation ) that ` false ` should be assigned to .this idea is known as _ conflict - driven clause learning_.  the procedure up to a conflict can be understood as the construction of a directed graph .nodes are literals which have been assigned ` true ` . a _ decision literal _( i.e. a literal with truth value assigned by decision ) has no incoming edge .a _ propagated literal _( i.e. a literal with truth value assigned by unit propagation ) has incoming edges for iff the clause was the clause used by unit propagation to assign a truth value to .a conflict is indicated by the simultaneous presence of any literal and its dual in the graph .when a conflict is detected , the graph can be analyzed to determine clauses that should be learned .various conflict analysis algorithms exist .the conceptually simplest one recommends learning a clause that is a disjunction of the negations of the decision literals .more sophisticated algorithms are capable of learning stronger clauses .an important benefit of conflict - driven clause learning is that redundant ( i.e. subsumed ) clauses are never derived .the learned clause can be derived by a sequence of resolution steps using the clauses corresponding to the edges in the graph as premises .when this is done , a sat - solver is capable of outputting a propositional resolution refutation for an unsatisfiable clause set .however , most developers of sat - solvers consider the overhead ( in both proving time and memory consumption ) of doing so unacceptable , especially when advanced techniques for minimizing learned clauses are used . instead, they prefer to generate proof certificates in the drup or drat formats , which record clauses that have been learned , but do not inform which premises are needed to derive them .a consequence of this lack of information is that checking a drup / drat certificate or converting it to a resolution refutation ( using the drat - trim tool ) can take as long as solving the problem in the first place .[ example : conflictgraphs ] consider the clause set . deciding and propagating units results in the conflict graph at the left side below .we backtrack and learn the unit clause , whose propagation leads to the conflict graph in the right side below . since this last conflict does not depend on any decision literal , no backtracking is possible , and we may conclude that the clause set is unsatisfiable .the resolution proof extracted from the first conflict graph is :  the resolution proof extracted from the second conflict graph is :as we have seen in the previous two sections , both propositional and first - order automated deduction have progressed ( in different ways ) much beyond their historical common roots in resolution .techniques such as splitting , conflict graphs and conflict - driven clause learning are not so easily explained in terms of a pure resolution calculus .there is a growing gap between the current state - of - the - art in automated deduction and its original proof - theoretical foundation . in this section ,we propose the * cr*calculus , which modifies the first - order resolution calculus by incorporating ideas from sat - solving , in an attempt to reduce not only the gap between automated deduction and proof theory but also between the first - order and the propositional cases .  as in resolution ,a * cr*__derivation _ _ is a directed acyclic graph where nodes are clauses and internal nodes are obtained from their parents by one of the inference rules shown in fig .[ fig : uprcl ] .the _ conflict _ rule is just a restriction of the resolution rule .the _ _ unit - propagating resolution _ _ rule is essentially a sequence of applications of the resolution rule where the left premises must always be unit clauses ; the conclusion clause must be unit as well , and its literal is called a _ propagated literal_.  the main innovation lies in the _ conflict - driven clause learning _ rule .the literals within brackets are the _ decision literals _ that have been assumed .the superscript index indicates that this assumption is discharged by the inference with index .it is not required that a inference discharge all decision literals above it .some decision literals may be left undischarged , to be discharged by future inferences .the vertical dots denote any derivation of using the decision literals , input clauses and previously derived clauses .the conclusion clause of this rule is the _ learned clause_. in contrast to the propositional case, the learned clause must be a disjunction of negations of _ instances _ of the discharged decision literals , because variables occurring in the discharged decision literals may be instantiated by unifications performed during the proof .since the derivation of need not be tree - like , we may need to consider several instances of each decision literal .a * cr*derivation is a * cr*__proof _ _ iff all its decision literals have been discharged .a * cr*__refutation _ _ is a * cr*proof of .* unit - propagating resolution : * {\ell~\sigma}{\ell_1 & \ldots & \ell_n & \dual{\ell'_1 } \vee \ldots \vee \dual{\ell'_n } \vee \ell}\ ] ]  where is a unifier of and , for all .* conflict : * {\bot}{\ell & \dual{\ell'}}\ ] ]  where is a unifier of and , for all .* conflict - driven clause learning : * { ( \dual{\ell_1 } \sigma^1_1 \vee \ldots \vee \dual{\ell_1 } \sigma^1_{m_1 } ) \vee \ldots \vee ( \dual{\ell_n } \sigma^n_1 \vee \ldots \vee \dual{\ell_n } \sigma^n_{m_n } ) } { \infer*{\bot}{\infer*[(\sigma_1 ^ 1,\ldots,\sigma_{m_1}^1)]{}{[\ell_1]^{i_1 } } &  & \infer*[(\sigma_1^n,\ldots,\sigma_{m_n}^n)]{}{[\ell_n]^{i_n } } } } \ ] ]  where ( for and ) is the composition of all substitutions used on the -th path from to .resolution s _ factoring _ rule can be simulated by a sequence of decisions , one unit - propagation , one conflict and one conflict - driven clause learning . in this way , we can prove the following lemma .resolution s factoring rule is admissible in * cr*.  let be a * cr*derivation of and consider constructing by applying the factoring inference to the conclusion of , as shown below : {(\ell \vee \ell'_1 \vee \ldots \vee\ell'_m)~\sigma}{\infer*[\varphi']{\ell_1 \vee \ldots \vee \ell_n \vee \ell'_1 \vee \ldots \vee \ell'_m } { } } \ ] ] this is admissible because , instead of using the factoring inference , we could have used a sequence of * cr*inferences , as shown in fig . [ fig : factoringadmissibility ] . { ( \ell \vee \ell'_1 \vee \ldots\vee \ell'_m)~\sigma } {   \infer[{\mathbf{c}(\varepsilon)}]{\bot }   {     \infer[{\mathbf{u}(\sigma)}]{\ell'_m~\sigma }     {       \psi : [ \dual{\ell}]^{1_1 }       &       \overbrace{\psi \quad \ldots \quad \psi}^{n-1 \ \mathrm{times } }       &        [ \dual{\ell'_1}]^{1_{n+1 } }       &       \ldots       &       [ \dual{\ell'_{m-1 } } ] ^{1_{n+m-1 } }       &       \infer*[\varphi']{\ell_1 \vee \ldots \vee \ell_n \vee \ell'_1 \vee \ldots \vee \ell'_m } { }     }     &     [ \dual{\ell'_m}~\sigma ]   } } \ ] ]  where is a unifier of ,  and , for any .the simulation of factoring depends on a sufficient degree of freedom in the choice of decision literals. we must be allowed ( as indeed we are in * cr * ) to assume a decision literal ( ) that is the dual of an instance of all ( for ) .[ example : uprcl ] consider the following clause set :   it admits the * cr*refutation shown in fig .[ fig : uprclrefutation ] . a shorter refutation would be possible if we had taken , for instance , as a decision literal . but taking as a decision literal instead , as done in the refutation in fig .[ fig : uprclrefutation ] , we can see how conflict driven clause learning behaves in the first - order case , when decision literals can contain variables , that can be instantiated during the process of propagation .in one path from to just above the inference , the unification performed by the unit - propagating resolution inference instantiates with , whereas in the other path is instantiated with .therefore , the inference learns the clause , which is the disjunction of the negations of all the instances of the decision literal .this is in contrast with ( and a generalization of ) the propositional case , where instances did not need to be considered .  as in the propositional case, the decisions and unit propagations can be represented graphically :     by comparing the conflict graphs and * cr*derivations in example [ example : uprcl ] , it is noticeable that there is a straightforward isomorphism between conflict graphs and * cr*sub - derivations with a single conflict inference .every decision literal in a conflict graph appears as a decision literal in the corresponding * cr*derivation .every propagated literal in the conflict graph appears as a propagated literal derived by a unit - propagating resolution inference , and the clause associated to the incoming edges of the propagated literal is exactly the non - unit clause used as the rightmost premise of the unit - propagating inference .finally , the conflict in the conflict graph is a conflict inference in the corresponding * cr*derivation .in contrast , the correspondence between resolution derivations and conflict graphs is imperfect .as illustrated in example [ example : conflictgraphs ] , we have a map from conflict graphs to resolution derivations ; however , this map is not an isomorphism , simply because it is not even surjective .furthermore , there is a mismatch between the conflict graph operations ( i.e. decisions , propagations and conflict ) and the operations of the resolution calculus ( i.e. the resolution and factoring inference rules ) . in other words ,no map from conflict graphs to resolution derivations could be an isomorphism , because the algebraic structure can not be preserved . from this algebraic point of view, we may conjecture that the popular belief that ( propositional ) resolution is the underlying proof system of modern sat - solvers ( which actually implement the cdcl procedure based on conflict graphs ) is mistaken .we also speculate that the mismatch is the theoretical explanation for the overhead experienced in the transformation of conflict graphs to resolution derivations ( as discussed in the end of section [ sec : dpllcdcl ] ) .perhaps a calculus such as * cr * , that enjoys a better correspondence to conflict graphs , could enable proof production with less overhead .a proof system * p * is _ refutationally complete _ iff any unsatisfiable clause set has a refutation in * p*. instead of proving refutational completeness for * cr*directly , we will prove it indirectly , showing that * cr*can simulate another refutationally complete proof system . a proof system *p * simulates another proof system * q * iff there is a map transforming any * q*-derivation of from to * p*-derivation of from .  this indirect approach to proving completeness can be traced back at least to gentzen s work ( ) , who applied it to his natural deduction and sequent calculi . in our case , the target proof system for the simulation is resolution , and the key idea of the simulation is that every resolution step that is not a unit - propagating resolution inference can be simulated by several decisions , two unit - propagating resolution inferences , one conflict inference and one conflict - driven clause learning inference .  [theorem : simulationofresolution ] * cr*linearly simulates resolution .let be a resolution derivation of a clause from a set of clauses .we show that there is a * cr*derivation of from , proceeding by induction :  * _ base case : _ is just a single node . in this case, is just the single node as well . *_ induction case 1 : _ ends with a factoring inference . in this case , let be the subderivation whose conclusion is the premise of . by induction hypothesis , there is a * cr*derivation of from .and then can be constructed as the * cr*derivation of from obtained from by applying the admissible factoring inference rule to its conclusion in the same way as in or by simulating factoring as shown in fig .[ fig : factoringadmissibility ] . in any case , the conclusion of is , as desired . * _ induction case 2 : _ ends with a resolution inference . in this case, is of the following form : { ( \ell_1 \vee \ldots \vee \ell_n \vee \ell'_1 \vee \ldots \vee \ell'_m)~\sigma } { \infer*[\psi_1]{\ell_1 \vee \ldots \vee \ell_n \vee\ell \qquad } { } &  \infer*[\psi_2]{\qquad \dual{\ell ' } \vee \ell'_1 \vee \ldots \vee \ell'_m } { } } \ ] ] by induction hypothesis , we have a * cr*derivation of from and a * cr*derivation of from . then a * cr*derivation of can be constructed as shown in fig .[ fig : simulationofresolution ] .+ {(\ell_1 \vee \ldots \vee \ell_n \vee \ell'_1 \vee \ldots \vee \ell'_m)~\sigma } {   \infer[{\mathbf{c}(\sigma)}]{\bot } {     \infer[{\mathbf{u}(\varepsilon)}]{\ell}{[\dual{\ell_1}]^1 & \ldots & [ \dual{\ell_n}]^1 & \infer*[\varphi_1]{\ell_1 \vee \ldots \vee \ell_n \vee \ell } { } }     &     \infer[{\mathbf{u}(\varepsilon)}]{\dual{\ell ' } } { [ \ell'_1]^1 & \ldots & [ \ell'_m]^1 & \infer*[\varphi_2]{\dual{\ell ' } \vee \ell'_1 \vee \ldots \vee \ell'_m } { } }   } } \ ] ]  the simulation is linear both in length ( i.e. number of inferences ) and size ( i.e. number of literals ) . if has resolutions and factorings , then has clause learning inferences , conflicts , unit propagations and factorings .hence , . if has literals occurring in conclusions of resolution inferences and literals occurring in conclusions of factoring inferences , then has logical symbols occurring in conclusions of clause learning inferences , logical symbols occurring in premises of conflict inferences , literals occurring as decision literals for unit propagations and literals . hence , . since every resolution inference in has at least one literal in its conclusion , except for the last one deriving the empty clause , .therefore , and thus .* cr*is refutationally complete .let be an unsatisfiable clause set .as resolution is a refutationally complete calculus , there is a resolution refutation of . by theorem [ theorem : simulationofresolution ], can be transformed to a * cr*refutation of .a mere restriction of resolution to unit - propagating resolution would result in a refutationally incomplete calculus .the unsatisfiable clause sets from examples [ example : conflictgraphs ] and [ example : uprcl ] , for instance , would not be refutable . by incorporating decision literals , as well as the conflict rule and the conflict - driven clause learning rule, we regain refutational completeness .  the fact that we need two unit - propagating resolution inferences , one conflict and one conflict - driven clause learning to simulate a single resolution inference ( as shown in fig .[ fig : simulationofresolution ] ) may lead us to think that * cr*is more bureaucratic and more inefficient than resolution .however , efficiency of proof search is not directly correlated with proof length .the efficiency of * cr*is a consequence of the fact that much fewer clauses are generated by unit - propagating resolution than by unrestricted resolution and the clause sizes are reduced through decisions and propagations .moreover , in any case , any resolution proof search , as well as any resolution proof , can be simulated in the * cr*calculus with only a ( small ) linear increase in length .to prove soundness , we exploit the key observation that decision literals resemble natural deduction s _ assumptions _ and conflict - driven clause learning resembles _ implication / negation introduction_. therefore , natural deduction is an excellent candidate for proving soundness indirectly , again by simulation .however , typical natural deduction rules operate on general formulas , which are not necessarily in clause form , and this makes a direct simulation technically difficult . in order to overcome this challenge, we define an intermediary _ clausal natural deduction calculus _( abbreviated as * cnd * ) with inference rules that operate on clauses , as shown in fig .[ fig : cnd ] .* implication elimination ( modus ponens ) : * {\gamma}{\ell & \dual{\ell } \vee \gamma}\ ] ]  * implication introduction : * { \dual{\ell } \vee \gamma } { \infer*{\gamma}{[\ell]^i}}\ ] ]  * universal quantification elimination : * {\gamma \sigma } { \gamma}\ ] ]  * universal quantification introduction : * { \gamma } { \gamma \ { { x_1 \backslash \alpha_1 } , \ldots , { x_n \backslash \alpha_n}\ } } \ ] ]   must be a distinct _ eigen - variable _ : + it should occur neither in nor in any undischarged assumption .the clausal natural deduction calculus * cnd*can be simulated by any standard non - clausal natural deduction calculus extended with a classical rule for double negation elimination .the key idea is to use the well - known classical equivalence ( where is an abbreviation for ) , in order to transform the clauses in a proof into formulas containing only implication , which are therefore suitable for a minimal non - clausal natural deduction calculus .when transforming a * cnd*proof into a standard non - clausal natural deduction proof , sequences of implication introduction / elimination rules may have to be added to the natural deduction proof , in order to reorder literals ( because associativity and commutativity of disjunction is implicitly taken into account by * cnd * s inference rules , but must be handled explicitly in a standard natural deduction calculus ) .the classical rule of double negation elimination is needed in order to handle the involutivity of classical negation , which is implicit in * cnd*. a more detailed proof of this simulation is omitted because it would be tedious and space - consuming .soundness of * cnd*is a corollary of the simulation , since natural deduction is sound .remembering that all clausal rules are assumed to be modulo negation s involutivity and modulo the neutrality of w.r.t .disjunction , the rules for negation introduction and elimination shown in fig .[ fig : cndnegationrules ] are admissible in * cnd * , since they are just special cases of , respectively , implication introduction and elimination , when .we are now ready to prove the following theorem .* negation elimination : * {\bot}{\ell & \dual{\ell } } \ ] ]  * negation introduction : * { \dual{\ell } } { \infer*{\bot}{[\ell]^i}}\ ] ]  [ theorem : simulationbynd ] * cnd*simulates * cr*.  given a * cr*derivation of a clause from a set of clauses , we must construct a * cnd*derivation of from ( modulo variable renaming ) .we first expand into a tree - like proof : for each clause with several children ( where ) , we create copies of and use each ( for ) as a parent for .the variables in each copy are renamed to fresh variables and all substitutions in the proof are updated accordingly , in order to maintain the property that distinct clauses in do not share variables ( cf .section [ sec : resolution ] ) .now that is tree - like , we may compute its _ global substitution _ ( i.e. the composition ( in topological order ) of all the substitutions used in the proof ) do not share variables and is tree - like , we do not need to worry about variable clashes in the composition of all substitutions .the topological order is needed because a variable introduced by a substitution may be in the domain of another substitution occurring below . in this case , the topologically ordered composition is ( i.e. apply first and then ) . ] .we now do a recursive top - down traversal of and for each subderivation deriving a clause from with decision literals , \ldots , [ \ell_n] ] :  * _ base case 1 : _ has just a leaf node containing a decision literal  ] . * _ base case 2 : _ has just a leaf node containing a clause . in this case , is : {\gamma~\sigma^*}{\gamma}\ ] ] * _ induction case 1 : _ ends with a unit - propagating resolution inference , as shown below : { \ell~\sigma } {  \infer*[\eta_1]{\ell_1 } { }  & \ldots &   \infer*[\eta_n]{\ell_n } { }  &   \infer*[\eta']{\dual{\ell'_1 } \vee \ldots\vee \dual{\ell'_n } \vee \ell } { }  } \ ] ] by induction hypothesis , there are * cnd*derivations , , , of , respectively , , , , .we then construct by applying implication elimination times , as shown below : { \ell~\sigma } {   \infer*[\xi_n]{\ell_n~\sigma^ * } { }   &   \infer[\imp_e ]   { \vdots }   {     \infer*{\qquad } { }   &     \infer[\imp_e ]     { ( \dual{\ell'_2 } \vee \ldots \vee \dual{\ell'_n } \vee \ell)~\sigma }     {      \infer*[\xi_1]{\ell_1~\sigma^ * } { }     &      \infer*[\xi']{(\dual{\ell'_1 } \vee \ldots\vee \dual{\ell'_n } \vee \ell)~\sigma^ * } { }     }   } } \ ] ] * _ induction case 2 : _ ends with a conflict inference .this case is analogous to the case above .but , instead of implication elimination inferences , a single negation elimination inference suffices . * _ induction case 3 : _ ends with a conflict - driven clause learning inference . in this case, the corresponding subproof in used to have the following form : { ( \dual{\ell_1 } \sigma^1_1 \vee \ldots \vee \dual{\ell_1 } \sigma^1_{m_1 } ) \vee \ldots \vee ( \dual{\ell_n } \sigma^n_1 \vee \ldots\vee \dual{\ell_n } \sigma^n_{m_n } ) } { \infer*{\bot}{\infer*[(\sigma_1 ^ 1,\ldots,\sigma_{m_1}^1)]{}{[\ell_1]^{i_1 } } &  & \infer*[(\sigma_1^n,\ldots,\sigma_{m_n}^n)]{}{[\ell_n]^{i_n } } } } \ ] ] but due to the expansion to a tree , the subproof in has the form shown below , where there is a copy  ] for every path that existed from  ] to be discharged , as depicted below : + { ( \dual{\ell_1 ^ 1 } \sigma^ * \vee \ldots \vee \dual{\ell_1^{m_1 } } \sigma^ * ) \vee \ldots \vee ( \dual{\ell_n^1 } \sigma^ * \vee \ldots \vee \dual{\ell_n^{m_n } } \sigma^ * ) } {     \infer*{\qquad\bot\qquad }     {     \infer*[]{}{[\ell_1 ^ 1~\sigma^*]^1 }                                      &     \ldots     &     \infer*[]{}{[\ell_n^{m_n}~\sigma^*]^k }      } } \ ] ] + since is the composition of all substitutions in , including every , we have that .therefore , the conclusion of is identical to :   at the end of the top - down traversal , we have a * cnd*proof of from .since is the global substitution of all substitutions used in and derives , we have that . therefore , is a * cnd*proof of from , as desired .  to illustrate the transformation of * cr*derivations into * cnd*derivations used in the proof of theorem [ theorem : simulationbynd ] , fig .[ fig : cndderivation ] shows the * cnd*derivation obtained by transforming the * cr*derivation shown in fig .[ fig : uprclrefutation ] .  where is a reference to a copy of .* cr*is sound .let be an arbitrary * cr*proof of from .then , by theorem [ theorem : simulationbynd ] , there is a * cnd*proof of from .since the natural deduction calculus * cnd*is sound , is entailed by .therefore , * cr*is sound .suppose that a prover refutes the set of clauses ( where the sets of variables of are mutually disjoint ) , by splitting it into the sets ( for ) and finding a resolution refutation for each set .one way to combine these proofs into a single resolution refutation of would be to use the following recursive method :  * _ for : _ construct by replacing every leaf occurrence of in by , propagating the added literals downwards and factoring the added literals when possible ; then is not a refutation , but a derivation of . * _ for from to : _ construct by replacing every leaf occurrence of in by the subproof deriving ; as before , propagate the added literals downwards and factor them when possible , so that is a proof of , if , or , otherwise .  however , this method is undesirable , because it requires a substantial modification of the component proofs .the modified subproofs are larger ( because of all the additional literals ) , and this may hinder readability of the proof by humans and reduce the efficiency of automatic proof checking .  a pragmatic approach is to disregard the attempt to output a single refutation for the original problem and simply output all the separate proofs for the split problems instead . keeping track of all splittings is important , particularly in the more general case where splitting is done recursively ( i.e. where each set can be split further ) .this seems to be the approach taken by most automated theorem provers .splittings performed during the proof search are recorded in the proof file in an extra - logical way , which may even violate informal semantic requirements of the tptp proof format rule or splitting .* cr * s conflict - driven clause learning is also affected by this limitation . ] .  in * cr * , splitting can be simulated in such a way that the refutations for the split sub - problems can be combined without the drawbacks that are incurred when this is done in resolution .suppose that are derivations of .then a refutation of can be constructed by combining all the ( for ) using the following recursive method :  * _ for : _ construct by replacing every leaf occurrence of in by the following subproof ( where are duals of the literals in ) : + {\gamma_1 } {   [ \ell_2 ^ 1]^2   &   \ldots   &   [ \ell_2^{n_1}]^2   &   \ldots   &   [ \ell_k^1]^k   &   \ldots   &   [ \ell_k^{n_k}]^k   &   \gamma_1 \vee \ldots \vee \gamma_k } \ ] ] + then construct by adding a conflict - driven clause learning to the bottom of : * _ for from to : _ construct by replacing every leaf occurrence of in by the following subproof : {\gamma_i } {   \infer*[\varphi'_{i-1}]{\bot } { } } \ ] ]  the desired refutation of is taken to be .this method of simulating splitting in * cr*requires no internal modification of the proofs : the modified proofs ( ) are just with a few inferences on top .hence , there is no loss in readability , and the only overhead for automatic proof checking is caused by the extra need to check the additional inferences .if the leaf clause occurs only once does not need to be tree - like . ] , a single inference suffices , in fact .therefore , the increase in proof size and the overhead for proof checking are negligible .the simulation described here shows that splitting can be seen as a macro - rule that performs , for a variable - disjoint component , batch decisions assuming the duals of all literals not in .the first - order mechanism of decisions and conflict - drive clause learning provided by * cr*is , however , more general , because it allows splitting even when the components are not variable - disjoint .the proof of * cr * s soundness in section [ sec : soundness ] demonstrates that there is a lot in common between * cr*and natural deduction . in the same way that natural deduction can be presented with a sequent notation , in which assumptions are listed in the antecedent of the sequent ( i.e. at the left side of the turnstile symbol ) , *cr*can also be presented with a sequent notation , with decision literals kept at the antecedent .this is shown in fig .[ fig : uprclsequentnotation ] .  * decision : * ^i}{}\ ] ]  * initial : *   if is an input clause  * unit - propagating resolution : * {\delta_1~\sigma , \ldots , \delta_n~\sigma , \delta~\sigma \vdash \ell~\sigma}{\delta_1 \vdash \ell_1 & \ldots & \delta_1 \vdash \ell_n & \delta \vdash \dual{\ell'_1 } \vee \ldots \vee \dual{\ell'_n } \vee \ell}\ ] ]  where is a unifier of and , for all .* conflict : * {\delta_1~\sigma , \delta_2~\sigma \vdash \bot}{\delta_1 \vdash \ell & \delta_2 \vdash \dual{\ell'}}\ ] ]  where is a unifier of and , for all .  * conflict - driven clause learning : * { \delta \vdash ( \dual{\ell_1 } \sigma^1_1 \vee \ldots \vee \dual{\ell_1 } \sigma^1_{m_1 } ) \vee \ldots \vee ( \dual{\ell_n } \sigma^n_1 \vee \ldots\vee \dual{\ell_n } \sigma^n_{m_n } ) } { \delta , \ell_1^i \sigma^1_1 , \ldots , \ell_1^i \sigma^1_{m_1 } , \ldots , \ell_n^i \sigma^n_1 , \ldots , \ell_n^i \sigma^n_{m_n } \vdash \bot } \ ] ]  where ( for and ) is the composition of all substitutions used on the -th path from to .  with the sequent notation, it is easier to state the inference rule for conflict - driven clause learning .all the substitutions that should be applied to the literals whose duals will be part of the learned clause have already been applied to the literals in the antecedent .there is no need to look at the substitutions that have been used in the paths above . on the other hand ,the presentation with sequent notation is much more redundant and bureaucratic .whereas in the standard presentation , the use of decision literals is a powerful way to reduce the size of clauses ( as in the simulation of splitting ) , this beneficial effect is lost in the presentation with the sequent notation , because the decision literals are carried along in the antecedents .for example , if we have the clause , then assuming the duals of the first literals and resolving them with the clause through unit - propagation would result in the unit clause in the standard presentation .with sequent notation , on the other hand , we would obtain .while this may be conceptually convenient , because it reminds us explicitly that the unit clause holds only under the assumptions , we have no reduction in size if we also count the antecedent s size .in fact , because the proof may be a non - tree - like dag , and decision literals may be instantiated by different substitutions along different paths of the dag , several instances of the decision literal will accumulate in the antecedent .the number of instances may be in the worst case exponential in the height of the derivation .that is one reason why the standard presentation , where the dependence of on assumptions and the substitutions used to instantiate the decision literals remain implicit in the derivation , is preferable .this is particularly important during proof search , in which not all inferences are useful and we do not want to apply substitutions and accumulate copies of literals unnecessarily along the derivation .we should do that only when a conflict , warranting conflict - driven clause learning , is reached .the seminal work of baumgartner and tinelli ( ) defining the _ model evolution _ ( me ) procedure was probably the first lifting of dpll to the first - order case .it was later extended with a lemma learning rule , while retaining a traditional dpll flavor ( distinct from the _ conflict graph _approach ) . in model evolution, decision literals do not contain standard variables , but _ parameters _ , which are variables with special semantics and behavior in the case of backtracking and clause learning .* cr*may be considered simpler , because it does not introduce the notion of parameter ; however , in contrast to model evolution , for * cr*the problem of interpreting decision literals as a model has not been investigated yet .more recently , alagi and weidenbach ( ) proposed the _ non - redundant clause learning _ ( nrcl ) procedure generalizing cdcl to the bernays - schnfinkel fragment of first - order logic .they introduce the notion of _ blocked decisions and clauses _ , which restricts the decisions that can be made and thus allows them to prove that the learned clause is non - redundant ( whereas in * cr*they might not be ) .they also introduce the notion of _ constrained literals _ , which allow more compact representation of the model . in * cr * , such optimizations and restrictions are intentionally avoided , in favor of a simple calculus focused on the core aspects of generalizing decisions and conflict - driven clause learning to _ full _ first - order logic .bonacina , fuhrbach and sofronie - stokkermans ( ) give a preview of a yet unpublished first - order _ semantically - guided goal sensitive _ ( sggs ) procedure inspired by cdcl . as they observe, there is a symmetry between positive and negative literals in the propositional case ( i.e. in the sense that when a decision literal is false , is true ) which appears to be lost in the first - order case ( i.e. because when is false , we can not conclude that is true ; we can only conclude that is true for some ) .one of the main challenges in lifting conflict - driven clause learning to first - order lies precisely in computing and dealing with the substitution when a decision literal leads to a conflict and a clause containing must be learned . instead of addressing this challenge , they circumvent it by introducing the notion of _ uniform falsity _ , according to which must be true when is uniformly false . with this notion , clause learning is still essentially propositional and it is not triggered at every conflict ( in the standard non - uniform sense of conflict ) .for instance , a conflict between and does not lead to clause learning but must be repaired by revising to instead .the variety of approaches attempting to generalize cdcl to first - order logic shows that this is not a trivial task .the most pragmatically successful approaches so far have harnessed the power of sat - solvers in first - order ( or even higher - order ) logic not by generalizing their underlying procedures but simply by employing them as _ black - boxes _ inside a theorem prover .the development of the conflict resolution calculus * cr*was initially motivated by the recent success of cdcl and by the desire to generalize its main ideas to first - order logic .however , * cr*can also be seen as the convergence of two ideas that actually precede cdcl by several decades .the first one is the assumption mechanism introduced by gentzen ( ) in his natural deduction calculus .the second one is robinson s generalization of the resolution rule to first - order logic through unification ( ) . *cr*extends resolution as natural deduction extends hilbert - style proof systems : decision literals are essentially assumptions , and conflict driven clause learning corresponds to ( several applications of ) natural deduction s implication introduction rule . and whereas robinson used unification to generalize resolution , * cr*uses unification to generalize conflict - driven clause learning .  from a historical perspective, what we are seeing today is similar to what happened between 1960 and 1965 . in 1960 , defined the _ propositional _ resolution rule , which can be regarded as an efficient machine - oriented variant of modus ponens ( implication elimination ) .the first - order case was then handled by _grounding / instantiating _ the first - order problem and using the propositional resolution rule . in 1965 , s direct generalization of the resolution rule to the first - order case enabled a breakthrough in first - order automated theorem proving .nowadays , we have a powerful _ propositional _ conflict driven clause learning rule , which can be regarded as an efficient machine - oriented variant of implication introduction .the first - order case is being handled by essentially grounding / instantiating the problem in various ways and using the propositional rule .if history repeats itself , we might see another breakthrough when clause learning is directly lifted to the first - order case through unification , as done in the * cr*calculus proposed here .a well - defined proof system is just a first step towards the development of a proof search procedure that could be implemented as an efficient theorem prover .there is much more to the efficiency of a modern sat - solver than just the ideas of decision literals , conflict - driven clause learning and unit - propagation . sat - solvers use restarts , strategies for selecting decision literals and data - structures that allow efficient unit - propagation , fast conflict graph analysis and fast backtracking . adapting these proof search strategies and implementation techniques to the conflict resolution calculus * cr*is beyond the scope of this paper , but is a crucial direction for future work .[ [ acknowledgements ] ] acknowledgements : + + + + + + + + + + + + + + + + +  bruno is grateful to pascal fontaine , who supervised him during his first post - doc , providing a great opportunity for him to learn some of the essential ideas behind current sat - solvers .bruno is thankful to peter baumgartner , who shared his experience in model evolution and other related methods , when they discussed the idea of * cr*in may 2015 .bruno would also like to thank hans de nivelle and jens otten for discussions during the vienna summer of logic about limitations of the tptp proof format that affect the representation of natural deduction and tableau proofs .gabor alagi and christoph weidenbach .`` non - redundant clause learning '' . in : _frocos _ ( 2015 ) , pp .evert w. beth .`` semantic entailment and formal derivability '' . in : _mededelingen van de koninklijke nederlandse akademie van wetenschappen , afdeling letterkunde _ 18.13 ( 1955 ) , pp .309342 .leo bachmair and harald ganzinger .`` completion of first - order clauses with equality by strict superposition ( extended abstract ) '' . in : _2nd international workshop conditional and typed rewriting systems _ , lncs 516 , springer ( 1990 ) , pp . 162180 .leo bachmair and harald ganzinger .`` rewrite - based equational theorem proving with selection and simplification '' . in : _ journal of logic and computation_ 4.3 ( 1994 ) , pp .217247 .peter baumgartner .`` model evolution based theorem proving '' . in : _ ieee inteligent systems _29(1 ) ( 2014 ) , pp . 410 .peter baumgartner and cesare tinelli .`` the model evolution calculus '' . in : _cade _ ( 2003 ) , pp .350364 .peter baumgartner , alexander fuchs and cesare tinelli .`` lemma learning in the model evolution calculus '' . in : _lpar _ ( 2006 ) , pp .572586 .armin biere .`` picosat essentials '' . in : _journal on satisfiability , boolean modelling and computation ( jsat ) _ ( 2008 ) .maria paola bonacina , ulrich fuhrbach and viorica sofronie - stokkermans .`` on first - order model - based reasoning '' . in : _ logic , rewriting and concurrency _ ( 2015 ) , pp .181204 .chad e. brown .`` satallax : an automatic higher - order prover '' . in : _ijcar _ ( 2012 ) , pp .111117 .chad e. brown .`` reducing higher - order theorem proving to a sequence of sat problems '' . in : _ journal of automated reasoning _ ( 2013 ) , pp .5777 .  martin davis and hilary putnam .`` a computing procedure for quantification theory '' . in : _journal of the acm _ 7 ( 1960 ) , pp .201215 .martin davis , george logemann and donald loveland .`` a machine program for theorem proving '' . in : _ communications of the acm _5(7 ) ( 1962 ) , pp . 394397 .gerhard gentzen .`` untersuchungen ber das logische schlieen i & ii '' . in : _ mathematische zeitschrift _ 39.1 ( 1935 ) , pp .176210 & 405431 .konstantin korovin .`` iprover - an instantiation - based theorem prover for first - order logic ( system description ) '' . in : _international joint conference on automated reasoning ( ijcar ) _( 2008 ) , pp .292298 .joao marques - silva and k.a .`` grasp : a new search algorithm for satisfiability '' . in : _international conference on computer - aided design _ ( 1996 ) , pp ..  joao marques - silva , ines lynce and sharad malik .`` conflict - driven clause learning sat solvers '' . in : _ handbook of satisfiability _ ( 2008 ) , pp .127 149 .j. mccharen , r. overbeek and l. wos .`` complexity and related enhancements for automated theorem - proving programs '' . in : _ computers and mathematics with applications _ 2 ( 1976 ) ,w. mccune .`` prover9manual '' ( 2006 ) .alexandre riazanov and andrei voronkov .`` the design and implementation of vampire '' . in : _ai communications _ 15(2 - 3)(2002 ) , pp .91110 .john alan robinson .`` a machine - oriented logic based on the resolution principle '' . in : _ journal of the acm _ 12.1 ( 1965 ) , pp .george robinson and larry wos .`` paramodulation and theorem - proving in first - order thories with equality '' . in : _machine intelligence _ 4 ( 1969 ) , pp . 135150 .stephan schultz .`` system description : e 1.8 '' . in : _lpar _ ( 2013 ) , pp .735743 .geoff sutcliffe .`` the tptp problem library and associated infrastructure : the fof and cnf parts , v3.5.0 '' . in : _ journal of automated reasoning _ 43.4 ( 2009 ) ,337362 .  andrei voronkov .`` avatar : the architecture for first - order theorem provers '' . in : _ cav _ ( 2014 ) ,696710 .uwe waldmann .`` superposition '' . in : _ encyclopedia of proof systems _( 2015 ) .uwe waldmann .`` saturation with redundancy '' . in : _encyclopedia of proof systems _ ( 2015 ) .christoph weidenbach .`` combining superposition , sorts and splitting '' . in : _ handbook of automated reasoning _ ( 2001 ) , pp .19652013 .christoph weidenbach .`` the theory of spass version 2.0 '' . in : _ spass 2.0 documentation_.  christoph weidenbach , dilyana dimova , arnaud fietzke , rohit kumar , martin suda , patrick wischnewski .`` spass version 3.5 '' . in : _ cade _ ( 2009 ) , pp .140145 .nathan wetzler , marijn heule and warren a. hunt jr .`` drat - trim : efficient checking and trimming using expressive clausal proofs '' .in : _ sat _ ( 2014 ) , pp .422429 .lintao zhang , conor f. madigan , matthew h. moskewicz , sharad malik . `` efficient conflict driven learning in a boolean satisfiability solver '' . in : _international conference on computer - aided design _ ( 2001 ) , pp .a standard natural deduction calculus for minimal quantified logic extended with a classical rule for double negation elimination is shown in fig . [fig : nd ] .

Abstract: this paper defines the ( first - order ) conflict resolution calculus : an extension of the resolution calculus inspired by techniques used in modern sat - solvers . the resolution inference is restricted to ( first - order ) unit - propagation and the calculus is extended with a mechanism for assuming _ decision literals _ and a new inference rule for _ clause learning _ , which is a first - order generalization of the propositional _ conflict - driven clause learning _ ( cdcl ) procedure . the calculus is sound ( because it can be simulated by natural deduction ) and refutationally complete ( because it can simulate resolution ) , and these facts are proven in detail here .   australian national university john.slaney.edu.au bruno.wp.com  proof theory , resolution , natural deduction , sat , first - order logic , conflict - driven clause learning


formal concept analysis ( fca )  has found many applications since its introduction . as the size of datasets grows , such as data generated from high - throughput technologies in bioinformatics ,there is a need for efficient algorithms for constructing concept lattices .the input of fca consists of a triple , called _ context _ , where is a set of objects , is a set of attributes , and is a binary relation between and . in fca , the context is structured into a set of _ concepts_. the set of all concepts , when ordered by set - inclusion , satisfies the properties of a _complete lattice_. the lattice of all concepts is called _ concept _  or _ galois _  lattice .when the binary relation is represented as a bipartite graph , each concept corresponds to a maximal bipartite clique ( or maximal biclique ) .there is also a one - one correspondence of a closed itemset studied in data mining and a concept in fca .the one - one correspondence of all these terminologies concepts in fca , maximal bipartite cliques in theoretical computer science ( tcs ) , and closed itemsets in data mining ( dm ) was known , e.g. .there is extensive work of the related problems in these three communities , e.g. in tcs , in fca , and in dm .in general , in tcs , the research focuses on efficiently enumerating all maximal bipartite cliques ( of a bipartite graph ) ; in fca , one is interested in the lattice structure of all concepts ; in dm , one is often interested in computing frequent closed itemsets only .[ [ time - complexity . ] ] time complexity .+ + + + + + + + + + + + + + + +  given a bipartite graph , it is not difficult to see that there can be exponentially many maximal bipartite cliques . for problems with potentially exponential ( in the size of the input ) size output , in their seminal paper  ,johnson et al introduced several notions of _ polynomial time _ for algorithms for these problems : _ polynomial total time _, _ incremental polynomial time _, _ polynomial delay time_. an algorithm runs in polynomial total time if the time is bounded by a polynomial in the size of the input and the size of the output .an algorithm runs in incremental polynomial time if the time required to generate a successive output is bounded by the size of input and the size of output generated thus far .an algorithm runs in polynomial delay time if the generation of each output is only polynomial in the size of input .it is not difficult to see that polynomial delay is stronger than incremental polynomial ( namely an algorithm with polynomial delay time is also running in incremental polynomial ) , which is stronger than polynomial total time .polynomial delay algorithm , we can further distinguish if the space used is polynomial or exponential in the input size .[ [ previous - work . ] ] previous work .+ + + + + + + + + + + + + +  observe that the maximal bipartite clique ( mbc ) problem is a special case of the maximal clique problem in a general graph .namely , given a bipartite graph , a maximal bipartite clique corresponds to a maximal clique in where .consequently , any algorithm for enumerating all maximal cliques in a general graph , e.g. , , also solves the mbc problem .in fact , the best known algorithm in enumerating all maximal bipartite cliques , which was proposed by makino and uno  that takes polynomial delay time where is the maximum degree of , was based on this approach .the fact that the set of maximal bipartite cliques constitutes a lattice was not observed in the paper and thus the property was not utilized for the enumeration algorithm .  in fca ,much of research has been devoted to study the properties of the lattice structure .there are several algorithms , e.g. , that construct the lattice , i.e. computing all concepts together with its lattice order .there are also some algorithms that compute only concepts , e.g. .( we remark that the idea of using a total _ lectical order _ on concepts ganter s algorithm  is also used in for enumerating maximal ( bi)cliques . )see for a comparison studies of these algorithms .the best polynomial total time algorithm was by nourine and raynaud with time and space , where and and denote the set of all concepts .this algorithm can be easily modified to run in incremental time .observe that the space of total size of all concepts is needed if one is to keep the entire structure explicitly .there were several other algorithms , e.g. , all run in polynomial delay .there is another algorithm  that is based on divide - and - conquer approach , but the analytical running time of the algorithm is unknown as it is difficult to analyze .there are several algorithms in data mining for computing frequent closed itemsets , such as charm(-l ) , and closet(+ )  .to our best knowledge , the algorithm with theoretical analysis running time was given in with incremental polynomial running time , where and .[ [ our - results . ] ] our results .+ + + + + + + + + + + +  in this paper , by making use of the lattice structure of concepts , we present a simple and fast algorithm for computing all concepts together with its lattice order .the main idea of the algorithm is that given a concept , when all of its successors are considered together ( i.e. in a batch manner ) , they can be efficiently computed .we compute concepts in the breadth first search ( bfs ) order the ordering given by bfs traversal of the lattice .when computing the concepts in this way , not only do we compute all concepts but also we identify all successors of each concept .another idea of the algorithm is that we make use of the concepts generated to dynamically update the adjacency relations .the running time of our algorithm is polynomial delay for each concept ( see section [ sec : background ] for related background and terminology ) , where is the reduced adjacency list of .our algorithm is faster than the best known algorithms for constructing a lattice because the algorithm is faster than a basic algorithm that runs in , where is number of attributes adjacent to the object , and this basic algorithm is already as fast as the current best algorithms for the problem .we also present two variants of the algorithm : one is computing all concepts only and another is constructing the frequent closed itemset lattice .both algorithms are faster than the current start - of - the - art program for these problems .[ [ outline . ] ] outline .+ + + + + + + +  the paper is organized as follows . in section[ sec : background ] , we review some background and notation on fca . in section [ sec :basic ] , we describe some basic properties of concepts that we use in our lattice - construction algorithm . in section [ sec :algorithms ] , we first describe the high level idea of our algorithm . then we describe how to efficiently implement the algorithm . in section [ sec : variants ] , we describe two variants of the algorithm .one is for computing all concepts only and another is for constructing a frequent closed itemset lattice .we conclude with discussion in section [ sec : discussion ] .in fca , a triple is called a _ context _ , where is a set of elements , called _ objects _ ; is a set of elements , called _ attributes _ ; and is a binary relation .the context is often represented by a _cross - table _ as shown in figure [ table1 ] .a set is called an _object set _ , and a set is called an _ attribute set_. following the convention , we write an object set as , and an attribute set as .  for ,denote the adjacency list of by .similarly , for , denote the adjacency list of by .the function maps a set of objects to their common attributes : , for .the function maps a set of attributes to their common objects : , for .it is easy to check that for , , and for , .an object set is _ closed _ if .an attribute set is closed if .the composition of and induces a _ galois connection _ between and .readers are referred to for properties of the galois connection .  a pair , with and ,is called a _ concept _ if and .  for a concept , by definition ,both and are closed .the object set is called the _ extent _ of , written as , and the attribute set is called the _ intent _ of , and written as .the set of all concepts of the context is denoted by or simply when the context is understood .let and be two concepts in .observe that if , then . we order the concepts in by the following relation : it is not difficult to see that the relation is a partial order on .in fact , is a complete lattice and it is known as the _ concept _ or _ galois _ lattice of the context . for with , if for all such that implies that or , then is called the _ successor_(or _ lower neighbor _ ) of , and is called the _ predecessor _ ( or _ upper neighbor _ ) of .the diagram representing an ordered set ( where only successors / predecessors are connected by edges ) is called a _ hasse diagram _ ( or a line diagram ) .see figure [ table1 ] for an example of the line diagram of a galois lattice .  for a concept , and .thus , is uniquely determined by either its extent , , or by its intent , .we denote the concepts restricted to the objects by , and the attributes by for , the corresponding concept is . for ,the corresponding concept is .the order is completely determined by the inclusion order on or equivalently by the reverse inclusion order on .that is , and are order - isomorphic .we have the property that is a successor of in if and only if is a successor of in .since the set of all concepts is finite , the lattice order relation is completely determined by the covering ( successor / predecessor ) relation .thus , to construct the lattice , it is sufficient to compute all concepts and identify all successors of each concept .in this section , we describe some basic properties of the concepts on which our lattice construction algorithms are based .[ prop-1 ] let be a concept in .for , if is not empty , is closed .consequently , is a concept .  for ,suppose that is not empty .we will show that .since , it remains to show that . by definition , .thus , .consequently , .[ cols="^,^,^ " , ]   * example . *consider the concept of context in figure [ table1 ] , we have .for a closed attribute set , denote the set of remaining attributes by .consider the following equivalence relation on : , for .let be the equivalence classes induced by , i.e. , and for any , .we denote the set by .we call the sibling of for . for convenience, we will write by . when there is no confusion , we abuse the notation by writing .note that by definition , for some .we denote the pairs by .recall that and are order - isomorphic .we have the property that is a successor of in if and only if is a successor of in . for each , we call a child of and a parent of . by the definition of the equivalence class , for each that is a successor of , there exists a that .that is , if is a successor of , is a child of .let denote all the successors of , then we have . however , not every child of is a successor of . for the example in figure[ table1 ] , , where and are successors of but is not . ; while , .similarly , if is a predecessor of , then p is parent of but it is not necessary that every parent of is a predecessor of .  note that for , if , then by definition is closed .it is easy to check that the converse is also true .namely , if is closed , then . in other words, we have the following proposition .[ succ - prop ] is closed , .   by definition , an attribute set is closed if . in the following we givetwo characterizations for an attribute set being closed based on its relationship with its siblings .[ close - prop ] for , is not closed if and only if there exists , , such that .furthermore , for all with , there exists such that , and .if is not closed , by definition , there exists such that . as is a partition of ,there exists a such that , and thus .conversely , suppose there exists such that . then . that is, , which implies is not closed .suppose that with .for , .thus , there exists such that , . since are disjoint , .based on the first part of this proposition ( first characterization ) , we can test if is closed , for , by using_ subset testing _ of its object set against its siblings object set .namely , is closed if and only is not a proper subset of its siblings object set . in our running example in figure [ table1 ] , not closed because its object set is a proper subset of the object set of its sibling , .  in general ,subset testing operations are expensive .we , however , can make use of the second part of the proposition ( second characterization ) for testing closure using set exact matching operations instead of subset testing operations .this is because if we process the children in the decreasing order of their object - set size , we can test the closure of by comparing its size against the size of the attribute set ( if exists ) of .namely , we first search if exists by a set exact matching operation .if it does not , then is closed .otherwise , if the size of the existing attribute set of is greater than , then is not closed . in our running example , is not closed because has a larger attribute set .in this section , we first describe the algorithm in general terms , independent of the implementation details .we then show how the algorithm can be implemented efficiently .recall that constructing a concept lattice includes generating all concepts and identifying each concept s successors .our algorithm starts with the top concept .we process the concept by computing all its _ successors _ , and then recursively process each successor by either the depth first search ( dfs ) order the ordering obtained by dfs traversal of the lattice or breadth first search ( bfs ) order . according to proposition [ succ - prop ] , successors of a conceptcan be computed from its children .let be a concept .first , we compute all the children .then for each , we check if is closed . if is closed , is a successor of .since a concept can have several predecessors , it can be generated several times .we check its existence to make sure that each concept is processed once and only once .the pseudo - code of the algorithm based on bfs is shown in algorithm [ bfs - lattice - alg ] .compute the top concept ; initialize a queue ; compute ;   ; let and suppose ; denote the concept by ; compute ; enqueue to ; identify as a successor of ;   the efficiency of the algorithm depends on the efficient implementation of processing a concept that include three procedures : ( 1 ) computing ; ( 2)testing if an attribute set is closed ; ( 3 ) testing if a concept already exists .first , we describe how to compute in time , using a procedure , called sprout , described in the following lemma .  for , it takes to compute .let .for each , we associate it with a set ( which is initialized as an empty set ) . for each object , we scan through each attribute in its neighbor list , append to the set .this step takes .next we collect all the sets .we use a trie to group the same object set : search in the trie ; if not found , insert into the trie with as its attribute set , otherwise we append to s existing attribute set .this step takes .thus , this procedure , called sprout , takes time to compute .  for , we test if is closed based on the second characterization in proposition [ close - prop ] . for this method to work, it requires processing the children in the decreasing order of their object - set size .suppose where before .if is closed , we also compute its children . now to test if is closed , we check if exists .if it does not , then is closed .otherwise , we compare against the size of the existing attribute set of .if is not smaller , then is closed otherwise it is not . to efficiently search , we use a trie ( with hashing over each node ) to store the object sets of concepts generated so far and it takes linear time to search and insert ( if not exists ) an object set .that is , it will take time to check if is closed .the total time it takes to check if all children are closed is .recall that a concept is uniquely determined by its extent or its intent .therefore , we can store either the object sets or the attribute sets generated so far in a trie , and then test the existence of by testing the existence of or .since searching the object sets are needed in testing the closure of an attribute set as described above , the cost of testing the existence comes for free .note that .hence , the time it takes to process a concept is dominated by the procedure sprout , in time .if we can reduce the sizes of the adjacency lists ( ) , we can reduce the running time of the algorithm . note that this basic algorithm is already as fast as any existing algorithm for constructing a concept lattice ( or computing all concepts only that takes time where is the maximum size of adjacency lists ) .  in the followingwe describe how to dynamically update the adjacency lists that will reduce the sizes of adjacent lists , and thus improve the running time of the algorithm .consider a concept , the object sets of all descendants of are all subsets of . to compute the descendants of , it suffices to consider the objects with restriction to . for , by definition , all attributes in have the same adjacency lists when restricting to .that is , for all , .in other words , for all , , for all , i.e. , the adjacent list of either contains all elements in or no element in . therefore , we can reduce the sizes of adjacent lists of objects by representing all attributes in by a single element .for example in figure example2 , we can use a single element to represent the two attributes and , and to represent and . in doing so ,we reduce the size of adjacency list of from elements to three elements .we call the reduced adjacency lists the condensed adjacency lists . denoted the condensed adjacent list by . the set of condensed adjacency lists corresponds to a reduced cross - table .for example , the reduced cross table of of the above example is shown in figure [ example2 ] .c  & &   + ( a ) & ( b ) & ( c )  in order to use the condensed adjacency lists in procedure sprout , we need to process our concepts in bfs order and it requires one extra level , i.e. in a two - level manner .more specifically , for a concept , we first compute all its children .then we dynamically update the adjacency lists by representing the attributes in each child of with one single element .we then use these condensed adjacency lists to process each child of . that is , instead of using the global adjacency lists , when processing , we use the condensed adjacency lists of its parent .it takes for to generate its condensed adjacency lists ( see algorithm [ condenseadj - procedure ] in the appendix for the pseudo - code ) .and the time for the procedure sprout is ( see algorithm [ sprout - procedure ] in the appendix for the pseudo - code ) .notice that , the time for updating the adjacency lists is subsumed by the time required for procedure sprout .therefore , our new running time is for each concept . see algorithm [ 2-level - bfs ] for the pseudo - code and figure [ bfstrees ] for a step - by - step illustration of the algorithm .for some applications , one is not interested in the entire concept lattice . in the following, we will describe how to modify our algorithm to solve two special cases : enumerating all concepts only and constructing a frequent closed itemset lattice .   if one is interested in computing all the concepts and not in their lattice order , as in enumerating all maximal bicliques studied in  .we can easily modify our algorithm to give an even faster algorithm for this purpose .this is because in our algorithm , each concept is generated many times , more precisely , at least number of its predecessors times .for example in figure [ bfstrees ] , is generated twice , one by each of its predecessor . however , when we need all concepts only , we do not need regenerate the concepts again and again .this can be easily accomplished by considering the right siblings only in the procedure sprout , i.e. changing the line 3 to , while the other parts of the algorithm remain the same . depending on the lattice structure , this can significantly speed up the algorithm as the number of siblings is decreasing in a cascading fashion .a more careful analysis is needed for the running time of this algorithm .   in data mining ,one is interested in large concepts , i.e. where is larger than a threshold .although our algorithm can naturally be modified to construct such a closed itemset lattice : we stop processing a concept when the size of its object set is less than the given threshold , where objects correspond to transactions and attributes correspond to items .theoretically , when the memory requirement is not a concern , our algorithm is faster than all other existing algorithms ( including the state - of - art program charm - l ) for constructing such a frequent closed itemset lattice .however , in practice , for large data sets ( as those studied in data mining ) , the data structure a trie on objects ( transactions ) requires huge memory and this may threaten the algorithm s practical efficiency .however , it is not difficult to modify our algorithm so that a trie on attributes ( items ) instead is used .recall that a trie on objects are required in two steps of our algorithm : testing the closure of an attribute set and testing the existence of a concept .as noted above , the existence of a concept can also be tested on its intent ( i.e. attributes ) , thus we can use a trie on attributes for testing the existence of a concept . to avoid using a trie on objects for testing the closure of an attribute set , we can use the first characterization in proposition [ close - prop ] instead , that is , we test the closure of an attribute set by using _ subset testing _ of its object set against its siblings object set , as described in section [ sec : basic ] .further , we can employ the practically efficient technique _diffset _ as in charm(-l ) for both our sprout procedure and subset testing operations .we are testing the performance of the diffset based implementation on the available benchmarks and the results will be reported elsewhere .our interest in fca stems from our research in microarray data analysis .we have implemented an not yet optimized version of our algorithm ( with less than 500 effective lines in c++ ) .the program is very efficient for our applications , in which our data consists of about 10000 objects and 29 attributes .it took less than 1 second for the program to produce the concept lattice ( about 530 vertices / concepts and 1500 edges ) in a pentium iv 3.0ghz computer with 2 g memory running under fedora 2 linux os .the program is available upon request at this point and will release to the public in the near future .  as fca finds more and more applications , especially in bioinformatics , efficient algorithms for constructing concept / galois latticesare much needed .our algorithm is faster than the existing algorithms for this problem , nevertheless , it seems to have much room to improve .we would like to thank reinhard laubenbacher for introducing us fca .we thank yang huang for his participation in his project .v. choi , y. huang , v. lam , d. potter , r. laubenbacher , k. duca . using formal concept analysis for microarray data comparison ._ dimacs workshop on clustering problems in biological networks .piscataway , new jersey , may 911 , 2006 .manuscript in preparation .t. kashiwabara , s. masuda , k. nakajima , t. fujisawa .generation of maximal independent sets of a bipartite graph and maximum cliques of a circular - arc graph ., 13 , p161174 , 1992 .johnson , m. yannakakis , c.h .papadimitriou . on generating all maximal independent sets . , 27 , p119123 , 1988search in ; denote by ; is not necessary a concept .insert into , and associate it with the attribute set ; identify as the successor of ; sprout ; enqueue into ; identify as the successor of ;

Abstract: in this paper , we present a fast algorithm for constructing a concept ( galois ) lattice of a binary relation , including computing all concepts and their lattice order . we also present two efficient variants of the algorithm , one for computing all concepts only , and one for constructing a frequent closed itemset lattice . the running time of our algorithms depends on the lattice structure and is faster than all other existing algorithms for these problems .


matching is of central importance to natural language processing . in fact , many problems in natural language processing can be formalized as matching between two short - texts , with different matching relations in different applications .for example , in paraphrase identification the relation is synonymy , and in information retrieval it is relevance . in the meantime matching is also a challenging problem , since it requires modeling of the two short - texts as well as their relation . in machine translation , for example, the model needs to determine whether a sentence in the source language has the same meaning as a sentence in the target language . in dialogue, the model needs to judge whether a message is an appropriate response to a given utterance .deep neural network can model non - linear and hierarchical relations  , and thus is well suited for short - text matching in natural language processing . the very limited work in that thread ,makes use of word embedding as the building blocks of matching model .although embedding - based methods have been proven effective on tasks like question answering  , paraphrase identification  , and even short text conversation , they are not enough good at handling the subtlety of general short - text matching. short - texts often represent rich content , their relations are also complicated , and more sophisticated structures are required for comparing the two short - texts .for example , when judging the appropriateness of response ` you should rest more . ` " to utterance `i have to work during the weekend ! ` " , we have to consider the semantic correspondence between work over the weekend " and need to rest more " , which is hard to be captured by an embedding - based model .we study the problem of short - text matching in a general setting .our method , named _ deep match tree _ ( deepmatch ) , consists of two sequentially connected components : 1 ) a mining algorithm to discover rich yet subtle patterns , defined in the product space of dependency trees , from a large corpus of paired short - texts , and 2 ) a learning algorithm to construct a deep neural network ( dnn ) for making a matching decision on the two short - texts , on the basis of the mined patterns .the dnn model is specifically trained based on contrastive sampling of negative examples .  without loss of generality , we focus on the task of matching a response to a given tweet on weibo , a popular chinese microblog service , for which a large amount of data is available .this is a hard problem , requiring consideration of complicated correspondence between the structures of two texts .our experimental results show that deepmatch is superior to existing methods on the problem .our main contributions are : 1 ) proposal of an algorithm for mining dependency tree matching patterns on large scale , 2 ) proposal of an algorithm for learning a deep matching model for using mined matching patterns , and 3 ) empirical validation of the efficacy and efficiency of the proposed method using large scale real datasets .  [cols="^,^ " , ]   suppose that for we want to pick a more appropriate response from candidates and .the mining algorithm ( algorithm 1 ) discovers the following pattern after the sameentity abstraction where stands for any named entity .this pattern ( and its own sub - patterns ) then plays an important role in the later matching model in assigning a higher matching score to ( , ) , covering more specific patterns like which are filtered out in the mining step for its small support .the proposed model is related to several threads of work in natural language processing and machine learning .  [ [ deep - matching - models ] ] deep matching models + + + + + + + + + + + + + + + + + + + +  there are other works on using deep neural networks for the matching task  , which build upon given or learned representations of objects . in our model , we try to directly mine and learn the representations of matching .[ [ graph - based - kernel ] ] graph - based kernel + + + + + + + + + + + + + + + + + +  deepmatch extends the important notions in conventional graph kernels in two senses .first , our model allows matching of two different subgraphs in two domains ( e.g. , \{`work` ` weekend ` } in one domain and \{`have` ` rest ` } in the other ) , while graph kernels only consider the common subgraphs on two sides .second , our model captures the nonlinear and hierarchical relations between different matching patterns , while graph kernels simply add them together , with different weights determined by the types of sub - graphs .[ [ string - rewriting - kernel ] ] string - rewriting kernel + + + + + + + + + + + + + + + + + + + + + + +  deepmatch is also related to the string - rewriting kernel ( srk ) for paraphrase identification , inthat srk also generates many patterns of matching and learns to weigh them in training .the main difference is the matching patterns considered in srk are exhaustively enumerated ( although calculated in a smart way ) , while ours are discovered via a mining algorithm .we propose a generic model for matching two short - texts , which relies on a tree - mining algorithm to discover a vast amount of matching patterns and a dnn to further perform the task using those patterns .empirical study on the rather difficult task of tweet and response matching shows that our model can outperform competitor with large margins .this work is supported in part by china national 973 project 2014cb340301 .qun liu s work is partially supported by the science foundation ireland ( grant 12/ce / i2267 and 13/rc/2106 ) as part of the adapt centre at dublin city university .

Abstract: many tasks in natural language processing , ranging from machine translation to question answering , can be reduced to the problem of matching two sentences or more generally two short texts . we propose a new approach to the problem , called deep match tree ( deepmatch ) , under a general setting . the approach consists of two components , 1 ) a mining algorithm to discover patterns for matching two short - texts , defined in the product space of dependency trees , and 2 ) a deep neural network for matching short texts using the mined patterns , as well as a learning algorithm to build the network having a sparse structure . we test our algorithm on the problem of matching a tweet and a response in social media , a hard matching problem proposed in , and show that deepmatch can outperform a number of competitor models including one without using dependency trees and one based on word - embedding , all with large margins .


the problem of extracting scientific parameters from dirty ( dominated by artifacts ) interferometric radio images has resulted in many deconvolution algorithms being developed . however, none of these solve the problem of incorporating instrumental errors as a source of uncertainty when making measurements from radio data .deconvolution algorithms can only produce one image , which the scientist must then assume is correct before extracting any science ( for example , a catalogue of source fluxes ) from it .algorithms such as clean ( ) , the most popular algorithm in use , can not reliably produce any uncertainties ( ) , making it impossible to propagate the uncertainties from instrumental errors to the scientific parameters .further , if these parameters are correlated , as they likely are , even correcting the data for instrumental errors may lead to biased scientific results , as the measurement of the instrumental error may be wrong . these instrumental effects will become more important as more sensitive telescopes such as the square kilometre array come online .we propose in , a completely different approach , whereby we model the sky and all known sources of instrumental error simultaneously using the radio interferometry measurement equation ( rime ) ( ) .the rime can be written as ( ) : where is the visibility matrix ( the radio data ) , is the jones matrix for antenna ( containing instrumental effects ) and is the brightness matrix ( containing the sky model , and hence all scientific parameters ) .we use the software package meqtrees ( ) , which implements the rime , to model our radio field and any known instrumental effects . we can then estimate the parameters of this model , both scientific and instrumental , in a bayesian context using a sampling method such as mcmc ( ) .we assume uncorrelated gaussian noise on the visibilities which leads to a simple gaussian likelihood for . with this approach ,we are able to determine the full posterior for the problem , obtaining not only the best fits for all parameters , but also their uncertainties and correlations .figure [ fig : field ] shows the mock wsrt field which we tested biro on .this field , simulated using meqtrees and based on a real field , consists of 17 point sources .we also applied pointing errors to each antenna as an example of a source of instrumental error , which wsrt ( and many other radio telescopes ) have had to deal with in the past ( ) .a mispointed antenna will observe a point source through the edge rather than the centre of its beam .thus , in general , we would expect pointing errors and fluxes to be correlated and we apply our method to determine these correlations , as well as the parameters themselves .the instrumental parameters for this simulated data consist of the pointing errors , the width of the primary beam and the noise on the visibilities , which we assume to be gaussian , as is widely considered a good approximation .we allow the pointing errors to vary in time as second ordr polynomial functions , resulting in 84 pointing error parameters , 3 parameters for each direction for each antenna .our scientific parameters include the flux for each source , and the shape parameters of the extended gaussian source .we compared biro with the standard , commonly used clean algorithm combined with a source extraction algorithm on the cleaned image ( we call this clean+se ) for this dataset .figure [ fig : compare ] illustrates this comparison for the estimated fluxes from biro and clean+se . with no knowledge of the pointing errors , it is no surprise that clean+se returns biased fluxes and fails to find several sources .the danger is that the error bars , estimated using only the surrounding flux of the point source in this source extraction algorithm , do not and can not take into account the additional source of uncertainty from the instrumental errors .in contrast , the biro estimates are unbiased and the error bars are larger , correctly propagating the instrumental errors , and determining the correlations between parameters ( figure [ fig : covmat ] ) .  , due to the strong correlations between pointing error and flux . ]-plane , while the pointing errors are correlated simply because every pointing error affects every source . of particular interest is the complex way in which pointing errors correlate with the fluxes , which would be very difficult to determine from first principles.,scaledwidth=55.0% ]we have introduced biro , a bayesian approach to the deconvolution problem of radio interferometry observations .figure [ fig : covmat ] highlights the importance of fully propagating the uncertainty on instrumental errors , as they can be highly correlated with the scientific parameters and hence bias scientific results . due to the fully bayesian nature of biro, it allows for very elegant extensions to this simple scenario .for example , the choice of model for the field can be selected for using the bayesian evidence ( see ) .biro can be useful in any scenario where reliable statistics are required for the science extracted and may be essential to fully exploit the sensitivity of the ska .1974 , _ a&as _, 15 , 417  2013 , _arxiv:1311.5282 _  2015 , _ mnras _ , 450 , 1308  1996 , _ a&as _ , 117 , 137 - 147  2010 , _ a&a _ , 524 , a61  2011 , _ a&a_ , 527 , a106  1953 , _ j. chem ._ , 21 , 1087  1970 , _ biometrika _ , 57 , 97 - 109  2011 _ arxiv:1110.2916 _ml and jz are grateful to the south africa national research foundation square kilometre array project for financial support .ml acknowledges support from the university of cape town and resources from the african institute for mathematical sciences .os is supported by the south african research chairs initiative of the department of science and technology and national research foundation .in acknowledges the meerkat hpc for radio astronomy programme .part of the computations were performed using facilities provided by the university of cape town s icts high performance computing team : http://hpc.uct.ac.za .

Abstract: radio interferometers suffer from the problem of missing information in their data , due to the gaps between the antennas . this results in artifacts , such as bright rings around sources , in the images obtained . multiple deconvolution algorithms have been proposed to solve this problem and produce cleaner radio images . however , these algorithms are unable to correctly estimate uncertainties in derived scientific parameters or to always include the effects of instrumental errors . we propose an alternative technique called bayesian inference for radio observations ( biro ) which uses a bayesian statistical framework to determine the scientific parameters and instrumental errors simultaneously directly from the raw data , without making an image . we use a simple simulation of westerbork synthesis radio telescope data including pointing errors and beam parameters as instrumental effects , to demonstrate the use of biro .