**Relations**

#$Relation relationships

The collection of relations whose CycL representations can appear in the 0th (or arg0 ) argument position of a #$CycLFormula, i.e. as the term immediately following the formula's opening parenthesis. An important subcollection of #$Relation is #$TruthFunction (q.v.), whose instances are intimately related to truth-values, as reflected in the fact that the CycL expressions that denote truth-functions can appear in the arg0 position of a #$CycLSentence; and a sentence (if quantificationally closed; see #$CycLClosedSentence), will generally be either true or false (with respect to a given context or interpretation). The major subcollections of #$TruthFunction are #$Predicate, #$LogicalConnective, and #$Quantifier (qq.v.). Another important subcollection of #$Relation is #$Function-Denotational (q.v.), whose instances are functions the CycL expressions for which can appear in the arg0 position of a #$CycLNonAtomicTerm; and such terms (if closed) generally denote things.

guid: bd5880cd-9c29-11b1-9dad-c379636f7270

direct instance of: #$RelationshipType #$AtemporalNecessarilyEssentialCollectionType

direct specialization of: #$MathematicalObject

direct generalization of: #$ELRelation #$ScopingRelation #$VariableArityRelation #$AssociativeRelation #$MacroRelation #$Function-Denotational #$MicrotheoryDesignatingRelation #$CommutativeRelation #$FunctionalRelation #$EvaluatableRelation #$TruthFunction #$FixedArityRelation #$PartiallyCommutativeRelation

#$arity arity (intangible object relating predicate) (default monotonic predicate) (predicate that is functional in its second argument)

A #$MetaRelation used for stating that a given relation takes a specified number of arguments. (#$arity RELN N) means that that semantic well-formedness requires that RELN take exactly N arguments at a time. That is, a formula (RELN ARG1 ... ARGM) is semantically well-formed only if M = N. For example, the #$arity of any instance of #$BinaryPredicate is 2. Note that full semantic well-formedness requires obeying argument-type constraints (see #$ArgTypePredicate) as well as arity constraints. For a general explanation of semantic well-formedness, see #$CycLExpression-Assertible. See also #$CycLExpression-Askable.

guid: bd5880ce-9c29-11b1-9dad-c379636f7270

direct instance of: #$OpenCycDefinitionalPredicate #$IntangibleObjectRelatingPredicate #$DefinitionalPredicate #$StrictlyFunctionalSlot #$DefaultMonotonicPredicate #$MetaRelation

#$VariableArityRelation variable arity relation

A specialization of #$Relation. Each instance of #$VariableArityRelation is a relation that can take a variable number of arguments. Examples of #$VariableArityRelation include the predicate #$different and the function #$PlusFn.

guid: bd5d0b56-9c29-11b1-9dad-c379636f7270

direct instance of: #$RelationshipTypeByArity #$AtemporalNecessarilyEssentialCollectionType

direct specialization of: #$Relation

direct generalization of: #$VariableAritySkolemFuncN #$VariableAritySkolemFunction #$VariableArityFunction

#$CommutativeRelation commutative relations

A collection of #$Relations and an instance of #$RelationTypeByLogicalFeature (q.v.). Each instance of #$CommutativeRelation COMREL is a predicate or function that is commutative in all of its argument-places. That is, if COMREL is a predicate (function) that holds among (has the value VAL for) a given sequence of arguments, then COMREL also holds among (has the same value VAL for) any permutation of that sequence. Instances include #$PlusFn, #$or, #$bordersOn, #$temporallyIntersects, and #$teammates. Specialization include #$SymmetricBinaryPredicate. Note that most relations are _not_ commutative. See also #$PartiallyCommutativeRelation.

guid: bd6449a2-9c29-11b1-9dad-c379636f7270

direct instance of: #$RelationTypeByLogicalFeature #$AtemporalNecessarilyEssentialCollectionType

direct specialization of: #$Relation

direct generalization of: #$SymmetricBinaryPredicate

#$FunctionalRelation functional relations

A specialization of #$Relation each instance of which is either a function (see #$Function-Denotational) or a predicate that is functional in at least one argument-place (see #$FunctionalPredicate and #$functionalInArgs). Examples include #$IntervalMaxFn, #$ElectricalPotentialDifferenceFn, #$revenueFromType, #$costRateForType, and #$biologicalMother. See also the specialization #$StrictlyFunctionalRelation.

guid: bd5880a3-9c29-11b1-9dad-c379636f7270

direct instance of: #$RelationshipType

direct specialization of: #$Relation

