# phil on SWISH Manual - SWI-Prolog Version¶

## Introduction¶

phil is a suite of programs for reasoning with hierarchical probabilistic logic programs (HPLP) [NguembangFadjaLR17]. It allows both inference and learning. phil is available only for SWI-Prolog.

phil is part of cplint on SWISH web application available at http://cplint.eu.

## Installation¶

phil is distributed as a pack of SWI-Prolog. To install it, use

```
$ swipl
?- pack_install(phil).
```

### Requirements¶

It requires the packs

They are installed automatically when installing pack phil or can be installed manually as follows

```
$ swipl
?- pack_install(auc).
?- pack_install(matrix).
```

You can upgrade the pack with

```
$ swipl
?- pack_upgrade(phil).
```

Note that the packs on which phil depends are not upgraded automatically. In this case, they need to be upgraded manually.

### Example of use¶

```
$ cd <pack>/phil/prolog/examples
$ swipl
?- [uwcse].
?- inference_hplp(advisedby(harry,ben),ai,Prob).
```

### Testing the installation¶

```
$ swipl
?- [library(phil_test/test)].
?- test.
```

### Datasets¶

Other machine learning datasets are available in pack phil_datasets.

## Syntax¶

phil allows the definition of discrete probability distributions. It performs inference, parameter and structure learning on Hierarchical Probabilistic Logic Programs (HPLPs) [NguembangFadjaLR17].

HPLPs are restrictions of Logic programs with annotated disjunctions LPADs ([VV03][VVB04]). A HPLP is a set of annotated clauses whose head contain a single atom annotated with a probability. For the rest, the usual syntax of Prolog is used. A general HPLP clause has the following form:

```
h:p:- BodyInput, b1,b2...,bn.
```

where `BodyInput`

is a conjunction of predicates called input predicates, that are defined by certain facts and rules, and the `bi`

are predicates non explicitly defined in the data called hidden predicates. Each hidden predicate is described by a set of clauses in a level immediately bellow. e.g `b1`

can be described as follows:

```
b1:p1_1:- BodyInput1, b1_11,b1_12...,b1_1m.
b1:p1_2:- BodyInput2, b1_21,b1_22...,b1_2m.
...
b1:p1_k:- BodyInputk, b1_k1,b1_k2...,b1_km.
```

Each `b1_ij`

is also described by a set clauses in the layer immediately bellow. This creates an hierarchy among predicates and clauses. Programs having this structure are called hierarchical probabilistic logic programs. The predicate in the head of clauses in the first layer is called `target`

or `output`

predicate which is the predicate we are interested in predicting.
The `p1_i`

are numeric expressions representing probabilities.
It is up to the user to ensure that their are legal, i.e. they are greater than zero and less than one. The first clause above states that if the conjunction of the input and the hidden predicates in the body is true, then the head is true is true with probability `p`

otherwise, the head is false with probability `1-p`

. Note that, hidden predicates in the body of clauses in the programs are all different.
If the clause has an empty body, it can be represented like this:

```
h:p.
```

If the clause is annotated with probability 1, the annotation can be omitted and the clause takes the form of a normal prolog clause, i.e.:

```
h :- Body.
```

stands for:

```
h:1 :- Body.
```

The following example inspired from the UWCSE dataset used in [KD05] is represented as (file uwcse.pl)

```
advisedby(A,B):0.3 :-student(A),professor(B),project(A,C),project(B,C),hid_1(A,B,C).
advisedby(A,B):0.6 :-student(A),professor(B),ta(C,A),taughtby(C,B).
hid_1(A,B,C): 0.2 :- publication(D,A,C),publication(D,B,C).
student(harry). professor(ben).
project(harry,pr1). project(harry,pr2).
project(ben,pr1). project(ben,pr2).
taughtby(c1,ben). taughtby(c2,ben).
ta(c_1,harry). ta(c_2,harry).
publication(p1, harry, pr1). publication(p2, harry, pr1).
publication(p3, harry, pr2). publication(p4, harry, pr2).
publication(p1, ben, pr1). publication(p2, ben, pr1).
publication(p3, ben, pr2). publication(p4, ben, pr2).
```

