PrologJ Support for Fuzzy Logic

Return Truth Value Variables

Any goal that appears in an initial context or a fuzzy context can be followed by a return truth value variable, which takes the form of a colon (:) followed by an uninstantiated variable. A fuzzy computation is performed, and if it succeeds (partially or absolutely) the variable is instantiated to the truth value resulting from the computation (1.0 meaning absolute success). (Note: it is an error for the variable to be instantiated before the computation, or to be instantiated by the computation itself.)

Example:

	?- tall(joe)  : V.          % Succeeds if the database contains a crisp or fuzzy
	                            % fact that joe is tall (or a rule that leads to this
	                            % conclusion);  if it succeeds, V is instantiated
	                            % to the truth value of the fact or rule if it is crisp,
	                            % or 1.0 if it is crisp.

Thresholds

The concept of a threshold is an important one in the PrologJ implementation of fuzzy logic. In a fuzzy computation, the threshold for a goal is the minimum truth value that will be considered to represent success for that goal. It is also possible to specify a threshold of 0.0 - which is taken to mean that a goal that succeeds with any degree of truth will be considered successful.

The default value for the threshold for a goal appearing in an initial context is 0.0. The default value for the threshold for a goal appearing in a fuzzy context is determined as follows:

• If the goal is the body of a fuzzy clause, its default threshold is deterMined by dividing inherent truth value of the clause into the threshold of the goal that is being satisfied by invoking the predicate to which the clause belongs. (If this result is greater than 1.0 - i.e. the inherent truth value of the clause is less than the threshold of the goal that caused it to be called - then the clause fails at once since it cannot possibly succeed.)
   
• If the goal is an argument of one of the following built-ins, its default threshold is 0.0.
   
  • call_fuzzy/1
  • fuzzy_bagof/3
  • fuzzy_best/1
  • fuzzy_filter_set/4
  • fuzzy_filter_set/5
  • fuzzy_findall/3
  • fuzzy_findset/3
  • fuzzy_setof/3
   
• If the goal is an argument of one of the following built-ins (called in a fuzzy context), its threshold is the threshold of the parent goal.
   
  • call/1
  • catch/3
  • ','/2
  • ';'/2
  • foreach/2
  • ->/2
  • once/1
  • phrase/2
   
• If the goal is the "condition" (first) argument of the following (called in a fuzzy context), its threshold is 0.0. It is considered to have succeeded if it succeeds with truth value is at least equal to the threshold of the parent goal, and to have failed otherwise. The threshold for the "then" and "else" arguments is the threshold of the parent goal.
   
  • -> ;/3
   
• If the goal is the argument of one of the following (called in a fuzzy context), its threshold is 0.0. It is considered to have succeeded if it succeeds with truth value is at least equal to the threshold of the parent goal, and to have failed otherwise.
   
  • not/1
  • \+/1
   

A higher threshold for any fuzzy goal can be specified by following the goal with a double colon (::) and then a real number in the range [0.0 .. 1.0). (If it is desired to specify a variable to be unified with the truth value of the computation, then the variable comes first.) The effective threshold is the maximum of the default threshold, determined as discussed above, and the value specified. This mechanism can therefore only be used to specify a threshold at least as high as the default; it cannot be used to specify a lower value. It is also often used to specify the threshold for an initial goal (since the default is 0.0 in this case).

Examples:

	?- tall(Person) : V.        % Find all Persons such that tall(Person)
	                            % succeeds with any value - however small - in
	                            % each case unify the actual truth value with V.
	                            
	?- tall(Person) :: 0.5.     % Find all the Persons such that tall(Person) 
	                            % succeeds with truth value at least 0.5.
                
	?- tall(Person) : V :: 0.5. % Find all the Persons such that tall(Person)
	                            % succeeds with truth value at least 0.5; in
	                            % each case unify the actual truth value with V. 

PrologJ uses the threshold to avoid the potential for combinatorial explosion when dealing with alternate ways of satisfying a goal. In fuzzy logic, the truth value of "A or B" is defined as maximum(truth value of A, truth value of B). This implies that - unless A succeeds absolutely (with the maximum possible truth value - 1.0) both subgoals need to be tried.

In Prolog, the various clauses for a predicate are considered to be connected by "or". Thus, strict adherence to fuzzy logic would require that, when attempting a goal for which there are multiple clauses, each clause has to be tried in order to find the one with the maximum degree of success (unless one succeeds totally) - leading quickly to the possibility of combinatorial explosion. Moreover, Prolog programs typically assume that only the first clause that succeeds in satisfying a goal is tried - at least until the goal is redone during backtracking, and cut (!) can be used to prevent trying alternatives if a goal succeeds.

