ProbLog Documentation

ProbLog 2 is a Probabilistic Logic Programming toolbox. It allows you to build programs that encode complex interactions between heterogeneous components while accounting for inherent uncertainties.

Core Concepts:

• Probabilistic Logic Programs: Logic programs where some facts are annotated with probabilities.
• Inference Engine: Converts programs, queries, and evidence into weighted Boolean formulas. This reduces inference tasks to weighted model counting, utilizing methods from graphical model and knowledge compilation literature.
• Supported Tasks: Computing marginals given evidence and learning from (partial) interpretations.
• Data Integration: Knowledge bases can be represented as Prolog/Datalog facts, CSV files, SQLite database tables, or via custom functions implemented in the host environment.

Scopes allow you to manage several ProbLog theories within a single model using the :/2 operator.

• Defining a scope: scope(Name):Predicate (e.g., scope(1):knowledge(1).).
• Unifying scopes: Use the ;/2 operator to generate the union of scopes.
• Querying scopes: Use the scope name in a query (e.g., query(scope(1):a).).
• Temporary unions: You can query a list of scopes simultaneously: query([scope(1), scope(2)]:b)..
• Global predicates: Predicates defined outside any scope are considered part of all scopes.
• Conjunction reasoning: You can perform conjunctions within a scope: query(scope(1):(a, b))..

scope(1):a.
scope(2):b.
% Querying the union of scope 1 and 2
query([scope(1), scope(2)]:b).

Annotated disjunctions allow you to model scenarios where multiple mutually exclusive outcomes are possible. The sum of probabilities in a disjunction represents the total probability of any of those outcomes occurring; the remaining probability is assigned to an implicit 'null' state where none of the options are true.

% Modeling a 6-sided die
1/6::die(D, 1); 1/6::die(D, 2); 1/6::die(D, 3);
1/6::die(D, 4); 1/6::die(D, 5); 1/6::die(D, 6).

ProbLog allows probabilities to be placed in the head of a clause. This means that if the body of the clause is true, the head will be true with the specified probability.

Note: Any program using probabilistic clauses can be transformed into an equivalent program using only probabilistic facts and standard Prolog clauses.

% If burglary is true, alarm is true with 90% probability
0.1::burglary.
0.9::alarm :- burglary.

The collect library provides the => operator, which generalizes the all/3 operator for complex aggregations.

Syntax: ( CODEBLOCK ) => GroupBy / AggFunc(Arg1, Arg2, ..., ArgK)

• CODEBLOCK: A Prolog-parseable block of code.
• AggFunc: The aggregation function to apply to the results of the CODEBLOCK.
• Arg1...K: Arguments for the aggregation function.
• GroupBy: (Optional) An expression to group the results.

To implement a custom collection, define a predicate with the shape: collect_AggFunc(CodeBlock, GroupBy, Arg1, ..., ArgK, Result)

% Example: Getting average per column for integer cell values
column_average(Column, Avg) :- (
    cell(Row, Column, Value),
    type(cell(Row, Column, 'int'))
) => Column / avg(Value, Avg).

ProbLog extends standard Prolog syntax with the :: operator to allow for probabilistic modeling. You can define probabilistic facts, clauses, and annotated disjunctions.

Syntax Overview

• Probabilistic Fact: P::fact. (e.g., 0.5::a.)
• Probabilistic Clause: P::head :- body. (e.g., 0.5::a :- x.)
• Annotated Disjunction: P1::choice1; P2::choice2. (e.g., 0.5::a; 0.5::b.). This expresses that at most one of these choices is true. There is an implicit null choice (none of the options are taken) which has a probability equal to 1 - sum(P_i).

Probabilistic Facts

% A single probabilistic choice
0.5::heads.

% Two separate probabilistic choices
0.5::heads1.
0.5::heads2.

% Generalizing with variable arguments
0.5::heads(C).

DTProbLog is an extension for decision-theoretic modeling. It differs from standard ProbLog in that it does not use query or evidence. Instead, it focuses on finding optimal choices.

• Decision Facts: Annotate facts as decisions to determine the optimal choice. Use ?::a. or decision(a)..
• Utilities: Define the contribution of atoms to the final score using the utility(Atom, Value) predicate.

% Decision fact
?::a.

% Utility definition
utility(win, 10).
utility(buy, -1).

ProbLog uses tabling (memoization) for all computations. This provides two main benefits:

1. Efficiency: It caches results of computations, turning exponential-time recursive algorithms (like Fibonacci) into linear-time ones.
2. Handling Cycles: It allows for the definition of cyclic relations (like ancestor or path in a graph) that would cause infinite recursion in standard Prolog.

% Path in a potentially cyclic graph
path(X, Y) :- edge(X, Y).
path(X, Y) :- edge(X, Z), path(Z, Y).