where publication(A,B,C) means that A is a publication with author B produced in project C. advisedby/2 is the target predicate, student/1, professor/1, project/2, ta/2, taughtby/2 and publication/3 are input predicates and hid_1/3 is a hidden predicate.

The first clause states that a student A is advised by a professor B with probability 0.3 if they both work on the same project C and the predicate hid_1(A,B,C) is true. The second states that a student A is advised by a professor B with probability 0.6 if the student is a teacher assistant in a course taught by the professor. The third clause is a hidden clause which acts as an aggregation of publications coauthored by the student and his/her professor from a certain project.

The facts in the program state that harry is a student and ben a professor. They have two joint courses c1 and c2, two joint projects pr1 and pr2, two joint publications p1 and p2 from project pr1 and two joint publications p3 and p4 from project pr2.

## Semantics¶

The semantics of HPLPs directly inherits the semantics of LPADs. In the case of programs without function symbols, the semantics of HPLPs is given as follows: an HPLP defines a probability distribution over normal logic programs called *worlds*.
A world is obtained from the HPLP by first grounding it, and by including in the world or no each ground clause (without the probability annotation).
The probability of a world is the product of the probabilities associated to the heads of each selected ground clause.
The probability of a ground atom (the query) is given by the sum of the probabilities of the worlds where the query is true.

If the HPLP contains function symbols, the definition is more complex, see [Poo97][SK01].

## Inference¶

phil answers queries using the module phil. It performs exact inference using a program transformation technique. Each program is converted to a set of arithmetic circuits (ACs) or deep neural networks using a modified version of PITA [Rig14] with tabling and answer subsumption [RS10] as described in [NguembangFadjaLR17].

For answering queries, you have to prepare a Prolog file where you first load the inference module `phil`

, initialize it with the directive `:- phil`

and then enclose the hierarchical program clauses in `:-begin_in.`

and `:-end_in.`

or enclose the clauses in `in([<clauses>])`

.
For example, the uwcse program above can be stored in uwcse.pl for performing inference with `phil`

as follows

```
:- use_module(library(phil)).
:- phil.
:- begin_in.
advisedby(A,B):0.3 :-student(A),professor(B),project(A,C),project(B,C),hid_1(A,B,C).
advisedby(A,B):0.6 :-student(A),professor(B),ta(C,A),taught\_by(C,B).
hid_1(A,B,C): 0.2 :- publication(D,A,C),publication(D,B,C).
:- end_in.
begin(model(ai)).
student(harry). professor(ben).
project(harry,pr1). project(harry,pr2).
project(ben,pr1). project(ben,pr2).
taughtby(c1,ben). taughtby(c2,ben).
ta(c_1,harry). ta(c_2,harry).
publication(p1, harry, pr1). publication(p2, harry, pr1).
publication(p3, harry, pr2). publication(p4, harry, pr2).
publication(p1, ben, pr1). publication(p2, ben, pr1).
publication(p3, ben, pr2). publication(p4, ben, pr2).
end(model(ai)).
```

You can also have (non-probabilistic) clauses outside `:-begin/end_in.`

which can be enclosed in `bg(<list of terms representing clauses>).`

These are considered as database clauses.

To run a query, you can simply load the Prolog file, for example uwcse.pl, as:

```
?- [uwcse].
```

or:

```
$ swipl uwcse.pl
```

and run the query:

```
?- inference_hplp(advisedby(harry,ben),ai,Prob).
```

where `advisedby(harry,ben)`

is the atom for the target predicate, `ai`

the interpretation or the model where the query is run and `Prob`

stores the computed probability. For also generating the arithmetic circuit, run the query:

```
?- inference_hplp(advisedby(harry,ben),ai,Prob,Circuit).
```

where `Circuit`

stores the arithmetic circuit as a Prolog term.

## Learning¶

The following learning algorithms are available:

PHIL for Parameter learning for HIerarchical probabilistic Logic programs. Given an input HPLP, PHIL learns its parameters from data. Two versions of PHIL are implemented:

