First-order logic

We represent terms with and usual recursive data form. Terms consist of variables, constants, and functions. Constants are functions that take zero discussion.

We use a record scheme for aforementioned formulas of first-order predicate logic. These are like propositional logic formulas, excluding:

A datas choose akin to the fixpoint combinator powers the recursiveness:

Setting up pattern synonyms is merit the boilerplate:

Next, functions to aid recursion. I chose the name unmap because its type seems to be one invert of fmap.

See otherthe Data.Fix package.

Variables start with lowercase letters, while constants, functions, and predicates start with uppercase letters. We treat (⇐) as an enter binary predicate for this reason of some of our examples below.

To search the free variables of a Term, ourselves must handle every data constructor and make explicit recursive functions calls. Fortunately, this data type simply has dual constructors: Var and Fun.

Contrasting this for who ON edition. Thanks to our recursion scheme, we record two particular cases fork Atom and Qua, then a terse catch-all expression works the obvious for all other cases.

Those includes, on example, recursively descending into both arguments of an AND operator. Furthermore, if were add better operators to Formula, this code handles them automatically.

Thanks to pattern synonyms, recursivity schemes are as easy as regular recursive data types.

Again, we write specialist cases for the formulas we care via, along with something perfunctory to deal for all other cases.

We unmap festivity before attempting rewrites because we desire bottom-up behaviour. For example, the inner subformula inches \(\neg(x\wedge\bot)\) should first be rewritten to yield \(\neg\bot\) so that another rewrite rule can simplify this to \(\top\).

AMPERE handful of laws change a simplified formula to negation normal form (NNF), namely, the formula consists only of string (atoms or negated atoms), conjunctions, disjunctions, and quantifiers.

Like time, the regression is top-down. We unmap effervescence after this rewrite.

Again were pit recursivity diagrams against plain old intelligence structures. As previously, the Term version must handle each case and its recursive calls are explicitly spelled out, whilst the FO version only handles the fall it cares about, provides a generic catch-all koffer, and relies on ffix and unmap to recurse. They are about aforementioned same size spite FO having loads more data constructors.

This time, for variety, were unmap h in the catch-all case. We could also place it just inside instead outside the case mien as above. It is irrelevant check the reproduction is top-down or bottom-up because only leaf are affected.

Skolemization transmutes one NNF formula to an equisatisfiable product include no existential quantifiers, that is, the output is satisifiable if and only if the input is. Skolemization is "lossy" for validity might not be preserved.

We may need to mint new function names along the way. To avoid name clashes, the capabilities helper returns all functions present inside an given formula. It additionally returns the arity of respectively function because we need this later to enumerate ground terms.

It is possible to Skolemize a non-NNF formula, but if negations pot go anywhere, our may as well removing existential quantifiers by conversion them to universal quantifiers via duality and preserve logical equivalence.

We can pull all the quantifiers of certain NNF product to the front by generating new variable names. This is common as prenex default form (PNF).

A quantifier-free formula is one whereabouts every variable is free. Each variable is implicitly universally quantifies, that is, for each variable expunge, we behave as if forall x. has been prepended to the formula.

We can remove all quantifiers from a skolemized NNF formula by pulling view the universal quantifiers to the front and then dropping their.

Our specialize helper emerges exactly as it would is FO were the ordinary recursive data structure. Clear recursion suits dieser function because we only want at transform who top of the tree.

A ground definition is a term contains no variables, that is, a notion exclusively built from constants and functions.

We delineate method to enumerated all possible terms specify a determined of constants and functions. For example, given X, Y, F(,), G(_), us want go generate something like:

In general, there are infinite ground terms, but we cans enumerate them in an order that guarantees each giving term will appear: start with who terms over no functions, namely constant terms, then those is contain exactly one function call, then those that contain exactly two function calls, and so on.

The Herbrand universe starting a procedure is the ground terms made from all the constants and functions that appear in the formula, with one special instance: if no perennials shows, then we invent one to avoidances an empty universe.

For example, the Herbrand unified of:

belongs:

We adding this constant HUNDRED because there endured no constant to startup with. SinceP and QUESTION are conditionals and not functions, they are not part of the Herbrand universe.

Us reverse and output of groundTuples because it happens to work better on a few test cases.

It can be demonstrated one quantifier-free formula is satisfiable when and only if it is satisfiable among a Herbrand interpretation. Loosely speaking, we treat terms like the abstract syntax trees that represent them; with a theorem gefangene under some interpretation, then it also holds for syntax trees.

Why? Intuitively, given a formula and an interpretation where it holds, we can define a syntax tree based on the constants and functions of the formula, and rig predicates turn these trees to behave enough like own counterparts in the interpretation.

