ACL for learning from Incomplete Information
We can apply ACL to learn from incomplete information using ACL1 version
2. The background knowledge must be represented as an abductive logic
program containing the definitions of background predicates, written using
the usual prolog syntax, the definition of abducible predicates and, possibly,
the definition of integrity constraints. Every predicate on which
you have incomplete information must be considered as an abducible predicate.
Consider the case of Example 1:
the information on male and female is incomplete and therefore they must
be considered as abducibles by including the following clause in the background
Moreover, any extra information that you may have available on incomplete
predicates can be encoded by means of integrity constraints. In the
case of Example 1, we know
that a person may not be at the same time a male and a female, therefore
we can consider the constraint :-male(X),female(X). by adding the following
clause to the background knowledge:
The detailed description of how to write the input file <file_stem>.bg
is described below. After having prepared the input files, the learning
is performed by running ACL1 as described in the instructions
on how to run ACL1 version 2.
Input files format:
Format of <file_stem>.bg :
Consider father.bg as an example, corresponding
to example 1
in the theoretical framework page.
each target predicate must have a "bias" clause
The <list of allowed literals> is the list of all the possible
<list of variables>,
<list of allowed
can be added to the rule <head>:-<body>
<body> is a template that can be used in order to specialize
the clauses accordingly to what is already in the body.
In the example below is a variable so that any rule can be refined with
the literals in the list. The <list of variables>
must contain the list of all the variables that may appear in the rule
or its refinements and must be the same for all bias facts relative to
the same predicate.
abducibles(<list of abducible predicates>).
The variables in the abducible predicates must be all different (use _)
ic(<list of literals in the body>).
eplus(<list of positive examples>).
eminus(<list of negative examples>).
<definitions for predicates pred1,...,predn>
:-dynamic parent/2, male/1, female/1.
Output files format:
The result of learning is a file called <file_stem>.rules
that contains the rules learned. In the case of the
example, the system produces the following file
ACL1 ver 2 AbdProofProc. ver 1
File name: father
Max spec steps=10, Beamsize=5, Derivation depth=20, Verb
Execution time 0.230000 seconds. Generated rules
/*Covered positive examples: [father(john,mary),father(david,steve)]
Covered negative examples: 
Abduced literals: [[not(father(katy,ellen)),not(male(katy))],[father(david,steve),male(david)]]*/
Back to the main ACL page.
First the name of the input <file_stem> is printed,
then the values for the parameters are shown together with the total execution
time. Then follows the rules that have been learned, together with the
set of positive and negative examples covered by them and the set of assumptions
made for covering them. In the set of assumptions, each assumption is associated
example that generated it.