- DPHIL (Deep PHIL) [NFRL18b] performs gradient descent over the ACs. Two regularizations of DPHIL are implemented: L1 and L2 regularizations as used in the deep learning community.
- EMPHIL (Expectation Maximization PHIL) [NFRL18a] performs EM. Three regularizations of EMPHIL are implemented: besides the previous two regularizations, a regularization based on Bayesian update of the parameters is also implemented.

SLEAHP for Structure LEArning of Hierarchical Probabilistic logic programming, learns both the structure and the parameters of HPLPs from data. SLEAHP performs structure learning by parameter learning. From the data, a set of bottoms clauses are generated. Then a tree of literals appearing in the bottom clauses is created. A very large HPLP with initial parameters (randomly chosen) is randomly generated from the tree. Finally, a regularized version of PHIL is performed on the initial HPLP and clauses with very small values of probability are dropped.

### Input¶

To execute the learning algorithms, prepare a Prolog file divided in five parts

- preamble
- background knowledge, i.e., knowledge valid for all interpretations
- hierarchical program for which you want to learn the parameters (optional for SLEAHP)
- language bias information
- example interpretations

The preamble must come first, the order of the other parts can be changed.

For example, consider the Bongard problems of [DRVL95]. bongard.pl and bongardkeys.pl represent a Bongard problem for SLEAHP.

#### Preamble¶

In the preamble, the PHIL library is loaded with (bongard.pl):

```
:- use_module(library(phil)).
```

Now you can initialize with

```
:- phil.
```

At this point you can start setting parameters for SLEAHP such as for example

```
:- set_hplp(megaex_bottom,10).
:- set_hplp(rate,0.95).
:- set_hplp(max_layer,-1).
:- set_hplp(min_probability,0.00001).
:- set_sc(verbosity,1).
```

We will later see the list of available parameters.

#### Background and Initial hierarchical program¶

Now you can specify the background knowledge with a fact of the form

```
bg(<list of terms representing clauses>).
```

where the clauses must be deterministic.
Alternatively, you can specify a set of clauses by including them in a section between `:- begin_bg.`

and `:- end_bg.`

Moreover, you can specify an initial program with a fact of the form

```
in(<list of terms representing clauses>).
```

The initial program is used in parameter learning for providing the structure.
Remember to enclose each clause in parentheses because `:-`

has the highest precedence.

For example, bongard.pl has the initial program

```
in([(pos:0.197575 :-
circle(A),
in(B,A)),
(pos:0.000303421 :-
circle(A),
triangle(B)),
(pos:0.000448807 :-
triangle(A),
circle(B))]).
```

Alternatively, you can specify an input program in a section between `:- begin_in.`

and `:- end_in.`

as for example

```
:- begin_in.
pos:0.197575 :-
circle(A),
in(B,A).
pos:0.000303421 :-
circle(A),
triangle(B).
pos:0.000448807 :-
triangle(A),
circle(B).
:- end_in.
```

If you specify both a `in/1`

fact and a section, the clauses of the two will be combined.

The annotations of the head atoms of the initial program can be probabilities, as in the example above. In parameter learning, the learning procedure can start with the initial parameters in the program. In this case, it is up to the user to ensure that there are values between 0 and 1. In the case of structure learning, the initial program is not necessary.

#### Language Bias¶

The language bias part contains the declarations of the input and output predicates. Note that the hidden predicates are not declared since there are automatically generated. The output predicate is declared as

```
output(<predicate>/<arity>).
```

and indicates the predicate whose atom you want to predict. Derivations for the atoms for this predicate in the input data is built by the system. Input predicates are those whose atoms you are not interested in predicting. You can declare input predicates with

```
input(<predicate>/<arity>).
```

For these predicates, the only true atoms are those in the interpretations and those derivable from them using the background knowledge.

Then, for structure learning you have to specify the language bias by means of mode declarations in the style of Progol.

```
modeh(<recall>,<predicate>(<arg1>,...)).
```

specifies the atoms that can appear in the head of clauses. In hierarchical programs only the ouput and the hidden predicates can appear in the head of clauses.

```
modeb(<recall>,<predicate>(<arg1>,...)).
```

specifies the atoms that can appear in the body of clauses. `<recall>`

can be an integer or `*`

. `<recall>`

