Grokbase Groups Perl ai August 2001
FAQ
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, <tbone@cpan.org>

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

Search Discussions

  • Gidon Wise at Aug 2, 2001 at 12:24 am
    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, <tbone@cpan.org>

    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

Related Discussions

Discussion Navigation
viewthread | post
Discussion Overview
groupai @
categoriesperl
postedAug 1, '01 at 10:01p
activeAug 2, '01 at 12:24a
posts2
users2
websiteperl.org

2 users in discussion

Gidon Wise: 1 post Terrence Brannon: 1 post

People

Translate

site design / logo © 2021 Grokbase