Ferdinando Primerano

NAME

AI::Logic::AnswerSet - Perl extension for embedding ASP (Answer Set Programming) programs in Perl.

SYNOPSIS

  use AI::Logic::AnswerSet;
  
  # invoke DLV( AnwerSetProgramming-based system) and save the stdoutput
  my @stdoutput = AI::Logic::AnswerSet::singleExec("3-colorability.txt");

  # parse the output
  my @res = AI::Logic::AnswerSet::getAS(@stdoutput);

  # map the results
  my @mappedAS = AI::Logic::AnswerSet::mapAS(\@res);

  # get a predicate from the results
  my @col = AI::Logic::AnswerSet::getPred(\@mappedAS,1,"col");

  # get a term of a predicate
  my @term = AI::Logic::AnswerSet::getProjection(\@mappedAS,1,"col",2);

DESCRIPTION

This extension allows to interact with DLV, an Artificial Intelligence system for Answer Set Programming (ASP). Please note that the DLV system must appear in the same folder of the perl program and it must be renamed as "dlv"; DLV can be freely obtained at www.dlvsystem.com. For further info about DLV and Answer Set Programming please start from www.dlvsystem.com.

The module was originally published as "ASPerl", but suffered from some problems with the namespace, now changed. The module has been also significantly rearranged according to the advices coming from the community. Thank you all! If you are using this module, please let us know: we are always interested in end-users desires, and we wish to improve our library: comments are truly welcome!

Methods

executeFromFileAndSave

This method allows to execute DLV with and input file and save the output in another file.

        AI::Logic::AnswerSet::executeFromFileAndSave("outprog.txt","dlvprog.txt","");

In this case the file "outprog.txt" consists of the result of the DLV invocation with the file "dlvprog.txt". No code is specified in the third value of the method. It can be used to add code to an existing file or to a new one.

        AI::Logic::AnswerSet::executeFromFileAndSave("outprog.txt","dlvprog.txt",
        "b(X):-a(X). a(1).");
  

executeAndSave

To call DLV without an input file, directly writing the ASP code from the terminal, use this method, passing only the name of the output file.

        AI::Logic::AnswerSet::executeAndSave("outprog.txt");

Press Ctrl+D to stop using the DLV terminal and execute the program.

singleExec

Use this method to execute DLV whit several input files, including also DLV options like "-nofacts". The output will be stored inside an array.

        my @out = AI::Logic::AnswerSet::singleExec("3col.txt","nodes.txt","edges.txt","-nofacts");

Another way to use this method:

        my @out = AI::Logic::AnswerSet::singleExec();

In this way it will work like executeAndSave() without saving the output to a file.

iterativeExec

This method allows to call multiples DLV executions for several instances of the same problem. Suppose you have a program that calculates the 3-colorability of a graph; in this case one might have more than a graph, and each graph instance can be stored in a different file. A Perl programmer might want to work with the results of all the graphs she has in her files, so this function will be useful for this purpose. Use it like in the following:

        my @outputs = AI::Logic::AnswerSet::iterativeExec("3col.txt","nodes.txt","./instances");

In this case the nodes of each graph are the same, but not the edges. Notice that in order to correctly use this method, the user must specify the path to the instances (the edges, in this case).

The output of this function is a two-dimensional array; each element corresponds to the result of a single DLV execution, exactly as in the case of the function singleExec().

selectOutput

This method allows to get one of the results of iterativeExec.

        my @outputs = AI::Logic::AnswerSet::iterativeExec("3col.txt","nodes.txt","./instances");
        my @out = AI::Logic::AnswerSet::selectOutput(\@outputs,0);

In this case the first output is selected.

getASFromFile

Parses the output of a DLV execution saved in a file and gather the answer sets.

        AI::Logic::AnswerSet::executeFromFileAndSave("outprog.txt","dlvprog.txt","");
        my @result = AI::Logic::AnswerSet::getASFromFile("outprog.txt");

getAS

Parses the output of a DLV execution and gather the answer sets.

        my @out = AI::Logic::AnswerSet::singleExec("3col.txt","nodes.txt","edges.txt","-nofacts");
        my @result = AI::Logic::AnswerSet::getAS(@out);

mapAS