indicates how many atoms for the predicate specification are retained in the bottom clause during a saturation step. `*`

stands for all those that are found.
Otherwise the indicated number of atoms are randomly chosen.

Arguments of the form

```
+<type>
```

specifies that the argument should be an input variable of type `<type>`

, i.e., a variable replacing a `+<type>`

argument in the head or a `-<type>`

argument in a preceding literal in the current hypothesized clause.

Another argument form is

```
-<type>
```

for specifying that the argument should be a output variable of type `<type>`

.
Any variable can replace this argument, either input or output.
The only constraint on output variables is that those in the head of a clause must appear as output variables in an atom in the body.

Other forms are

```
#<type>
```

for specifying an argument which should be replaced by a constant of type `<type>`

in the bottom clause but should not be used for replacing input variables of the following literals when building the bottom clause or

```
-#<type>
```

for specifying an argument which should be replaced by a constant of type `<type>`

in the bottom clause and that should be used for replacing input variables of the following literals when building the bottom clause.

```
<constant>
```

for specifying a constant.

An example of language bias for the Bongard domain is

```
output(pos/0).
input(triangle/1).
input(square/1).
input(circle/1).
input(in/2).
input(config/2).
modeh(*,pos).
modeb(*,triangle(-obj)).
modeb(*,square(-obj)).
modeb(*,circle(-obj)).
modeb(*,in(+obj,-obj)).
modeb(*,in(-obj,+obj)).
modeb(*,config(+obj,-#dir)).
```

SLEAHP also requires facts for the `determination/2`

Aleph-style predicate that indicate which predicates can appear in the body of clauses.
For example

```
determination(pos/0,triangle/1).
determination(pos/0,square/1).
determination(pos/0,circle/1).
determination(pos/0,in/2).
determination(pos/0,config/2).
```

state that `triangle/1`

can appear in the body of clauses for `pos/0`

.

#### Example Interpretations¶

The last part of the file contains the data.
You can specify data with two modalities: models and keys.
In the models case, you specify an example model (or interpretation or mega-example) as a list of Prolog facts initiated by `begin(model(<name>)).`

and terminated by `end(model(<name>)).`

as in

```
begin(model(2)).
pos.
triangle(o5).
config(o5,up).
square(o4).
in(o4,o5).
circle(o3).
triangle(o2).
config(o2,up).
in(o2,o3).
triangle(o1).
config(o1,up).
end(model(2)).
```

The facts in the interpretation are loaded in SWI-Prolog database by adding an extra initial argument equal to the name of the model.
After each interpretation is loaded, a fact of the form `int(<id>)`

is asserted, where `id`

is the name of the interpretation.
This can be used in order to retrieve the list of interpretations.

Alternatively, with the keys modality, you can directly write the facts and the first argument will be interpreted as a model identifier. The above interpretation in the keys modality is

```
pos(2).
triangle(2,o5).
config(2,o5,up).
square(2,o4).
in(2,o4,o5).
circle(2,o3).
triangle(2,o2).
config(2,o2,up).
in(2,o2,o3).
triangle(2,o1).
config(2,o1,up).
```

which is contained in the bongardkeys.pl.
This is also how model `2`

above is stored in SWI-Prolog database.
The two modalities, models and keys, can be mixed in the same file.
Facts for `int/1`

are not asserted for interpretations in the key modality but can be added by the user explicitly.

Note that you can add background knowledge that is not probabilistic directly to the file writing clauses taking into account the model argument.
For example (`carc.pl`

), available in phil_datasets, contains

```
connected(_M,Ring1,Ring2):-
Ring1 \= Ring2,
member(A,Ring1),
member(A,Ring2), !.
symbond(Mod,A,B,T):- bond(Mod,A,B,T).
symbond(Mod,A,B,T):- bond(Mod,B,A,T).
```

where the first argument of all atoms is the model.

Then you must indicate how examples are divided in folds with facts of the form: `fold(<fold_name>,<list of model identifiers>)`

, as for example

```
fold(train,[2,3,...]).
fold(test,[490,491,...]).
```

As the input file is a Prolog program, you can define intentionally the folds as in

```
fold(all,F):-
findall(I,int(I),F).
```

