DePYsible

DePYsible is a Python implementation of Defeasible Logic for argumentation. In particular, Defeasible Logic is a non-monotonic logic proposed to formalize defeasible reasoning and argumentation.

In a nutshell, Defeasible Logic supports three types of propositions:

strict rules: to specify known facts or information that is always a consequence of other sure facts,
defeasible rules: to specify information that is typically or possibly a consequence of other information,
undercutting defeaters: to specify exceptions to defeasible rules.

Some approaches like the one used in this implementation, the undercutting defeaters are derived by identifying the defeating arguments among conflicting ones. (An argument relates to a fact called conclusion and includes the list of defeasible rules that have to be true to make the conclusion to hold.)

A priority ordering over the defeasible rules and the defeaters can be given or inferred by the generalised specificity of the arguments. Intuitively, this comparison criterion favours two aspects: it prefers arguments (1) with greater information content or (2) with less use of rules (more direct). In other words, given two conflicting arguments, the defeater is the more precise or more concise among them. Arguments that have the same generalised specificity can be ordered by means of user-specified priorities on the rules.

During the process of deduction, the strict rules are always applied, while a defeasible rule can be applied only if no defeater of a higher priority specifies that it should not. This process decides if each defeasible fact is true, false or undecided and provides the clues supporting these decisions.

TL;DR

> git clone https://github.com/stefano-bragaglia/DePYsible.git ./depysible
> cd depysible
> pip install virtualenv
> virtualenv --python=python3.6 .env
> source ./.env/bin/activate
> pip install pybuilder
> pyb install_dependencies
> pyb install
> depysible example.pl

Example

% Strict rules
bird(X) <- chicken(X).
bird(X) <- penguin(X).
~flies(X) <- penguin(X).

% Facts
chicken(tina).
penguin(tweety).
scared(tina).

% Defeasible knowledge
flies(X) -< bird(X).
flies(X) -< chicken(X), scared(X).
~flies(X) -< chicken(X).
nests_in_trees(X) -< flies(X).

This program is a typical Defeasible Logic program that states that every chicken is a bird, that every penguin is a bird and that penguins don't fly (strict rules). We also know that Tina is a chicken, Tweety is a penguin and that Tina is scared (facts).

The program then says that birds can possibly fly, that scared chickens might fly, that chickens usually don't fly and that flying animals usually nest in trees (defeasible knowledge).

The argumentative procedure for Defeasible Logic can derive, for instance, that Tweety doesn't fly for sure (directly entailed from the strict knowledge) but also that Tina flies because she's scared (defeasibly entailed from the strict knowledge and flies(X) -< chicken(X), scared(X).).

Obtaining DePYsible

Prerequisites

DePYsible is an application developed in Python 3.6.5 and requires Python 3.6.x (or later) to run. A more recent version of Python for your working environment, if needed, can be downloaded from the official Python website.

It is possible to use a virtual environment and install DePYsible in a sandbox into a user directory. Virtualenv is possibly the most popular tool to create isolated Python environments. Assuming that Python 3.6.x (or later) has been successfully installed, Virtualenv can be installed globally by running on a command line:

pip install virtualenv

The instructions to create a virtual environment can be found below. Assuming that a virtual environment is available in a folder named .env, it is activated by:

source ./.env/bin/activate

and deactivated by running:

deactivate

Obtaining DePYsible

DePYsible's sources can be downloaded from github.com/stefano-bragaglia/DePYsible.git.

Alternatively, they can be cloned by issuing the following command on your terminal:

git clone https://github.com/stefano-bragaglia/DePYsible.git ./depysible

The interpreter might soon become available on pypi.org too. Once available, it will be possible to directly installing it into the current virtual (or global) Python environment (see above) with:

pip install DePYsible

Compiling DePYsible

If DePYsible has been installed as a package on a virtual (or global) Python environment, the compiling is not required. Otherwise compiling is mandatory, but DePYsible supports PyBuilder which simplifies this step.

Assuming that Python 3.6.x (or later)_ and Virtualenv are already installed (see here), it's highly recommended to create a local virtual environment by running:

cd ./depysible
virtualenv --python=python3.6 .env

The next step consists in installing PyBuilder in the local virtual environment after having activated it:

source ./.env/bin/activate
pip install pybuilder

PyBuilder is a build automation tool automates all the repetitive operations during the life cycle of the application such as installing the dependencies, testing the sources, compiling the sources, etc. In order to compile and install DePYsible, run the following commands:

pyb install_dependencies
pyb install

From now on, any time the local virtual environment is activated, the command depysible becomes available on the command line.

Running DePYsible

DePYsible comes as a command line interface application. Once it has been installed (see above), DePYsible can be simply run by invoking it at the prompt:

> depysible

Welcome to Defeasible 0.1.0 (Darwin-18.0.0-x86_64-i386-64bit)
Defeasible comes with ABSOLUTELY NO WARRANTY. This is free software.
Type "help", "copyright", "credits" and "license" for more information.

?-

Command line parameters

If no parameters is given, DePYsible is run with default configuration. By passing -h or --help as a parameter, the list of possible parameters is returned:

> depysible --help

usage: depysible [-h] [-b] [filename]

positional arguments:
  filename     load the file with given name

optional arguments:
  -h, --help   show this help message and exit
  -b, --blind  ignore colours to render output

`-h`, `--help`

This parameter will display the list of possible parameters for DePYsible, as shown above.

`-b`, `--blind`

Normally, DePYsible highlights the syntax of program that it holds in memory. At the moment, only the dark theme displayed in the opening screenshot is supported. On different setups, this theme might not render well or some people might find the syntax highlighting distracting. In either cases the -b, --blind parameter will help by turning off the syntax highlighting.

`filename`

When given, this parameter will preload the program contained in the file with the given name into the DePYsible interpreter. For instance, the following command will load example.pl into memory when started:

> depysible example.pl

Command line interface actions

DePYsible is a command-line interpreter application. When started, it enters into a loop that displays a message on the screen and then waits for a user's input.

Normally DePYsible presumes that a program is already loaded in memory, and assumes that anything the user types is a valid statement for its language. Valid statements are either sets of rules or just literals (see language below).

Any valid set of rules is automatically appended to the program currently in memory. The following input, for instance, adds a strict rule (every chicken is a bird) and a fact (Tina is a chicken):

?- bird(X) <- chicken(X). chicken(tina).

Any literal, instead, triggers the defeasible argumentation algorithm which checks whether it is true or not according to the information available on the domain. Assuming that example.pl has been loaded into memory, the given input triggers the following output:

?- ~flies(tina)
NO
    flies(tina) -< chicken(tina), scared(tina).

This output means that the interpreter believes the fact "Tina does not fly" to be false because the opposite could be derived from the strict domain's knowledge and the given ground rules (if any): Tina, being a chicken, could fly if scared.

The interpreter accepts more specialised commands that are introduced in alphabetical order in the following sections.