Parses the new output in order to save and organize the results into a hashmap.

        my @out = AI::Logic::AnswerSet::singleExec("3col.txt","nodes.txt","edges.txt","-nofacts");
        my @result = AI::Logic::AnswerSet::getAS(@out);
        my @mappedAS = AI::Logic::AnswerSet::mapAS(@result);

The user can set some constraints on the data to be saved in the hashmap, such as predicates, or answer sets, or both.

        my @mappedAS = AI::Logic::AnswerSet::mapAS(@result,@predicates,@answerSets);

For instance, think about the 3-colorability problem: imagine to have the edges in the hashmap, and to print the edges contained in the third answer set returned by DLV; this is an example of the print instruction, useful to understand how the hashmap works:

        print "Edges: @{$mappedAS[2]{edge}}\n";

In this case, we are printing the array containing the predicate "edge".

getPred

Easily manage the hashmap and get the desired predicate(see the print example described in the method above):

        my @edges = AI::Logic::AnswerSet::getPred(\@mappedAS,3,"edge");

getProjection

Returns the projection of the n-th term of a specified predicate. Suppose that we have the predicate "person" person(Name,Surename); and that we just want the surenames of all the instances of "person":

        my @surenames = AI::Logic::AnswerSet::getProjection(\@mappedAS,3,"person",2);

The parameters are, respectively: hashmap, number of the answer set, name of the predicate, position of the term.

statistics

This method returns an array of hashes with some stats of every predicate of every answer set, namely the number of occurrences of the specified predicates of each answer set. If a condition is specified(number of predicates), only the answer sets that satisfy the condition are returned.

        my @res = AI::Logic::AnswerSet::getAS(@output);
        my @predicates = ("node","edge");
        my @stats = AI::Logic::AnswerSet::statistics(\@res,\@predicates);

In this case the data structure returned is the same as the one returned by mapAS(). Hence, for each answer set (each element of the array of hashes), the hashmap will appear like this:

        {
                node => 6
                edge => 9
        }

This means that for a particular answer set we have 6 nodes and 9 edges. In addition, this method can be used with some constraints:

        my @res = AI::Logic::AnswerSet::getAS(@output);
        my @predicates = ("node,"edge");
        my @numbers = (4,15);
        my @operators = (">","<");
        my @stats = AI::Logic::AnswerSet::statistics(\@res,\@predicates,\@numbers,\@operators);

Now the functions returns the answer sets that satisfy the condition, i.e., an answer set is returned only if the number of occurrences of the predicate "node" is higher than 4, and the number of occurrences of the predicate "edge" less than 15.

getFacts

Get the logic program facts from a file or a string.

        my @facts = AI::Logic::AnswerSet::getFacts($inputFile);

or

        my $code = "a(X):-b(X). b(1). b(2).";
        my @facts = AI::Logic::AnswerSet::getFacts($code);

DLV code can be freely exploited, with the only constraint of putting a space between rules or facts. This is an example of wrong input code:

        my $code = "a(X):-b(X).b(1).b(2).";

addCode

Use this method to quiclky add new code to a string or a file.

        my $code = "a(X):-b(X). b(1). b(2).";
        AI::Logic::AnswerSet::addCode($code,"b(3). b(4).");

or

        my $file = "myfile.txt";
        AI::Logic::AnswerSet::addCode($file,"b(3). b(4).");

createNewFile

Creates a new file with some code.

        AI::Logic::AnswerSet::createNewFile($file,"b(3). b(4).");

addFacts

Quiclky adds facts to a file. Imagine to have some data(representing facts) stored inside an array; just use this method to put them in a file and give it a name.

        AI::Logic::AnswerSet::addFacts("villagers",\@villagers,">","villagersFile.txt");

In the example above, "villagers" will be the name of the facts; @villagers is the array containing the data; ">" is the file operator(will create a new file, in this case); "villagersFile.txt" is the filename. The file will contain facts of the form "villagers(X)", for each "X", appearing in the array @villagers.

SEE ALSO

www.dlvsystem.com

AUTHOR

Ferdinando Primerano, <levia@cpan.org> Francesco Calimeri, <calimeri@mat.unical.it>

This work started within the bachelor degree thesis program of the Computer Science course at Department of Mathematics of the University of Calabria.

COPYRIGHT AND LICENSE

Copyright (C) 2012 by Ferdinando Primerano , Francesco Calimeri

This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself, either Perl version 5.10.1 or, at your option, any later version of Perl 5 you may have available.