`fold/2`

is dynamic so you can also write

```
:- fold(all,F),
sample_hplp(4,F,FTr,FTe),
assert(fold(rand_train,FTr)),
assert(fold(rand_test,FTe)).
```

which however must be inserted after the input interpretations otherwise the facts for `int/1`

will not be available and the fold `all`

would be empty.
This command uses `sample_hplp(N,List,Sampled,Rest)`

exported from `phil`

that samples `N`

elements from `List`

and returns the sampled elements in `Sampled`

and the rest in `Rest`

.
If `List`

has `N`

elements or less, `Sampled`

is equal to `List`

and `Rest`

is empty.

### Commands¶

#### Parameter Learning¶

To execute PHIL, prepare an input file as indicated above and call

```
?- induce_hplp_par(+List_of_folds:list,-P:list).
```

where `<list of folds>`

is a list of the folds for training and `P`

will contain the input program with updated parameters.

For example bongard.pl, you can perform parameter learning on the `train`

fold with

```
?- induce_hplp_par([train],P).
```

#### Structure Learning¶

To execute SLEAHP, prepare an input file in the editor panel as indicated above and call

```
?- induce_hplp(+List_of_folds:list,-P:list).
```

where `List_of_folds`

is a list of the folds for training and `P`

will contain the learned program.

For example bongard.pl, you can perform structure learning on the `train`

fold with

```
?- induce_hplp([train],P).
```

A program can also be tested on a test set with `test_hplp/7`

as described below.

Between two executions of `induce_hplp/2`

you should exit SWI-Prolog to have a clean database.

#### Testing¶

A program can also be tested on a test set in SLEAHP with

```
test_hplp(+Program:list,+List_of_folds:list,-LL:float,-AUCROC:float,-ROC:list,-AUCPR:float,-PR:list) is det
```

where `Program`

is a list of terms representing clauses and `List_of_folds`

is a list of folds.

`test_hplp/7`

returns the log likelihood of the test examples in `LL`

, the Area Under the ROC curve in `AUCROC`

, a dictionary containing the list of points (in the form of Prolog pairs `x-y`

) of the ROC curve in `ROC`

, the Area Under the PR curve in `AUCPR`

, a dictionary containing the list of points of the PR curve in `PR`

.

Then you can draw the curves in `phil`

using C3.js as follows

```
compute_areas_diagrams(+ExampleList:list,-AUCROC:float,-ROC:dict,-AUCPR:float,-PR:dict) is det
```

(from pack auc.pl) that takes as input a list `ExampleList`

of pairs probability-literal.

For example, to test on fold `test`

the program learned on fold `train`

you can run the query

```
?- induce_hplp_par([train],P),
test_hplp(P,[test],LL,AUCROC,ROC,AUCPR,PR).
```

Or you can test the input program on the fold `test`

with

```
?- in(P),test_hplp(P,[test],LL,AUCROC,ROC,AUCPR,PR).
```

In `phil`

on SWISH, by including

```
:- use_rendering(c3).
:- use_rendering(lpad).
```

in the code before `:- phil.`

the curves will be shown as graphs using C3.js and the output program will be pretty printed.

### Hyper-parameters for Learning¶

Hyper-parameters are set with commands of the form

```
:- set_hplp(<parameter>,<value>).
```

They are available both for PHIL and SLEAHP:

PHIL hyper-parameters

`algorithmType`

(values:`{dphil,emphil}`

, default value:`dphil`

): defines the parameter learning algorithm.`maxIter_phil`

(values: integer, default value: 1000): maximum number of iteration of PHIL. If set to -1, no maximum number of iterations is imposed.`epsilon_deep`

(values: real, default value: 0.0001): if the difference in the log likelihood in two successive PHIL (DPHIL and EMPHIL) iteration is smaller than`epsilon_deep`

, then PHIL stops.`epsilon_deep_fraction`

(values: real, default value: 0.00001): if the difference in the log likelihood in two successive PHIL iteration is smaller than`epsilon_deep_fraction*(-current log likelihood)`

, then PHIL stops.`seed`

(values: seed(integer) or seed(random), default value`seed(3032)`

): seed for the Prolog random functions, see SWI-Prolog manual .`setSeed`