direct generalization of: #$StrictlyFunctionalPredicate #$Function-Denotational #$FunctionalPredicate #$StrictlyFunctionalRelation

#$FunctionalPredicate functional predicates

A specialization of #$Predicate whose instances are those predicates that are functional in at least one argument-place (see #$functionalInArgs and #$singleEntryFormatInArgs). That is, given any sequence of legal arguments placed in such a predicate's other argument positions, there is at most one argument such that, when it is placed in the predicate's functional position, the resulting formula is true. More precisely: Suppose PRED is an N-ary instance of #$FunctionalPredicate that is functional in its Kth place. Given any (N-1)-tuple consisting of things that are, respectively, legal arguments for (i.e. satisfy all argument-constraints on) the N-1 argument-places in PRED other than its Kth-place, there is at most one thing -- call it O(K) -- such that (PRED O(1)..O(N)) is true. (The one exception to the above is when the entry-format for PRED's functional argument-place is #$intervalEntryFormatInArgs (q.v.) instead of #$singleEntryFormatInArgs. In that case there might be multiple instances INT-1..INT-M of #$ScalarInterval that, when put in this argument-place, each yield a true formula; but only if all of the INT-i overlap one another and thus have a common sub-interval; see #$quantityIntersects and #$quantitySubsumes. Cf. #$StrictlyFunctionalPredicate.) For example, #$biologicalMother is functional in its second argument-place, since every animal has one and only one biological mother. Note that it might be the case that, for some ways of fixing PRED's other arguments, there will be _nothing_ that would yield a true formula when put into PRED's functional argument-place; for example, while a spatial thing has at most one length (see #$lengthOfObject), if it is (say) a sphere it has none. A binary #$FunctionalPredicate that is functional in its second argument is an instance of #$FunctionalSlot (q.v.).

guid: bd58dc77-9c29-11b1-9dad-c379636f7270

direct instance of: #$PredicateCategory #$AtemporalNecessarilyEssentialCollectionType

direct specialization of: #$FunctionalRelation #$Predicate

direct generalization of: #$StrictlyFunctionalPredicate #$FunctionalSlot

#$FunctionalSlot predicates that is functional in its second argument

A specialization of #$FunctionalPredicate each instance of which is a binary predicate that is functional in its second argument position. More precisely, a binary predicate PRED is an instance of #$FunctionalSlot if, for any legal occupant THING1 of PRED's first (or arg1 ) argument position, there is at most one legal occupant THING2 of PRED's second (or arg2 ) argument position such that (PRED THING1 THING2) holds. (The foregoing sufficient condition is not necessary in the case where the arg2 entry-format of PRED is #$intervalEntryFormatInArgs (q.v.) instead of #$singleEntryFormatInArgs; see the comment for #$FunctionalPredicate for that case. Cf. #$StrictlyFunctionalSlot.) #$FunctionalSlot is thus the subcollection of the collection-intersection of #$BinaryPredicate and #$FunctionalPredicate containing those predicates whose second argument (at least) is functional. Examples include #$latitude, #$countryOfAddress, and #$femaleParentActor.

guid: bd5881a4-9c29-11b1-9dad-c379636f7270

direct instance of: #$PredicateCategory #$AtemporalNecessarilyEssentialCollectionType

direct specialization of: #$FunctionalPredicate #$BinaryPredicate

direct generalization of: #$StrictlyFunctionalSlot #$IntervalBasedQuantitySlot

#$Function-MathematicalObject mathematical type of functions **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

The collection of functions and a specialization of #$Relation-MathematicalObject. Each instance of #$Function-MathematicalObject is a many-one relation that represents a mapping from one set of things (the function's #$relationDomain) to another set of things (its #$relationRange). As a many-one relation, a function maps each thing in its domain to exactly one thing in its range. A function is either unary, binary, ternary, or whatever (see #$functionalArity; but cf. #$relationalArity), depending on the nature of the members of its domain. In general, the domain of an N-ary function is a set of ordered N-tuples (construed in CycL as #$Lists of length N). The function is said to take the items from any of these N-tuples as its N _arguments_ and to return a member of its range as its corresponding _value_. A key specialization of #$Function-MathematicalObject is #$FixedArityFunction (which is also a specialization of #$Function-Denotational). Instances include the elements of #$Distribution and the (non-denumerably many) one-to-one correspondences that exist between the positive integers and the rational numbers. See also #$valueOfFunctionForArgs, #$DomainOfFunctionFn, and #$RangeOfFunctionFn.

guid: bee42bbb-9c29-11b1-9dad-c379636f7270

