Re: ANN: AI::Proplog - propositional logic engine for Perl

Cool module, the probabilistic add on also seems interesting.

How would you tie the rules into a database
so that they could be persistant?

Let's say that you had 100K rules for example.

Terrence Brannon wrote:
> 
> NAME
>     AI::Proplog - Propositional logic engine
> 
> SYNOPSIS
>      use strict;
>      use AI::Proplog;
> 
>      my $p = new AI::Proplog;
>      #
>      # assert some facts:
>      #
> 
>      # cs requirements are basic cs, math, advanced cs, an engr rec and nat. sci.
>      $p->a( cs_req => qw(basic_cs math_req advanced_cs engr_rec natural_science));
> 
>      # basic cs requires an intro req, comp org, advanced programming and theory
>      $p->a( basic_cs  => qw(intro_req comp_org adv_prog theory) );
> 
>      # and so forth
>      $p->a( intro_req => 'intro_cs');
>      $p->a( intro_req => qw(introI introII) );
>      $p->a( math_req  => qw(calc_req finite_req alg_req) );
>      $p->a( calc_req  => qw(basic_calc adv_calc) );
>      $p->a( basic_calc => qw(calcI calcII) );
>      $p->a( basic_calc => qw(calcA calcB calcC) );
>      $p->a( adv_calc   => 'lin_alg');
>      $p->a( adv_calc   => 'honors_linalg');
>      $p->a( finite_req => qw(fin_structI stat) );
>      $p->a( alg_req    => 'fin_structII');
>      $p->a( alg_req    => 'abs_alg');
>      $p->a( alg_req    => 'abs_alg');
> 
>      # here we assert a bunch of facts:
> 
>      # the following things have been taken:
>      # cs intro, computer org, advanced programming, and theory
>      $p->apl( qw(intro_cs comp_org adv_prog theory) );
> 
>      # now do a bottom up search of the fact/rule space to see if the
>      # basic cs requirements have been met
>      my $R = $p->bottom_up('basic_cs');
>     # or:  my $R = $p->top_down('basic_cs');
>      ok($R);
> 
> DESCRIPTION
>     This module is a prelude to more powerful modules supporting predicate
>     and functional logic semantics with Perl syntax. The search algorithms
>     are naive, inefficient and not-foolproof. For example the top-down
>     engine will run without termination on the following code:
> 
>         $p->a( x => 'y' );
>         $p->a( y => 'x' );
> 
>     On the other hand, the code body is quite small (smaller than the
>     original Pascal examples in the textbook) and thus serves as an
>     excellent vehicle for study of such programs.
> 
>     It is written based on the same interpreters described in "Computer with
>     Logic: Logic Programming with Prolog", a book by David Maer and David S.
>     Warren.
> 
> USAGE
>     First you `use AI::Proplog' then you assert rules and facts using `a()'.
>     If you have a bunch of facts you want to assert, you can do so
>     conveniently with `apl()' as exmplified in the SYNOPSIS.
> 
>     Then you search your universe of truths in a top down or bottom-up
>     manner, depending on what you want to do with the results. If you would
>     like to know every truth that can result from your fact/rule space, then
>     use `bottom_up' and inspect `$p-'{established}> with Data::Dumper to see
>     all the derived propositions.
> 
>     On the other hand, if you are more interested in simply finding out if a
>     certain proposition holds based on the fact/rule base, then `top_down()'
>     will likely be more efficient. This is because it will terminate as soon
>     as a proposition is derived which matches your one of interest. However,
>     `top_down()' does do backtracking, while `bottom_up()' simply plows
>     through your fact/rule base one time finding every truth it can, and
>     then testing your queried proposition.
> 
> TODO
>   Probablistic propositions:
> 
>      # there is a 0.6 chance that a souffle rises is beaten well and it is quiet
>         $p->a( souffle_rises(0.6) => qw(beaten_well quiet_while_cooking) ) ;
> 
>      # there is a 0.1 chance that it will rise based on luck
>         $p->a( souffle_rise(0.1 ) => 'have_luck');
> 
>      # there is thus 0.3 chance that it will NOT rise
> 
>         $p->a( beaten_well(0.4)   => 'use_whisk');
>         $p->a( beaten_well(0.6)   => 'use_mixer');
> 
>         $p->a( quiet_while_cooking(0.8) => 'kids_outside');
>         $p->a( have_luck(0.3) => 'knock_on_wood');
> 
>      # tell me what the chances are of this souffle rising if the kids are
>      # outside and I use whisk...
>         $p->apl( qw(use_whisk kids_outside) );
> 
>      $p->top_down('souffle_rise')
> 
>   use strict terms
> 
>     Right now if a single term shows up there is no warning, thus if I
>     mis-spell a term name (as I did when making the test suite for this),
>     then the program will search for something that no-one intended it to.
> 
> AUTHOR
>     T. M. Brannon, <[email protected]>
> 
>     I would like to thank nardo and IDStewart of www.perlmonks.org for their
>     help in debugging my test suite for me. I would have never got this
>     module out so fast if it weren't for thie speedy help.
> 
> SEE ALSO
>     * "Computer with Logic: Logic Programming with Prolog", a book by David
>     Maer and David S. Warren
>     * Array::PatternMatcher
>     * Quantum::Superpositions
>     * Quantum::Entanglements