(values:`{no,yes}`

, default value:`no`

): if`yes`

, the value of`c_seed`

is used as seed for randomly initializing the probabilities in PHIL otherwise the actual clock value is used.`c_seed`

(values: unsigned integer, default value 21344)): seed for the C random functions if`setSeed`

is set to`yes`

.`useInitParams`

(values:`{no,yes}`

, default value:`no`

): if`yes`

the initial parameters during the learning are the ones indicated in the program. Otherwise, the initial parameters are generated randomly using the clock seed.`logzero`

(values: negative real, default value \(\log(0.000001)\)): value assigned to \(\log(0)\).`zero`

(values: real, default value \(0.000001\)): value assigned to \(0\).`max_initial_weight`

(values: real number , default value: 0.5): weights in DPHIL are randomly initialized with values in the interval [-max_initial_weight, max_initial_weight].`adam_params`

(values: list of four values [learningRate, beta1, beta2, epsilon], default value: [0.001,0.9,0.999,1e-8]): provides Adam’s hyper-parameters.`batch_strategy`

(values:`minibatch(size)`

,`stoch_minibatch(size)`

,`batch`

, default value:`minibatch(10)`

): defines the gradient descent strategy in DPHIL. If set to`minibatch(size)`

the mini batch strategy with batch size`size`

is used i.e at each iteration,`size`

arithmetic circuits (ACs) are used to compute the gradients. If set to`batch`

the whole set of ACs are used to compute the gradients.`stoch_minibatch(size)`

is a modified version of mini batch in which at each iteration,`size`

ACs are randomly selected for computing the gradients.`saveStatistics`

(values:`{no,yes}`

, default value:`no`

): if`yes`

, the statistics (evolution of the likelihood and other values) during parameter learning are saved in a folder whose name is the value of`statistics_folder`

hyper-parameter.`statistics_folder`

(values: string , default value:`statistics`

): folder where to save the statistics if`saveStatistics`

is set to`yes`

.`regularized`

(values:`{no,yes}`

, default value:`no`

): if set to`yes`

regularization is enabled.`regularizationType`

(values: integer in`[0,3]`

, default value:`0`

):`0`

to disable regularization,`1`

,`2`

and`3`

for L1, L2 and Bayesian regularization respectively.`gamma`

(values: real number, default value:`10`

): regularization coefficient for L1 and L2. Is equal to the Dirichlet coefficient`a`

for Bayesian regularization.`gammaCount`

(values:real number , default value: 0): Dirichlet coefficient`b`

for Bayesian regularization and typically 0 for L1 and l2 regularization.

SLEAHP hyper-parameters

`megaex_bottom`

(values: integer, default value: 1, valid for SLEAHP): number of mega-examples on which to build the bottom clauses.`initial_clauses_per_megaex`

(values: integer, default value: 1, valid for SLEAHP): number of bottom clauses to build for each mega-example (or model or interpretation).`d`

(values: integer, default value: 1, valid for SLEAHP): number of saturation steps when building the bottom clause.`neg_ex`

(values:`given`

,`cw`

, default value:`cw`

): if set to`given`

, the negative examples in training and testing are taken from the test folds interpretations, i.e., those examples`ex`

stored as`neg(ex)`

; if set to`cw`

, the negative examples in training and testing are generated according to the closed world assumption, i.e., all atoms for target predicates that are not positive examples. The set of all atoms is obtained by collecting the set of constants for each type of the arguments of the target predicate, so the target predicates must have at least one fact for`modeh/2`

or`modeb/2`

also for parameter learning.`probability`

(values:real number in`[0,1]`

, default value:`1.0`

): initial value which indicates the probability to go from the current layer to the next when generating the initial HPLP.`rate`

(values: real number in`[0,1]`

, default value:`0.95`

): at each layer during the tree generation, the probability to go deeper is equal to`probability=probability*rate`

. The deeper the layer the lower is the probability to go deeper.`min_probability`

(values: real number in`[0,1]`

, default value:`1e-5`

): probability threshold under which a clause is dropped out.`use_all_mega_examples`

(values:`{no,yes}`

, default value:`yes`

): if set to`yes`

all the the bottom clauses are used to create the tree otherwise only one of them is used (typically the first).`saveHPLP`

(values:`{no,yes}`

, default value:`no`

): if set to`yes`

the initial and the learned hierarchical programs are saved in the current folder.`saveFile`

(values: string, default value: “hplp”): file name where to save the initial hierarchical programs if`saveHPLP`

is set to`yes`

. If the file name is`hplp`

, the learned program is saved in file`hplp_learned`

.`max_layer`

(values: integer, default value: -1): maximum layer of clauses. If set to -1, no maximum is imposed.`verbosity`

(values: integer in`[1,3]`

, default value:`1`

): level of verbosity of the algorithms.

## Example Files¶

The `pack/phil/prolog/examples`

folder in SWI-Prolog home contains some example programs.
The subfolder `learning`

contains some learning examples.
The `pack/phil/docs`

folder contains this manual in latex, html and pdf.

## Manual in PDF¶

A PDF version of the manual is available at https://arnaudfadja.github.io/phil/_build/latex/phil.pdf.

## License¶

phil follows the Artistic License 2.0 that you can find in phil root folder. The copyright is by Arnaud Nguembang Fadja.

## References¶

[DRVL95] | L. De Raedt and W. Van Laer. Inductive constraint logic. In Proceedings of the 6th Conference on Algorithmic Learning Theory (ALT 1995), volume 997 of LNAI, 80–94. Fukuoka, Japan, 1995. Springer. |

[KD05] | Stanley Kok and Pedro Domingos. Learning the structure of markov logic networks. In Proceedings of the 22nd international conference on Machine learning, 441–448. 2005. |

[NFRL18a] | Arnaud Nguembang Fadja, Fabrizio Riguzzi, and Evelina Lamma. Expectation maximization in deep probabilistic logic programming. In International Conference of the Italian Association for Artificial Intelligence, 293–306. Springer, 2018. |

[NFRL18b] | Arnaud Nguembang Fadja, Fabrizio Riguzzi, and Evelina Lamma. Learning the parameters of deep probabilistic logic programs. In Elena Bellodi and Tom Schrijvers, editors, Probabilistic Logic Programming (PLP 2018), volume 2219 of CEUR Workshop Proceedings, 9–14. Aachen, Germany, 2018. Sun SITE Central Europe. URL: http://ceur-ws.org/Vol-2219/paper2.pdf. |

[Poo97] | David Poole. The independent choice logic for modelling multiple agents under uncertainty. Artificial Intelligence, 94(1-2):7–56, 1997. |

[Rig14] | Fabrizio Riguzzi. Speeding up inference for probabilistic logic programs. CJ_J, 57(3):347–363, 2014. doi:10.1093/comjnl/bxt096. |

[RS10] | Fabrizio Riguzzi and Terrance Swift. Tabling and Answer Subsumption for Reasoning on Logic Programs with Annotated Disjunctions. In Technical Communications of the International Conference on Logic Programming, volume 7 of Leibniz International Proceedings in Informatics (LIPIcs), 162–171. Schloss Dagstuhl–Leibniz-Zentrum fuer Informatik, 2010. doi:10.4230/LIPIcs.ICLP.2010.162. |

[SK01] | Taisuke Sato and Yoshitaka Kameya. Parameter learning of logic programs for symbolic-statistical modeling. J. Artif. Intell. Res., 15:391–454, 2001. |

[VV03] | J. Vennekens and S. Verbaeten. Logic programs with annotated disjunctions. Technical Report CW386, K. U. Leuven, 2003. |

[VVB04] | J. Vennekens, S. Verbaeten, and M. Bruynooghe. Logic programs with annotated disjunctions. In International Conference on Logic Programming, volume 3131 of LNCS, 195–209. Springer, 2004. |

[NguembangFadjaLR17] | (1, 2, 3) Arnaud Nguembang Fadja, Evelina Lamma, and Fabrizio Riguzzi. Deep probabilistic logic programming. In Christian Theil Have and Riccardo Zese, editors, PLP17_B, volume 1916 of CEUR_S, 3–14. Sun SITE Central Europe, 2017. |