Functions vs. Predicates

Return to Table of Contents

This document should provide insight into the discussion of when to use functions and when to use predicates.

Given a real-world relationship between N items that is functional in at least one of those items, should one create a #$Predicate or a #$Function-Denotational to represent that relationship? If the relationship is not at all functional, of course a Predicate must be used. But if at least one of the "arguments" is functional, the relationship could be represented with either a function or a predicate. For example, one could represent the "successor" relationship with either a #$BinaryPredicate,

  (#$successor 1 2)

  (#$SuccessorFn 1) which returns 2.  

1. There can be multiple, independent reasons to choose one or the other. This means that sometimes, the best thing is to have BOTH a predicate and the corresponding function. Aside: In the case where we do have equivalent functions and predicates, it will be appropriate to write an axiom such as this in some appropriate mt:

     (#$implies (#$termOfUnit ?X (#$GovernmentFn ?C)
           (#$government ?C ?X))
   

2. If you want to be able to add new terms to your language on the fly, during inference, you must have the function version (else use a SkolemFunction). For example, we know that practically every country has a government. If all we had was #$government, we could use the expression

     (#$government ?C ?G) 
   

   to bind ?G to the government of ?C, but we would only find bindings in cases where someone had bothered to introduce, by hand, a term corresponding to the government of ?C.

   Named functions are more desirable than Skolem functions, partly due to clarity.

3. If you want to be able to associate a piece of code to compute the functional "argument", you should represent the relationship with an EvaluatableFunction. What if we represented "plus" with a predicate?

      (#$plus 2 2 ?X)
   

   It is possible to make a predicate an instance of #$EvaluatableRelationship, but the current system only supports an #$evaluationDefn which expects all arguments to be fully-bound. So if "plus" were an evaluatable predicate, we could answer the question

      (#$plus 2 2 4) 
   

   as True, but we couldn't use the defn to find bindings for ?X as in the expression further above.

4. In cases where you want to frequently assign a value to the functional "argument", a predicate is most useful. For example, the "height" relationship is functional -- for every PartiallyTangible, there is some Distance that is the height of the object. We could use a function --

      (#$HeightFn #$Karen) 
   

   -- to generate that Distance. However, this would only be useful in certain cases. If we want to declare that Karen has a particular height, this is best accomplished with a Predicate:

      (#$heightOfObject #$Karen (#$Foot-UnitOfMeasure 5.3)), 
   

5. In cases where you want to compare or constrain the value of a functional arguement, a function version is useful:

      (#$greaterThan (#$HeightFn #$Karen) (#$HeightFn #$Muffet))
   

6. There are several reasoning modules with special support that can be applied to Predicates: #$genlPreds, #$genlInverse, #$negationPreds, #$negationInverse, etc. In order to use these, you have to have a predicate.

7. If the relationship is functional in more than one argument, you can get by with a single Predicate but would require more than one Function. For example, "atomic number" is a one-to-one relationship. We can have a single predicate

      (#$atomicNumber #$Helium 2)
   

   which is functional in both of its arguments. Or, we could have

      (#$AtomicNumberFn #$Helium) -> 2
      (#$AtomicNumberOfFn 2) -> #$Helium
   

8. There is better indexing support for #$Predicates, especially if the function version would not be reifiable.

Go to Top