direct instance of: #$ObjectType #$AtemporalNecessarilyEssentialCollectionType

direct specialization of: #$Relation-MathematicalObject

direct generalization of: #$BinaryFunction #$QuintaryFunction #$UnaryFunction #$QuaternaryFunction #$TernaryFunction #$FixedArityFunction #$OneToOneFunction

#$EvaluatableRelation evaluatable relations

A specialization of #$Relation. Each instance of #$EvaluatableRelation is a function or predicate for which there is some piece of system code that can be invoked to evaluate (i.e. to determine the denotation or truth-value of) a closed expression built from that function or predicate (i.e. a closed expression that has the constant that denotes that function or predicate in its initial or 0th argument-place). An evaluation of this sort is carried out, for example, when the system is queried using an #$evaluate (q.v.) sentence. As one might expect, most evaluatable relations are mathematical or syntactic in nature; for numbers, sets, lists, and strings are the sorts of things that are related in various ways that can be calculated algorithmically. Examples include #$PlusFn, #$greaterThan, #$JoinListsFn, and #$substring. In the case of a function that is evaluatable (see #$EvaluatableFunction), the practical result of evaluating the relevant expression is another _term_ -- one that has the same denotatum as the original expression, but that is syntactically simpler and constitutes a more straightforward way of referring to that denotatum. For example, the term `(#$PlusFn (#$Inch 3) (#$Inch 1))', when evaluated, results in the term `(#$Inch 4)'. So if a query using the open sentence `(#$evaluate ?X (#$PlusFn (#$Inch 3) (#$Inch 1)))' is asked, the answer (or binding for the variable `?X') returned will be the term `(#$Inch 4)'. Evaluating a sentence built from (a constant that denotes) an #$EvaluatablePredicate, on the other hand, yields a _truth-value_. For example, the sentence `(#$greaterThan (#$Inch 3) (#$Inch 1))' evaluates to (and so if used to ask a query will return the answer) `#$True'. The predicate #$evaluationDefn (q.v.) is used to specify the name of the piece of system code used to evaluate expressions formed with a given evaluatable relation.

guid: bfb0e3f0-9c29-11b1-9dad-c379636f7270

direct instance of: #$RelationshipType #$AtemporalNecessarilyEssentialCollectionType

direct specialization of: #$Relation

direct generalization of: #$EvaluatableFunction #$EvaluatablePredicate

#$evaluationDefn evaluation defn **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

The Cyc predicate #$evaluationDefn is used to relate an evaluatable Cyc function or predicate to the name of the piece of code that is used to evaluate it. (#$evaluationDefn E-REL NAME) means that the #$SubLSymbol NAME is the name of a piece of Heuristic Level (SubL) code in the Cyc system which is used to compute the value of expressions containing the #$EvaluatableRelation E-REL.

guid: bd5880c1-9c29-11b1-9dad-c379636f7270

direct instance of: #$CycInferenceDescriptorPredicate #$InferenceRelatedBookkeepingPredicate #$IntangibleObjectRelatingPredicate #$StrictlyFunctionalSlot #$DefaultMonotonicPredicate

#$TruthFunction truth-functions

A major subcollection of #$Relation that subsumes the collections #$Predicate, #$LogicalConnective, and #$Quantifier (qq.v.). Truth-functions, or rather the expressions that represent or denote them, are used to form sentences. More precisely, any CycL expression that denotes an instance of #$TruthFunction (and only such an expression) can appear in the 0th (or arg0 ) position (i.e. as the term immediately following the opening parenthesis) of a #$CycLSentence. The name `TruthFunction' derives in part from the fact that the sentences thus formed (if semantically well-formed and quantificationally closed; see #$CycLSentence-Assertible and #$CycLClosedSentence) are the kind of expression that can be true or false (with respect to a given context and interpretation). Though not really functions (cf. #$Function-Denotational), #$TruthFunctions are truth-functional in the sense that the truth-value of a (closed, semantically well-formed) sentence (RELN ARG1..ARGN) built using a truth-function RELN is uniquely determined (with respect to a given context) by RELN together with the argument(s) ARG1..ARGN to which it is applied. For example, the sentence `(#$mother #$ChelseaClinton #$HillaryClinton)' is made true (in the actual world) by the fact that Chelsea Clinton's mother is Hillary Clinton.

guid: bea64551-9c29-11b1-9dad-c379636f7270

direct instance of: #$RelationshipType #$AtemporalNecessarilyEssentialCollectionType

direct specialization of: #$Relation

direct generalization of: #$SententialRelation #$Predicate