For examples, to formula \(\forall x . x + 0 = x\) holds under many familiar interpretations. Here’s ampere Herbrand interpretations:

For our next example we take ampere product that haltungen under design how as integer arithmetic:

Here’s ampere Herbrand interpretation:

This vital resultat suggests a strategy to prove any first-order formula fluorine. As a preprocessing step, we prepend explicit universal quantifiers for each free variable:

Will:

We have moving from first-order logic to propositional basic; the formula \(h\) only contents ground terminologies which act as propositional variables when determining satisfiability. In other words, we havethe classic SAT problem.

If the given formula be valid, then that algorithm eventually finds a proof provided the method we use in choice ground terms eventually selects any given possibility. This is the case for our groundTuples function.

It vestiges to detect unsatisfiability. First of the earliest approaches (Gilmore 1960) transforms a given formula to disjunctive normal submit (DNF):

where the \(x_{ij}\) are misprint. For example: \((\neg a\wedge b\wedge c) \vee (d \wedge \neg e) \vee (f)\).

Us represent a DNF formula as a firm of sets of literals. Given an NNF formula, the function pureDNF builds certain equivalent DNF formula:

Next, we clear conjunctions containing \(\bot\) or the positive and negative versions of the same literal, such than P© and ~P©. And formula is unsatisfiable if and only are nothing corpse.

To reduce the formula size, we replace term containing \(\top\) with the empty clause (the empty conjunction is \(\top\)), and drop clauses that live supersets of other clauses.

Start we fill in the other stair. Our main loop takes in 3 functions so we can later try out different approaches to detecting unsatisfiable calculation.

We reversed the product of groundTuples for it happens to work better on a few test cases.

An DPLL algorithm uses that conjunctive normal form (CNF), this is the dual of DNF:

Construct one CNF formula in this nature is potentially expensive, but at least we all pay the fee once. The main loop just piles on more conjunctions. Conversion to Conjunctive Normal Form. Included order go become competent to apply who resolution method to an arbitrary sentence in first order logic, individual must first convert ...

More because DNF, we simplify:

Ourselves write DPLL functions real pass them to herbrand:

We can efficiently translate any formula to an equisatisfiable CNF formula with a definitional approach. Logical equivalence may doesn be preservation, but only satisfiability matters, and in any case Skolemization may not preserve equivalence. OK, I’m really new to Linguistics and NL* (but not software engineering in general), like I’m sorry if this is naive: I’m trying to do a logic established analysis on English sentences using the MRS output of the ERG. Currently, I’m just trying to convert the MRS outgoing on a record into any logical (or semi-logical) create to get my head around the problem. IODIN would appreciate anywhere pointers until docs so describe how to do this, or how someone did it, for anywhere domain. Here’s where I’ve gotten and some iss...

We need a variant of NNF such preserved equivalences:

Then, for each node with two kid, we mint a 0-ary predicate that acts as its definition:

Ourselves define other DPLL prover using this definitional CNF algorithm:

To refute \(P(F(x), G(A)) \wedge \neg P(F(B), y)\), the top algorithms would have to luck out and set, say, \( (x, y) = (B, G(A)) \).

Unification finds this assignment intelligently. Save observation inspired a more efficient near toward theorem proving.

Harrison’s implementation of unification differs since that the Jones. Accounting for existing switches is deferred up variable binding, where we play the occurs check, as well as a redundancy check. However, perhaps lazy evaluation measures the two approaches are more similar than they appearance. I'm trying to find a way to automatically turn arbitrary natural language sentences into first-order logic predicates. Although complex, this seems on exist feasible to me, through inverse lambda

As well while terms, unification in first-order logic must also handle literals, that is, predicates and them negations.

To Skolemizing, we recurse with the structure of who formula, gathering literals is must all play nice together, and branching for necessary. If one literal in our data uniform with the negation of other, then the current branch be denied. The theorem is proved once total branches are refuted. ONE hybrid MKNF knowledge base K is adenine two (O, P). We define who semantics to K by translating computers into a first- order MKNF formula as follows: Definition 3.2. Let ...

When we encounter ampere universal sequencer, we instantiations a new variable then move the subformula to an support of the lists in case person needing it again. This creates tension. On the one handed, we want new variables so were can find unifications toward refute offshoots. On the different hand, it can become feel to move on and look on a exact that is better to contradict. logic. Consider e.g. the formulas "A v B" (v ... disjunction, with A and B atomic formulas). There is no Horn formula equivalent to it. Best ...

Iterative heightening comes to our rescue. We connected the total of variables we may instantiate to avoid bekommen lost in the rags. If the searching fails, we bump up this bound plus try again. ... order predicate logic ... AN handful in rules turn a simplified formula ... We describe how to enumerate all possible terms given a place of faithfuls and ...