To deal with these problem, PrologJ handles the evaluation of a predicate for which there are multiple fuzzy clauses as follows: each clause is tried, in turn, until one succeeds with truth value at least equal to the threshold. If the clause contains redoable subgoals, each way of proving the clause may be tried until one such solution is found. Cut (!) can be used to cut off alternatives if the truth value at the point the cut is executed is at least equal to the threshold, even though a later term may push the truth value below the threshold and force failure (in the same way that !, ..., fail can be used to force a crisp computation to fail.) As soon as any clause succeeds with truth value at least equal to the threshold, the goal is declared to be satisfied at once. Subsequent clauses may be tried during backtracking - but again, only until a clause that succeeds with truth value at least equal to the threshold is found.

Truth Values and Control Structures

When one of the control structure predicates listed earlier is called in a fuzzy context, its truth value is based on the truth value of its subgoal(s) according to the following rules.

• call(A) - the truth value is the truth value of A
   
• catch(A, B, C) - the truth value is the truth value of whichever of A or C is called.
   
• A, B - the truth value is the minimum of the truth values for A and B.
   
• A; B
   
  If A succeeds (or re-succeeds on redo) with truth value at least equal to the threshold of the parent goal, the parent goal succeeds with truth value equal to that for A. Only if A does not (re)succeed with value at least equal to the threshold of the parent goal is B tried; and if it succeeds, the parent goal succeeds with truth value equal to that for B.
   
  Note that this differs from the way that "or" is usually defined in fuzzy logic. PrologJ defines "or" this way to avoid combinatorial explosion and complexity during backtracking (e.g. if the best way of satisfying a goal involves the second subgoal, but the second best way involves some alternative for the first subgoal). A computation that is more consistent with the fuzzy logic notion of "or" can be forced by using the built-in predicate fuzzy_best/1 described below.
   
  
• foreach(A, B) - The truth value is the minimum of the truth values of the various calls to B - 1.0 if B is never called because A never succeeds.
   
• A -> B - The truth value is the minimum of the truth values for A and B.
   
• A -> B; C
   
  If A and B succeed, the truth value is the minimum of the two truth values.
   
  If A succeeds partially (but with truth value less than the threshold for the parent goal), or it fails, and C succeeds, then the truth value is the minimum of (1.0 - truth value for A [ 1.0 - 0.0 = 1.0 if A failed ] ), truth value for C).
   
• \+ A or not A
   
  If A succeeds partially (but with truth value less than the threshold for the parent goal), or it fails, the truth value is (1.0 - truth value for A [ 1.0 - 0.0 = 1.0 if A failed ] ).
   
• once(A) - the truth value is the truth value of A
   
• phrase(A, B) - the truth value is the truth value of the grammar rule corresponding to A

Accessing and Retracting Fuzzy Clauses

Fuzzy clauses can be accessed or deleted in the same way as crisp clauses, using the built-in predicates clause/2, retract/1 and retractall/1. When these predicates are used in the standard way, the inherent truth value of the clause is ignored, as is any threshold if they are called in the context of a fuzzy computation. (That is, a fuzzy clause is handled in exactly the same way as a crisp clause by default.)

However, it is possible to take into account the inherent truth value of a fuzzy clause when one of these built-in predicate is used, by following the head of the clause with one of the following. (This only affects clause selection; it has no affect on the outcome of the overall goal, which is always crisp).

• A colon (:) followed by an uninstantiated variable. In this case, the variable is instantiated to the inherent truth value of the selected clause. (Note: this is not allowed with retractall/1, since multiple clauses are typically selected, and no unification with variables in the clause is visible.)
   
• A double colon (::) followed by a real number that serves as a threshold for selecting clauses, in the range (0.0 .. 1.0]. In this case, a fuzzy clause is selected only if it has an inherent truth value at least equal to the threshold. (Crisp clauses are always selected.)
   
• Both of the above, in the order listed. (Note: this is not allowed with retractall/1.)

Note that, when entering one of these goals to the interpreter, the truth value and/or threshold specifier(s) appear inside the goal, not outside it. Example: to access clauses for a tall fact in such a way as to find out the inherent truth value of each, and to only consider clauses with inherent truth value at least 0.5, one would write:

	clause(tall(Person) : V :: 0.5, B).

not

	clause(tall(Person), B) : V :: 0.5.

(The latter would find all clauses, and would report 1.0 as the value of V in every case, since it is considering the truth of the proposition "there exists a clause ...")

When listing/1 or listing/2 lists a fuzzy clause, its inherent truth value is printed as part of the listing in the same way it would be specified when inputting the clause.

Special Built-in Predicates for Fuzzy Computations

Several built-in predicates are added to facilitate fuzzy computations. In the discussions that follow, the following sample database will be used:

	tall(joe) : 0.5.
	tall(ralph) : 0.3.
	tall(john) : 0.8.
	tall(george) : 0.4.

