;;;; -*-  Mode: LISP; Syntax: Common-Lisp; Base: 10                          -*-
;;;; ---------------------------------------------------------------------------
;;;; File name: analogy-dt.lsp
;;;;    System: nil
;;;;   Version: 1.0
;;;;    Author: mostek
;;;;   Created: October 30, 1998 17:13:24
;;;;   Purpose: 
;;;; ---------------------------------------------------------------------------
;;;;  Modified: Friday, March 3, 2000 at 16:39:32 by mostek
;;;; ---------------------------------------------------------------------------

(in-package :cl-user)

(set-dt-name 'analogy-dt)


;;required from HPKB upper
(defuniversalfact (collection microtheory))
(defuniversalfact (collection abstract-information))
(defuniversalfact (collection abstract-information))

;; recommened from HPKB upper
(defuniversalfact (collection CYC-FORMULA))
(defuniversalfact (collection CYC-EXPRESSION))
(defuniversalfact (collection FUNCTION-EXPRESSION))
(defuniversalfact (binary-predicate ist))
(defuniversalfact (variable-arity-relation THE-PARTITION))
(defuniversalfact (binary-predicate PARTITIONED-INTO))


;;; CASES

(defentity case
 :subclass-of (microtheory)
 :documentation "a case is a collection of propositions that describe a real or hypothetical scenario")

;; this needs to be added because cyc2.6 had a slightly different implementation than us
(defuniversalfact (genls case analogy-case))

(defrelation case-description (?case ?prop)
  :documentation "Associates a proposition ?prop with a ?case.
 There can be multiple propositions, and each proposition can be a conjunction.
 The intent is that ?prop is explicitly known in ?case, so that it will be
 available for the analogy matcher.")

(defuniversalfact (genl-preds case-description ist))
(defuniversalfact (arg1-isa case-description case))
(defuniversalfact (arg2-isa case-description cyc-formula))

(defrelation case-facts (?case ?object ?prop)
  :documentation 
  "Specifies one of the facts that reference the ?object in the given ?case.
   There will be a case-facts relation for each of the facts in the case for each object in the case")
(defuniversalfact (arg1-isa case-facts case))
(defuniversalfact (arg2-isa case-facts individual))
(defuniversalfact (arg3-isa case-facts cyc-formula))


;;; MATCHES

(defentity match
 :subclass-of (abstract-information)
 :documentation "a match refers to the linking of two cases in an analogy. See match-bewteen. Each match can have multiple mappings")

(defrelation match-between (?base ?target ?match)
 :documentation "?match is from ?base to ?target")

(defuniversalfact (functional-predicate match-between))
(defuniversalfact (arg1-isa match-between case))
(defuniversalfact (arg2-isa match-between case))
(defuniversalfact (arg3-isa match-between match))

(defentity analogy-entity-with-structural-evaluation
 :subclass-of (abstract-information)
 :documentation "An information entity associated with an analogy that can be structurally evaluated.  Either a correspondence or a mapping")

;;; MAPPINGS

(defentity mapping
 :subclass-of (abstract-information analogy-entity-with-structural-evaluation)
 :documentation "A mapping is a set of correspondences plus candidate inferences that is an interpretation of a match.") 

(defrelation mapping-of (?mapping ?match)
 :documentation "?mapping is a mapping of match ?match")

(defuniversalfact (isa mapping-of functional-slot))
(defuniversalfact (arg1-isa mapping-of mapping))
(defuniversalfact (arg2-isa mapping-of match))

(defquantityfunction structural-evaluation-score (?mapping-or-correspondence)
 :documentation "Each mapping and correspondence has a structural evaluation score.
 Higher scores indicate more structural overlap, with a bias towards
 higher-order (in the Structure-Mapping sense) structure.
 This number is derived via SME automatically, as a side effect of the matching process.
 We use the functional version to express the result declaratively because this supports
 comparison of scores more easily.  In DTE what is asserted looks like
  (nvalue (structural-evaluation-score MH32) 0.2554), where nvalue requires
  its second argument to be a numerical value. ")

;;; (forall (?analogy-entity ?score)
;;;   (implies (and (analogy-entity-with-structural-evaluation ?analogy-entity)
;;;                 (nvalue (structural-evaluation-score ?analogy-entity) ?score))
;;;     (non-negative-number ?score)))

(defuniversalfact (arg1-isa structural-evaluation-score
                    analogy-entity-with-structural-evaluation))

(defrelation best-mapping (?match ?mapping) 
 :documentation "Indicates that ?mapping of ?match has the highest structural evaluation.")

(defuniversalfact (isa best-mapping functional-slot))
(defuniversalfact (arg1-isa best-mapping match))
(defuniversalfact (arg2-isa best-mapping mapping))

;;; CONSTRAINTS ON MATCHES

(defrelation required-correspondence (?base-item ?target-item)
  :documentation "In ?match, any mappings generated must have ?base-item
 corresponding to ?target-item.  ?base-item and ?target-item
 are either entities or expressions.  Useful when analogies are used
 in communication, e.g., the AnalogyMappingSpec entry in the CM CP grammar.
 This expresses control information that is used by SME.")

(defuniversalfact (arg1-isa required-correspondence cyc-expression))
(defuniversalfact (arg2-isa required-correspondence cyc-expression))
;;; (defuniversalfact (arg3-isa required-correspondence match))

(defrelation excluded-correspondence (?base-item ?target-item)
  :documentation "In ?match, any mappings generated must not have ?base-item
 corresponding to ?target-item.  ?base-item and ?target-item
 are either entities or expressions.  Useful when the best mapping so far looks
 unproductive, and one wants to force alternatives.
  This expresses control information that is used by SME. ")

(defuniversalfact (arg1-isa excluded-correspondence cyc-expression))
(defuniversalfact (arg2-isa excluded-correspondence cyc-expression))
;;; (defuniversalfact (arg3-isa excluded-correspondence match))

(defrelation must-map-item (?item ?base-or-target ?match)
  :documentation "In ?match, every mapping must include a correspondence
 that aligns ?item with something in the other description.  ?base-or-target
 is either the base or target description of ?match.
  This expresses control information that is used by SME. ")

(defuniversalfact (arg1-isa must-map-item cyc-expression))
(defuniversalfact (arg2-isa must-map-item cyc-expression))
(defuniversalfact (arg3-isa must-map-item case))

;;; CORRESPONDENCE

(defentity correspondence
 :subclass-of (abstract-information analogy-entity-with-structural-evaluation)
 :documentation "Represents a correspondence between an item in the base
 and an item in the target, with respect to a given match.
 As such, it can appear in multiple mappings under the same match.
 However, its structural evaluation is the same for every mapping. 
 See also correspondence-of and correspondence-between.") 

(defentity entity-correspondence
  :subclass-of (correspondence)
  :documentation "A correspondence that pairs up entities.")

(defentity expression-correspondence
  :subclass-of (correspondence)
  :documentation "A correspondence that pairs up expressions.")

(defentity functor-correspondence
  :subclass-of (correspondence)
  :documentation "A correspondence that pairs up functors.  Typically
   these will be identical, but not always, e.g., pressure aligned
   with temperature. ")

(defuniversalfact (partitioned-into correspondence 
                    (the-partition entity-correspondence
                      expression-correspondence functor-correspondence)))

(defrelation correspondence-of (?correspondence ?match)
 :documentation "?correspondence is part of ?match.")

(defuniversalfact (isa correspondence-of functional-slot))
(defuniversalfact (arg1-isa correspondence-of correspondence))
(defuniversalfact (arg2-isa correspondence-of match))

(defrelation has-correspondence (?mapping ?correspondence)
  :documentation "?correspondence is one of the correspondences
 that comprise ?mapping.  A correspondence can be part of multiple
 mappings.")

(defuniversalfact (arg1-isa has-correspondence mapping))
(defuniversalfact (arg2-isa has-correspondence correspondence))

(defrelation correspondence-between (?correspondence ?base-prop ?target-prop)
 :documentation "?correspondence is the hypothesis that ?base-item matches ?target-item.
 ?base-item and ?target-item can be entities, functors, or expressions.
 Mappings include a set of structurally consistent correspondences.
 For example, comparing WW-II to the Gulf war may produce a correspondence between Germany and Iraq.")

(defuniversalfact (arg1-isa correspondence-between correspondence))
(defuniversalfact (arg2-isa correspondence-between cyc-expression)) ;; entities or expressions
(defuniversalfact (arg3-isa correspondence-between cyc-expression))

(defrelation structurally-supported-by (?corr1 ?corr2)
  :documentation "?corr1 was hypothesized because of ?corr2.
 For example, entities are only aligned when some other match suggests
 them.  When combined with structure-mapping's tiered identicality
 constraint, this design choice avoids much of the brutal combinatorics
 of typical graph matchers.")

(defuniversalfact (arg1-isa structurally-supported-by correspondence))
(defuniversalfact (arg2-isa structurally-supported-by correspondence))

;;; (forall (?corr1 ?corr2 ?match)
;;;   ;; Probably some very clever Cyc way to say this...
;;;   (implies (and (match ?match)
;;;                 (structurally-supported-by ?corr1 ?corr2))
;;;     (<=> (correspondence-of ?corr1 ?match)
;;;       (correspondence-of ?corr2 ?match))))
 


;;; CANDIDATE INFERENCES

(defentity candidate-inference 
 :subclass-of (abstract-information)
 :documentation "An analogical inference suggested by a mapping. 
 Candidate inferences are surmises; they must be tested using other forms of reasoning.
 A candidate inference can be an entire piece of an argument, e.g., an implication
 with its antecedents and conclusions that appears in the base as a whole expression,
 or it can be a proposition.")

(defrelation candidate-inference-of (?candidate-inference ?mapping)
  :documentation "?candidate-inference is a consequence of ?mapping.")

(defuniversalfact (isa candidate-inference-of functional-slot))
(defuniversalfact (arg1-isa candidate-inference-of candidate-inference))
(defuniversalfact (arg2-isa candidate-inference-of mapping))

 
(defrelation candidate-inference-content (?candidate-inference ?prop)
  :documentation "?prop is the propositional content of ?candidate-inference")

(defuniversalfact (isa candidate-inference-content functional-slot))
(defuniversalfact (arg1-isa candidate-inference-content candidate-inference))
(defuniversalfact (arg2-isa candidate-inference-content cyc-formula))

(defrelation candidate-inference-support (?candidate-inference ?support-prop)
  :documentation "?support-prop was the base expression used to infer ?candidate-inference")

(defuniversalfact (isa candidate-inference-support functional-slot))
(defuniversalfact (arg1-isa candidate-inference-support candidate-inference))
(defuniversalfact (arg2-isa candidate-inference-support cyc-formula))

(defrelation candidate-inference-correspondence-support (?candidate-inference ?correspondence)
  :documentation "?correspondence supports ?candidate-inference")

(defuniversalfact (arg1-isa candidate-inference-correspondence-support candidate-inference))
(defuniversalfact (arg2-isa candidate-inference-correspondence-support correspondence))

(defquantityfunction support-score (?candidate-inference)
 :documentation "Degree of structural support ?candidate-inference gets from its mapping.")

(defuniversalfact (arg1-isa support-score candidate-inference))

(defquantityfunction extrapolation-score (?candidate-inference)
 :documentation "Degree to which ?candidate-inference introduces new information.")

(defuniversalfact (arg1-isa extrapolation-score candidate-inference))

(defreifiablefunction analogy-skolem (?entity)
  :result-isa cyc-expression
  :documentation "An arbitrary individual introduced during analogical reasoning.")

(defuniversalfact (gen-format analogy-skolem "something like ?entity" nil))

;;; STATES OF KNOWLEDGE ABOUT ANALOGICAL INFERENCES

(defrelation unvalidated-inference (?candidate-inference)
  :documentation "Indicates that the ?candidate-inference has not been checked. It is still a surmise, and thus needs checking.")

(defuniversalfact (arg1-isa unvalidated-inference candidate-inference))

(defrelation knowledge-plausible-inference (?candidate-inference)
  :documentation "?candidate-inference is both categorically plausible and is not known to be implausible. For example, a match between Save the Children and the Irish Republic Army might produce the candidate inference that Save the Children supports terrorist activities may be categorically plausible (organizations can support terrorist activities), but knowledge-implausible.
 Often knowledge plausibility will be tested via first-principles reasoning. ")

(defuniversalfact (arg1-isa knowledge-plausible-inference candidate-inference))


(defrelation invalid-inference (?candidate-inference)
  :documentation "?candidate-inference is known to be invalid with respect to current knowledge.")

(defuniversalfact (arg1-isa invalid-inference candidate-inference))


(defrelation categorically-plausible-inference (?candidate-inference)
  :documentation  "?candidate-inference doesn't violate category constraints or slot values. For example, saying that Iran has nuclear capability is categorically plausible because countries can have nuclear capability.  Saying that Iran has four legs isn't categorically plausible because it isn't an animal or furniture, and thus cannot have legs without changing the notion of what a nation is. (see metaphor)")

(defuniversalfact (arg1-isa categorically-plausible-inference candidate-inference))


(defrelation validity-difference (?mapping ?base-prop ?target-prop)
  :documentation "In ?mapping, ?base-prop and ?target-prop have different truth values. A possible example is (validity-difference Mapping-27 (nuclear-capability USSR) (nuclear-capability Iran)). Validity differences in consequences of candidate inferences indicate places where the original argumentation was incomplete, since in a complete and correct theory, if all the antecedents were true the consequences must be, assuming simple identicality was used.")

(defuniversalfact (arg1-isa validity-difference mapping))
(defuniversalfact (arg2-isa validity-difference cyc-formula))
(defuniversalfact (arg3-isa validity-difference cyc-formula))

;; The following rule says that if you know the implication of the candidate inference to be false,
;; the inference is invalid and there is a validity-difference in the mapping
;;
;;; (forall (?inference ?mapping ?content ?support)
;;;   (=> (and (categorically-plausible-inference ?inference)
;;;            (candidate-inference-content ?inference ?content)
;;;            (candidate-inference-support ?inference ?support)
;;;            (candidate-inference-of ?inference ?mapping)
;;;            (not ?content))
;;;     (and (validity-difference ?mapping ?support ?content)
;;;          (invalid-inference ?inference))))
           

(defrelation dimensional-difference (?mapping ?difference-pred ?base-term ?target-term)
  :documentation "In ?mapping, ?base-term and ?target-term differ as expressed by ?difference-pred. ?base-term and ?target-term must be functional expressions. For example, (dimensional-difference Mapping-27 Greater-Than (Population UUSR) (Population Iran))")

(defuniversalfact (arg1-isa dimensional-difference mapping))
(defuniversalfact (arg2-isa dimensional-difference binary-predicate))
(defuniversalfact (arg3-isa dimensional-difference function-expression))
(defuniversalfact (arg4-isa dimensional-difference function-expression))

;;;; REPORTING ON SIMILARITIES AND DIFFERENCES

(defrelation kernel-of (?corr ?mapping)
  :documentation "Correspondence ?corr is a kernel of mapping ?mapping.
 A kernel is a root of the match hypothesis forest within a match.
 Kernel mappings are combined to form global mappings, which are the
 output of SME.  When one is reporting similarities suggested by a mapping,
 correspondences that are kernels provide the largest units to work from." )

(defuniversalfact (arg1-isa kernel-of correspondence))
(defuniversalfact (arg2-isa kernel-of mapping))

(defrelation alignable-difference (?corr ?mapping ?base-item ?target-item)
  :documentation "?base-item and ?target-item constitute an alignable difference
 involving the items mentioned in correspondence ?corr with respect to mapping ?mapping.
 The items aligned in ?corr must participate somehow in ?base-item and ?target-item. 
 Psychologically, alignable differences are more salient than non-alignable differences." )

(defuniversalfact (arg1-isa alignable-difference correspondence))
(defuniversalfact (arg2-isa alignable-difference mapping))
(defuniversalfact (arg3-isa alignable-difference cyc-expression)) ;; Entity or expression
(defuniversalfact (arg4-isa alignable-difference cyc-expression)) ;; Entity or expression

;;; (forall (?corr ?mapping ?base-item ?target-item)
;;;   (implies (alignable-difference ?corr ?mapping ?base-item ?target-item)
;;;     (there-exists ?match
;;;       (there-exists ?base
;;;         (there-exists ?target
;;;           (and (match-between ?base ?target ?match)
;;;                (mapping-of ?mapping ?match)
;;;                (has-correspondence ?mapping ?match)
;;;                (case-description ?base ?base-item)
;;;                (case-description ?target ?target-item)))))))
               

;;;-----------------------------------------------------------------------------
;;; Allow iteration

(defrelation rematch-between (?base ?target ?match ?num)
  :documentation "Internal predicate used to remine the Case base for more matches to ?base")

;;;-----------------------------------------------------------------------------
;;; Commonalities and differences

(defrelation commonalities (?corr ?mapping ?shared ?obj-1-only ?obj-2-only)
  :documentation 
  "Recurively lists the commonalities and differences between ?obj-1 and ?obj-2 for the given mapping.")

(defuniversalfact (arg1-isa commonalities correspondence))
(defuniversalfact (arg2-isa commonalities mapping))
(defuniversalfact (gen-format commonalities "?shared but the BASE is involved in ?obj-1-only, while the TARGET is involved in ?obj-2-only" nil))

(defrelation same-thing (?obj-1 ?obj-2 ?class)
  :documentation 
  "Indicates that ?obj-1 and ?obj-2 are both of the same ?class")

(defuniversalfact (gen-format same-thing "?obj-1 and ?obj-2 are both ?class" nil))

(defrelation same-binary-relation (?obj-1 ?obj-2 ?relation ?other-arg)
  :documentation 
  "Indicates that ?obj-1 and ?obj-2 are correspond due to the ?relation with and ?other-arg")

(defuniversalfact (gen-format same-binary-relation "?obj-1 and ?obj-2 are both have a ?relation role with ?other-arg" nil))


(defrelation same-different (?corr ?mapping ?exact-common ?dimensional-common ?other-common ?obj-1-only ?obj-2-only)
  :documentation 
  "Lists the correspondence-between expression for ?exact-common (which says that all the other arguments
   in the correponding expressions are the same), ?dimenional-common (which says that there is one other argument
   that is different in the corresponding expressions and that difference is a dimensional one),
   ?other-common and the non-corresponding propositions for ?obj-1-only and ?obj-2-only for the given mapping.")

(defuniversalfact (arg1-isa same-different correspondence))
(defuniversalfact (arg2-isa same-different mapping))
(defuniversalfact (arg3-isa same-different cyc-expression))
(defuniversalfact (arg4-isa same-different cyc-expression))
(defuniversalfact (arg5-isa same-different cyc-expression))
(defuniversalfact (arg6-isa same-different cyc-expression))
(defuniversalfact (arg7-isa same-different cyc-expression))
(defuniversalfact (gen-format same-different "?shared but the BASE is involved in ?obj-1-only, while the TARGET is involved in ?obj-2-only" nil))


(defrelation similarities (?corr ?mapping ?exact-common ?dimensional-common ?other-common)
  :documentation 
  "Lists the correspondence-between expression for ?exact-common (which says that all the other arguments
   in the correponding expressions are the same), ?dimenional-common (which says that there is one other argument
   that is different in the corresponding expressions and that difference is a dimensional one),
   and shared alignable difference <?alignable-differences>.")


(defrelation differences (?corr ?mapping ?alignable-differences ?obj-1-only ?obj-2-only)
  :documentation 
  "Lists the correspondence-between expression for 
   shared alignable difference <?alignable-differences> and the non-corresponding propositions
   for ?obj-1-only and ?obj-2-only for the given mapping which are inferable alignable differences.")


;;;-----------------------------------------------------------------------------
;;; CASE FILTERING

(defreifiablefunction agent-case-fn (?agent)
  :result-isa case
  :documentation
  "Creates a Case by finding all the relations that reference ?agent, plus all relations between 
   objects in that first set of relations.  (Designed with ?agent being of type agent.)")

(defreifiablefunction agent-in-context-case-fn (?agent ?context)
  :result-isa case
  :documentation
  "Creates a Case by finding all the relations that reference ?agent, that are within the scope of the
   event ?context (context constrained by case-sub-event-predicate)")


(defreifiablefunction event-case-fn (?event)
  :result-isa case
  :documentation
  "Creates a Case by finding all the relations that reference ?event")

(defreifiablefunction event-no-postlude-case-fn (?event)
  :result-isa case
  :documentation
  "Creates a Case by finding all the relations that reference ?event, but excludes any facts 
   that references what things this event causes")


(defreifiablefunction recursive-case-fn (?event ?predicate)
  :result-isa case
  :documentation
  "Creates a Case by finding all the relations that reference ?event, plus all the relations
   that refernces any of its sub-events (constrained by case-sub-event-predicate) ")


(defreifiablefunction interest-case-fn (?interest)
  :result-isa case
  :documentation
  "Creates a Case by finding all the relations that reference the interest/goal ?interest")

(defreifiablefunction interest-no-postlude-case-fn (?interest)
  :result-isa case
  :documentation
  "Creates a Case by finding all the relations that reference the interest/goal ?interest,
   but excludes any facts that references what things this event causes ")

(defreifiablefunction interest-in-context-case-fn (?interest ?context)
  :result-isa case
  :documentation
  "Creates a Case by finding all the relations that reference the interest/goal ?interest
   that are within the scope of the event ?context (context constrained by case-sub-event-predicate)")


(defreifiablefunction case-fn (?obj1 ?obj2)
  :result-isa case
  :documentation
  "Creates a Case by finding all the relations that are common between ?obj1 and ?obj2.  Also includes
   all the isa relations between the objects referenced in those relations.")

(defreifiablefunction case-w-filter-fn (?obj1 ?obj2 ?query)
  :result-isa case
  :documentation
  "Creates a Case by finding all the relations that are common between ?obj1 and ?obj2, and
   all the relations that are used to generate the answer to the query.  Also includes
   all the isa relations between the objects referenced in those relations.")

(defreifiablefunction case-by-query-fn (?query)
  :result-isa case
  :documentation
  "Creates a Case by finding all the relations that are used to generate the answer to the query. 
   Also includes all the isa relations between the objects referenced in those relations.")

(defreifiablefunction enhanced-case-fn (?case ?query)
  :result-isa case
  :documentation
  "Creates a Case by finding all the relations that are used to generate the answer to the query,
   with the query scoped by the facts originally specified in ?case. 
   Also includes all the isa relations between the objects referenced in those relations.")

(defreifiablefunction extended-case-fn (?original-case-name ?justification)
  :result-isa case
  :documentation
  "Creates a Case by adding all facts of form (ist--information ?original-case-name <fact>) which
   has the justification label set to ?justification in the reasoning session.")


(defreifiablefunction case-conjunction-fn (?case1 ?case2)
  :result-isa case
  :documentation
  "Creates a Case by combining the information from the ?case1 and ?case2.")

(defreifiablefunction case-by-event-set-fn (?set-of-events)
  :result-isa case
  :documentation
  "Creates a Case by applying event-case-fn on each of the elements of the ?set-of-events
   and unioning the facts together.")

;;;-----------------------------------------------------------------------------
;;; EXTENDED MATCHING

(defreifiablefunction extended-match-fn (?match ?correspondence)
  :result-isa match
  :documentation
  "Creates a new match by extending the ?match by looking at the details suggested by ?correspondence
   This invalidates the old ?match.  Usage example (best-mapping (extended-match-fn match13 mapping43) ?x).")

(defreifiablefunction exhaustive-match-fn (?match)
  :result-isa match
  :documentation
  "Creates a new match by extending the ?match by looking at the details suggested by all the mappings in the original ?match.
   This invalidates the old ?match.  Usage example (best-mapping (exhaustive-match-fn match13) ?x).")

(defreifiablefunction contentious-correspondences (?match)
  :result-isa set--mathematical
  :documentation
  "Lists the names of the match-hypotheses which are in consistent across them mappings within the given match.")

(defrelation quick-match-between (?base ?target ?match)
 :documentation "Uses SME to make a ?match from ?base to ?target, but by-passes the merge step
 (returns the biggest kernel). Useful for image retrieval in which a person makes the final decision about 
 what's best")

(defrelation recursive-match-between (?base ?target ?match)
 :documentation "Uses SME to make ?match is from ?base to ?target, but automatically builds up the 
  base and target cases by getting more detail about events put in correspondence.")

(defrelation seeking-match-between (?base ?target ?match)
  :documentation "Uses SME to match ?base and ?target, with the comparison represented by ?match.
 Does recursive case buildup, but also uses required constraints to focus the match.") 

(defrelation vanilla-match-between (?base ?target ?match)
  :documentation "Uses SME to match ?base and ?target, with the comparison represented by ?match.
 This is the orignal -- no recursion, no content vector adjustment.") 

;;;-----------------------------------------------------------------------------
;;; DECLARATIVE MATCHING PARAMETERS

;;; (defrelation case-expansion-level (?level)
;;;   :documentation
;;;   "Globally sets the case expansion level.  When gathering the relations to build a case out of an object, 
;;;    deterimines the amount of expansion of the related objects. NONE indicates only isa relations for the other
;;;    objects. SOME indicates isa + relations that link to other objects already in the case.  ALL indicates 
;;;    SOME + all other relations mentioning only the object. Default is NONE")
;;; 
;;; (defuniversalfact (individual NONE))
;;; (defuniversalfact (individual SOME))
;;; (defuniversalfact (individual ALL))
;;; (defuniversalfact (arg1-format case-expansion-level single-entry))

(defrelation case-sub-event-predicate (?predicate)
  :documentation
  "Globally sets the predicates used for recursively creating an case out of an event.
   When gathering the relations to build a case out of an event, any <sub-event> of the form
   (?predicate <event> <sub-event>) will also be expanded.")

(defrelation ubiquitous-predicate (?predicate)
  :documentation
  "Globally sets the predicates that are ignored during the matching process for the purpose of 
   providing support for a correspondece.  For example, since every object is a THING, it is ubiquitous
   and saying that two items are similar because they are both THINGS isn't useful.")

(defrelation ubiquitous-for (?predicate ?context)
  :documentation
  "Tells which <predicate>s should be deemed ubiquitous for a given <context>.")

(defrelation sme-same-functor-score (?value)
  :documentation
  "Changes the default value for the score SME gives for having two expressions with the same predicate")

(defrelation sme-same-function-score (?value)
  :documentation
  "Changes the default value for the score SME gives for having two NATs with the same predicate")


;;;; ---------------------------------------------------------------------------
;;;; Predicates to help the case extraction reasoning process

(defrelation content-vector (?case ?value)
  :documentation
  "Relates the MAC/FAC content vector (represented by a list of (PRED-ID . num-referenced)) to its case.")

(defrelation sub-part-predicate (?predicate)
   :documentation
   "Tells the reasoner what the binary predicate indentifies sub-parts of the form (<pred> <item> <part>).
    Part can be a sub event, sub-goal, sub-part, etc.
    See also reverse-sub-part-predicate.  Assumes only one instance of these two types")

(defrelation reverse-sub-part-predicate (?predicate)
   :documentation
   "Tells the reasoner what the binary predicate indentifies sub-parts of the form (<pred> <part> <item>).
    Part can be a sub event, sub-goal, sub-part, etc.
    See also sub-part-predicate.  Assumes only one instance of these two types")


(defrelation forward-causality-predicates (?predicate)
   :documentation
    "Tells the reasoner what the binary predicate indentifies forward causality of the form 
    (<pred> <antecedent> <consequent>). Can be more than one. Only need to specify the parent predicates.
    See also reverse-causality-predicates")

(defrelation reverse-causality-predicates (?predicate)
   :documentation
    "Tells the reasoner what the binary predicate indentifies forward causality of the form 
    (<pred> <consequent> <antecedent>).  Can be more than one. Only need to specify the parent predicates.
    See also forward-causality-predicates")

(defrelation item-expandable (?item ?depth)
   :documentation
   "Indicates whether these two items are worth getting more data to extend the SME match")


;;;; ---------------------------------------------------------------------------
;;; END OF CODE