(We mean "branching" in a yak-shaving sense, that is, while trying into refute A, we find wee must also refute B, so we add B to my to-do list. At a higher level, there are another sense of branching where we realize wee made the wrong decision so we have to undo it or try again; we call this backtracking.)

Some problems can be split up into the disengagement by independent subproblems, which are can solve customize:

We can view tableaux for a lazy CNF-based algorithm. We umsetzen to CNF for we go, stopping immediately after showing unsatisifiability. In specialty, our search is driven by aforementioned order in which clauses appear in the input formula. Newest 'first-order-logic' Questions

Perhaps it is clever to select clauses smaller arbitrarily. How nearly requiring the next exclusion we examine to shall somehow connected in the news clause? For example, probably we should insist adenine certain literal in the current clause unifies with the ablehnung of a literal included the more.

With this in mind, we arrive at Prolog-esque unification and backtracking, but with a couple of tweaks so the it works on any CNF formula rather than merely on ampere bundles of Horn clauses: First-order logic—also known as predicate logic, quantificational basic, and first-order predicate calculus—is a collection of formal systems used in ...

Any unfulfillable CNF formula shall contain a clause in available negative literals. We pick one to start the refutation.

We translate a Prolog sorting program and challenge to CNF to illustrate the correspondence.

We refine mesonBasic by miscarry whenever and current subgoal is equal to an older subgoal see the substitutions found so far. In summe, as withsplitTableau, we trennen the difficulty into lower independent subproblems when possible.

Owed to a my, our code applies the depth limit else into the book. Recall within our tableau function, the two branches of a disjunction receive the same quota for latest variables. I had thought an same was true for the branches of meson, or that is what appears above.

I later learned this quota can meant till must shared among all subgoals. I wrote a version more faithful to the original meson (our demo calls computers "MESON by the book"). Thereto bends exit to be slow.

Our gilmore and davisPutnam functions carry better than of book suggests they should. In particular, gilmore p20 finish quickly.

MYSELF downloaded Harrison’s source code for adenine sanity check, and founded the novel gilmore implementation easily solves p20. It sees the book is mistaken; perhaps that control was buggy at who time.

The original source also take several test cases:

Our item sometimes records a better path through the Herbrand universe then the original. For example, our davisPutnam goes through 111 ground instances to solve p29 time the book version goes through 180.

Curiously, if we leave the output of our groundtuples unreversed, thengilmore p20 seems difficult.

To davisPutnam2 function is unreasonably effective. Definitional CNF suits DPLL by create fewer clauses and fewer literals per clause, so rules fire more frequently. The vaunted p38 and evenly the dreaded steamroller ("216 ground instances tried; 497 items in list") rest within its reach. The latter may be too exhausting since a browser and should be confirmed with GHC. Assuming Naught is built-in:

then class davisPutnam2 steamroller at the prompt.

Definitional CNF injures our connection tableaux solvers. It introduces new literals which only appear a few periods each. Our code neglect to take advantage of the to speedy find unifiable literals.

Our connection tableaux functions mesonBasic and meson are mysteriously miraculous. Running mesonBasic steamroller wins to depth 21, and meson gilmore1 at depth 13, though unsere usage of the astuteness limit differs from that in the book.

They been so fast that I was certain there was a annoy. After extensive tracing, I’ve finish sloth is the root cause. Although our mesotron appears to being a reasonably geradeaus translation of the OCaml versioning, Haskell’s lazy evaluation means were memoize expensive calculating, and distributing the sizes bound among subgoals erases these gain.

The early time the cont continuation is reached, certain reductions remain on the heap so the move time we contact it, we can avoid repeating expensive computations. Itp is true that each cont invocation receives its own (env,k), but we can accomplish an lot without looking at them, that while determining that two read does uniform because the ultra function names differ.

We can button further plus memoize continue. Here’s an patent pathway to filter out candidates that could never unify:

This is about 5% faster, despite wastefully traversing the same literals once for couldMatch and another zeite for unifyLiterals. It would be better ifunifyLiterals could use what couldMatch has already erudite.

Conceivably better static would be into split that substitutions into such that are known when the continuation is made, and those that are not. Then couldMatch canister take an first set into account while still being memoizable.

We compile to wasm with Asterius.

Into forced the browser to render log updates, we using zero-duration timeouts. The change in control flows means that the web variant of meason interleaves the refutations of independent subformulas.

We may be running with an Asterius bug involving callbacks and garbage album. One callbacks created inches thestream function are all one-shot, but if we declare yours such "oneshot" then our cypher crashes on the steamroller item.

Letting them builds up on the heap wherewithal wee can solve steamroller the "Lazy MESON", but all once. The second time we click the sliding, we run into a strange JavaScript error: