Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
rather than writing control constructs (loops, selection statements, subroutines) you specify knowledge and how that knowledge is to be applied through a series of rules the programming language environment uses one or more built-in methods to reason over the knowledge and prove things (or answer questions)
in logic programming, the common approach is to apply the methods of resolution and unification
Logic Programming
While these languages have numerous flaws, they can build powerful problem solving systems with little programming expertise
they have been used extensively in AI research
Terminology
Logic Programming is a specific type of a more general class: production systems (also called rule-based systems)
a production system is a collection of facts (knowledge), rules (which are another form of knowledge) and control strategies we often refer to the collection of facts (what we know) as working memory the rules are simple if-then statements where the condition tests values stored in working memory and the action (then clause) manipulates working memory (adds new facts, deletes old facts, modifies facts) the control strategies help select among a set of rules that match that is, if multiple rules have matching conditions, the control strategies can help decide which rule we select this time through there are other control strategies as well whether we work from conditions to conclusions or from conclusions to conditions (forward, backward chaining respectively)
Logic programming is mostly synonymous with the Prolog language because it is the only widely used language for logic programming
the basic idea behind logic programming is to state knowledge
facts rules these are truth preserving
Logic Programming
Prolog is not so much a programming language as it is a problem solving tool, however, in order to make Prolog more usable, it contains some useful programming language features to understand Prolog, we have to first start with some basics on logic programming
understanding first-order predicate calculus, resolution and unification
Symbolic logic uses propositions to express ideas, relationships between ideas and to generate new ideas based on the given propositions Two forms of propositions are
atomic propositions compound terms (multiple propositions connected through the logical operators of and, or, not, and implies)
Propositions will either be true (if stated) or something to prove or disprove (determine if it is true) we do not include statements which are false For symbolic logic, we use 1st order predicate calculus
statements include predicates a predicate is a proposition that is provided one or more arguments so that it may or may not be true based on the argument(s) provided
example: round(x) or round(Earth) -- you might think of an argument as a parameter and the predicate as a Boolean function
Logic Operators
Name negation disjunction Symbol Example Meaning a ab ab ab not a a and b a or b a is equivalent to b conjunction equivalence
Equivalence means that both expressions have identical truth tables Implication is like an ifthen statement
if a is true then b is true note that this does not necessarily mean that if a is false that b must also be false
implication
universal
ab ab
a implies b b implies a
For all X, P is true
X.P
Universal quantifier says that this is true no matter what x is Existential quantifier says that there is an X that fulfills the statement
existential
X.P
X.(woman(X) human(X))
X.(mother(mary, X) male(X))
Mary has a son (X)
Clausal Form
We will then break down our statements so that each statement has a single item on the left
we can break the above statement into:
B1 A1 A2 Am B2 A1 A2 Am Bn A1 A2 Am
Note that propositions and predicates by themselves are already in clausal form, such as round(Earth) and Sunny
Example Statements
Consider the following knowledge: Bob is Freds father father(Bob, Fred) Sue is Freds mother mother(Sue, Fred) Barbara is Freds sister sister(Barbara, Fred) Jerry is Bobs father father(Jerry, Bob) And the following rules: A persons fathers father is the persons grandfather A persons father or mother is that persons parent A persons sister or bother is that persons sibling If a person has a parent and a sibling, then the sibling has the same parent These might be captured in first-order predicate calculus as: x, y, z : if father(x, y) and father(y, z) then grandfather(x, z) x, y : if father(x, y) or mother(x, y) then parent(x, y) x, y : if sister(x, y) or brother(x, y) then sibling(x, y) and sibling(y, x) x, y, z : if parent(x, y) and sibling(y, z) then parent(x, z) We would rewrite these as grandfather(x, z) father(x, y) and father(y, z) parent(x, y) father(x, y) parent(x, y) mother(x, y) etc
For instance, from the previous example, we might ask How can this be done? Through backward chaining through rules
note: authors often refer to what PROLOG does as resolution, resolution is a different process which we cover in AI
To complicate matters, predicates (e.g., round(X)) need to be unified, that is, to prove round(X) is true, we have to find some X where we know it is true, for instance, round(Earth)
This requires finding pet(X) and small(X) (find an X to make both predicates true) pet(X) is implied by dog(X), dog(X) is implied by terrier(X), SCOTTY is a terrier so SCOTTY is a dog so SCOTTY is a pet
Can we find if SCOTTY is small? small(SCOTTY) is implied by terrier(SCOTTY) which we already know is true, therefore, since terrier(SCOTTY) is true, small(SCOTTY) and pet(SCOTTY) are true, so indoorpet(SCOTTY) is True Continuing with this process will also prove that indoorpet(COCOA) is true.
PROLOG is a programming language that allows the programmer to specify declarative statements only
declarative statements (things you are declaring) fall into 2 categories
predicates/propositions that are true clauses (truth preserving rules in clausal form)
PROLOG
Elements of Prolog
constants are atoms or integers (atoms are like those symbols found in Lisp) variables are not bound to types, but are bound to values when instantiated (via unification) an instantiation will last as long as it takes to complete a goal
proving something is true, or reaching a dead end with the current instantiation
Rules
All rules are stated in Horn clause form
the consequence comes first
the symbol :- is used to separate the consequence from the antecedent
And is denoted by , and Or is denoted by ; or separating the rule into two separately rules variables in rules are indicated with upper-case letters rules end with a . examples:
parent(X, Y) :- mother(X, Y). parent(X, Y) :- father(X, Y). grandparent(X, Z) :- parent(X, Y), parent(Y, Z). sibling(X, Y) :- mother(M, X), mother(M, Y), father(F, X), father(F, Y).
we can use _ as a wildcard meaning this is true if we can find any clause that fits
father(X) :- father(X, _), male(X).
X is a father if X is male and is someones father
Successful person is someone who either makes > $50000 in salary or was born after 1980 and is making more than $40000. success(X) :- record(X, Y, Z), Z > 50000; record(X, Y, Z), Y > 1980, Z > 40000.
Defining Length: length([ ], 0). // empty list has a length of 0 length([ _ | Tail, N) :- length(Tail, N1), N is 1 + N1. // a list that has an // item _ and a Tail is length N if the length of Tail is N1 where N = 1 + N1 Sum of the items in a list: sum([ ], 0). // sum of an empty list is 0 sum([X | Tail], S) :- sum(Tail, S1), S is X + S1.
Advantages of Prolog
ability to create automated problem solvers merely by listing knowledge a shortcut way to build and query a database solving significantly difficult problems with minimal code: Deriving the permutations of a list List:
perm(List,[H|Perm]):-delete(H,List,Rest),perm(Rest,Perm). perm([ ],[ ]). delete(X,[X|T],T). delete(X,[H|T],[H|NT]):-delete(X,T,NT).
Deficiencies of Prolog
Inefficiencies of resolution
resolution, as a process, is intractable (O(2n) for n clauses)
useful heuristics could be applied to reduce the complexity, but there is no way to apply heuristics in Prolog
they would just be additional rules that increases the size of n!
Rule-based Approaches
uncertainty can be expressed by adding certainty factors or probabilities to data, rules and conclusions use both forward and backward chaining
Rule-based systems are less restrictive than the strictly logic-based approach in Prolog
by moving away from the formal logic approach however, doubts can arise from any results generated by such a system
that is, we can not be sure of the truth of something proven when the system contains non-truth-preserving rules and uncertain data
is it useful to move away from the strict logic-based approach given this uncertainty?
since nearly everything in the world has uncertainty, my answer is YES
Working Memory
Rule-based systems divide memory into two sections
production memory the collection of rules available working memory partial results and tentative conclusions
variables are available by enclosing the name of the variable in < > symbols (student ^name <name> ^major CS ^gpa 4.0)
find student with major = CS, gpa = 4.0, store this students name in <name>
values can be tested against other values using <, >, =, <>, <= and >=, also arithmetic operations are available compound conditions are available
where conjuctions are placed in { } as in (student ^gpa {>= 3.0 <= 4.0}) disjuctions are placed in << >> marks as in (student ^name <<anderson bruford wakeman howe>>)
testing to see if something does not exist: place before the entry
- (student ^major MUS ^gpa 0.0)
are there no music majors with gpa of 0.0?
RHS Actions
Actions are what will happen if a rule is fired (executed)
multiple actions can be listed, each in a separate list actions usually revolve around manipulating working memory
add to working memory, for instance
(make student ^name <name> ^hours <oldhours> + 3)
remove from working memory alter some value(s) of a piece of working memory
(modify 1 ^rank senior) (modify 2 ^major ) which removes the major value from that students entry
Conflict Resolution
In Prolog, if two or more rules have matching (true) clauses, they are tried one at a time until an answer is reached
but because of recursion and the depth-first approach taken, the second clause would only be tried after the first clause led to a failure
so if clauses 1 and 2 matched, we try clause 1, assume it leads to clauses 3, 4, 5, and 6 matching, each of which is tried and fails, we only try clause 2 after all that
In Ops5, the decision of which rule to fire is based on a conflict resolution strategy, some options include:
refraction: a given rule cannot fire twice in a row recency: select the rule that previously matched most recently specificity: select the rule that has the most number of conditions on the LHS (this should be the most specific rule)
Handling Uncertainty
these questions have different answers depending on the form of uncertainty used
Ops5 does not directly support any of these you can add probabilities/certainty factors to each piece of knowledge and add rules to handle the probabilities/certainty factors
CLIPS
There are a few problems with Ops5:
forward chaining is only appropriate in data-driven problems and yet people may not want to use Prolog for backward chaining problems the conflict resolution strategies are built-in, programmers cannot implement their own
Ops5, like Prolog, is not so much a programming language as a tool, what about including other features?
Clips written in C (although it looks like lisp) offers solutions to these problems
Clips is a production system language but one that includes
class constructs including multiple inheritance, class daemons, polymorphism and dynamic binding functions and function calls to provide a different form of control, including a progn statement, return, break switch statement forall construct used to test all possible combinations of a group of conditions
Clips can perform forward and/or backward chaining based on the way you specify your rules
In Ops5, all rules were considered during each iteration, and the only way to alter the search strategy (from forward chaining) was by using conflict resolution strategies In Clips, there are several added strategies:
focus: on a set of rules pertaining to a current context agendas: rules whose conditions have matched but have not yet been evaluated can be stored in a list and consulted before searching through unmatched rules deactivated rules: eliminate rules from consideration which are no longer relevant (deactivated rules may be later activated) explicit conflict resolution strategies beyond those in Ops5
salience each rule can be given a salience value, how important is it? select rules based on the highest salience depth-first search or breadth-first search simplicity newly activated rules come before older activated rules complexity opposite of simplicity random
Java Expert System Shell Java-based implementation of Clips (to produce expert system applets)
Jess simplifies/restricts several elements of Clips
fewer resolution strategies, much of Clips OO facilities (these are replaced largely through Java Beans) Jess is thought to be about 3 times slower than Clips
Jess
but Jess is built on top of Java so it contains all of Javas GUI classes, is much more suitable for use over the Internet as a platform-independent tool and can use threads