# Relations

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.

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.

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.

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.

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.

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.).

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.

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.

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.

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.

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.