Rules and Facts (cyclic ?) definition in an inference engine

Question

I am working on an backwards chaining engine as a school project. Until now, I have mostly done projects in C, and so I decided to try Haskell for that projet. I have read LYAH in order to get started and have begun to implement the representation of rules and facts in my inference engine. So far, this is what I got

module Inference () where

type Op = Bool -> Bool -> Bool
type Label = String
type Fact = (Label, [Rule])
data Rule = Operation Rule Op Rule
          | Fact Fact

eval_fact:: [Label] -> Fact -> Bool
eval_fact proved (label,rules) = label `elem` proved || any (eval_rule proved) rules

eval_rule:: [Label] -> Rule -> Bool
eval_rule proved (Fact x) = eval_fact proved x
eval_rule proved (Operation r op r') =  eval_rule proved r `op` eval_rule proved r'

The idea being to have some kind of graph where Fact nodes points to Rules nodes, unless the fact is already in a list of known facts.

However, here I encounter the problem of defining my actual facts and rules.

Doing somethings like

let fact_e = ("E", [Fact ("C", [(Operation (Fact ("A", [])) (||) (Fact ("B", [])))])])

in ghci in order to represent the rules

C => E
A || B => C

That works. But I don't really see what direction to go to construct theses rules programmatically. Furthermore, I don't see how I can handle cyclic rules with that scheme (adding a rule E => A for example).

I have seen that there is ways to define self referencing data structures in haskell with the trick called "Tying the knot" on the Haskell wiki, but I don't see how (or even if) I should apply that in the present case.

My question is essentially, am I going in the right direction, or do I have it completely backward with that approach ?

P.S : It also seems to me that my code is not as concise as it should be (passing around the [Label] list, repeating eVal_rule proved many times...), but I don't really know either how to do it in another way.

Aren't you already constructing rules programmatically? That is, you're already specifying rules like `fact_e` using programming. For cyclic rules, you should be able to just put them all into one `let` block (e.g. `let x1 = val1 x2 = val2 x3 = val3 in _`), and have laziness sort out the cyclicity automatically. As for your P.S.: for passing around `[Label]`, try learning about the '`Reader` monad'. The repetition of `eval_rule proved` should get a bit better as well if you use `Reader`. — bradrn, Jun 21 '19 at 05:43
I mean I don't see how to do it dynamically, (by parsing from a file for example) and not statically writing them down in the code. About the `let`, that's what I was trying, thxs :). — VannTen, Jun 21 '19 at 15:56
For dynamically generating a list of `Fact`s, you should be able to do it like any other data structure. For instance, if you have `C => E`, you could split it up into `["C", "=>", "E"]`, then write functions to convert the individual items of the list into `Operation`s and other `Fact`s, then combine them together using the appropriate constructors. It's hard to say much else beyond that without knowing exactly what you're stuck on; are you struggling with parsing a `String`, or converting the parsed `String` into a `Fact`? — bradrn, Jun 22 '19 at 05:10
My trouble is more with the possible self reference of rules. Parsing my source into my representation is not hard, but translating to self referential expression is a bit harder. I thing the answer from @K. A. Buhr is exactly what I was trying to do. — VannTen, Jun 24 '19 at 11:03

score 2 · Accepted Answer · answered Jun 22 '19 at 16:19

The idea would be to first parse the rules into an intermediate representation that is not self referential. For example, given the representation:

type Program = [(Label, [Rule_P])]
data Rule_P = Operation_P Rule_P Op Rule_P | Fact_P Label

then the set of rules:

C => E
A || B => C
E => A
F => E

would be parsed, gathered by implication target, and represented as:

prog1 :: Program
prog1 = [ ("E", [ Fact_P "C"                                       -- C => E
                , Fact_P "F" ])                                    -- F => E
        , ("C", [ Operation_P (Fact_P "A") (||) (Fact_P "B") ])    -- A || B => C
        , ("A", [ Fact_P "E" ]) ]                                  -- E => A

Then, to convert this to a cyclically self-referential knowledge base (using your original Fact type):

type Knowledge = [Fact]

you tie the knot like so:

learn :: Program -> Knowledge
learn program = knowledge

  where

    knowledge :: [Fact]
    knowledge = [ (target, map learn1 rules_p) | (target, rules_p) <- program ]

    remember lbl = fromJust (find ((==lbl) . fst) knowledge)

    learn1 :: Rule_P -> Rule
    learn1 (Fact_P lbl) = Fact (remember lbl)
    learn1 (Operation_P rule1 op rule2) = Operation (learn1 rule1) op (learn1 rule2)

This perhaps deserves some explanation. We create knowledge by simply applying learn1 to convert each occurrence of a non-self-referential Rule_P in the original program into a self-referential Rule in the knowledge base. The function learn1 does this in the obvious recursive manner, and it "ties the knot" at each Fact_P by looking up (remembering) the label in the body of knowledge that we're in the middle of defining.

Anyway, to prove to yourself that it's self-referential, you can play with it in GHCi:

> know1 = learn prog1
> Just [Operation factA _ _] = lookup "C" know1
> Fact ("A", [factE]) = factA
> Fact ("E", [factC, _]) = factE
> Fact ("C", [Operation factA' _ _]) = factC
> Fact ("A", [factE']) = factA'

Of course, trying:

> eval_fact [] $ fromJust $ find ((=="E").fst) (learn prog1)

will loop until it runs out of memory, as it tries to (unsuccessfully) prove E from C from A from E, etc., so you'll need to add some logic to abort cyclic proofs.

Rules and Facts (cyclic ?) definition in an inference engine

1 Answers1