• call_fuzzy(Goal)
   
  
  • Goal must be a callable goal, and (as with any goal called in a fuzzy context) can be followed by a return truth value variable and/or a threshold specifier. (If no threshold is specified, the default value 0.0 is used.)
     
  • If Goal succeeds either partially or absolutely, the overall goal succeeds absolutely.
     
  • This predicate is opaque to cuts, similarly to call/1.
     
  • Error Cases - same as for call/1.
  
   
  This predicate can be used to convert partial success to absolute success when calling a fuzzy goal from a crisp computation.
   
  Example: Suppose the database contains the example facts listed above. The following goal will succeed twice, with Person being instantiated to joe the first time and john the second. Each success will be absolute. It will not succeed for tall(ralph) or george, because the truth value of the relevant facts is less than the threshold specified.

  	call_fuzzy(tall(Person) :: 0.5).
  	

• fuzzy_best(Goal)
   
  
  • Goal must be a callable goal, and (as with any goal called in a fuzzy context) can be followed by a return truth value variable and/or a threshold specifier. (If no threshold is specified, the default value 0.0 is used.)
     
    All ways of satisfying Goal are explored. If at least one solution is found with truth value greater than or equal to the threshold, then the overall goal succeeds with variables bound in accordance with the best solution found, and with truth value equal to the truth value for that solution. (If, in the course of exploring alternatives, a solution is found that succeeds absolutely (with truth value 1.0), the overall goal succeeds absolutely at once, without exploring further alternatives, since no other outcome could possibly have a higher truth value.) If no solution can be found with truth value at least equal to the threshold, the goal fails.
     
  • This predicate is not redoable.
     
  • This predicate is opaque to cuts, similarly to call/1.
     
  • Error Cases - same as for call/1
  
   
  Example: Suppose the database contains the example facts listed above. The following goal will succeed once, with Person instantiated to john and V instantiated to 0.8:

  	fuzzy_best(tall(Person)) : V.
  	

• fuzzy_findall(Term, Goal, Bag),
  fuzzy_findset(Term, Goal, Set),
  fuzzy_bagof(Template, BGoal, Bag),
  fuzzy_setof(Template, BGoal, Set)
   
  Like the standard predicates these are analogous to, these built-in predicates are crisp. They always either succeed absolutely or fail absolutely, and if they are invoked by a fuzzy computation, the threshold of the fuzzy computation is ignored. (This is because success or failure is taken as meaning "a non-empty list of solutions exists and can be unified with the third argument.")
   
  Unlike the standard predicates these are analogous to, their embedded subgoal is considered a fuzzy goal, and the list of solutions includes the truth value of each solution.
   
  • The subgoal (the Goal parameter for fuzzy_findall or fuzzy_findset, or the subgoal portion of it for fuzzy_bagof or fuzzy_setof) must be a callable goal, and (as with any goal called in a fuzzy context) can be followed by a return truth value variable and/or a threshold specifier. (If no threshold is specified, the default value 0.0 is used. In this case, specifying a variable to receive the return truth value generally serves no purpose, but is legal.)
     
    The evaluation of the subgoal is performed as a fuzzy computation, and the list of solutions generated includes only those whose truth value is greater than or equal to the threshold.
     
  • These predicates differ from the standard predicate they are analogous to in that the bag(s) or set(s) they construct consist of terms of the form template : truth value where truth value is the truth value of the goal success that resulted in template. (In the case of fuzzy_findset/3 or fuzzy_setof/3, if the same template value occurs two or more times, the truth value of the single copy that is reported will be the maximum of the different truth values.)
     
  • Error Cases - same as for the corresponding standard predicate.
  
   
  Example: using the database of the previous examples, the following goal will instantiate L to the list shown.

  	fuzzy_findall(P, tall(P) :: 0.5, L).
  	% L will be instantiated to [ ralph : 0.5, john : 0.8 ]
  	

• fuzzy_truth(TruthValue)
   
  
  • TruthValue is a number in the range (0.0 .. 1.0]. If the value is at least equal to the threshold for the goal, the predicate succeeds once, with truth value equal to the value of its argument. It cannot be redone. If TruthValue is less than the threshold for the goal, then the goal fails.
     
  • This predicate can be used to set the truth value for a computation. If it occurs in a control structure, the overall truth value for the computation will be determined by the combining rules for the control structure.
     
  • Error Cases:
     

    Conditions	Error Term
    TruthValue is a variable	instantiation_error
    TruthValue is not a variable or a number	type_error(number, TruthValue)
    TruthValue is less than or equal to 0.0 or greater than 1.0	domain_error(fuzzy_truth, TruthValue)

  
   
  Example: Using the database of the previous examples, the following goal will succeed four times, with Person being instantiated to joe, ralph, john and george, and with truth values 0.4, 0.3, 0.4 and 0.4. (The truth value 0.3 results from the minimum operation performed when calculating the truth value of ','/2 since the inherent truth value for tall(ralph) is 0.3).

  	tall(Person), fuzzy_truth(0.4).
  	

Fuzzy Sets