## Cyc Fundamental Vocabulary

E-Mail Comments to: opencyc-doc@cyc.com
Last Update: 4/5/02
Copyright© 1996-2002. All rights reserved. See Terms of Usage.

Return to Documentation Contents
Return to Vocabulary Contents

### Basics

#$Thing things

> #$Thing is the universal collection : the collection which, by definition, contains everything there is. Every thing in the Cyc ontology -- every #$Individual (of any kind), every #$Set-Mathematical, and every #$Collection -- is an instance of (see #$isa) #$Thing. Similarly, every collection is a subcollection of (see #$genls) #$Thing. Trivially, #$Thing is both an instance of and a subcollection of itself, and is not a subcollection of any other collection. (Note that the above reference to every thing in the Cyc ontology is _not_ meant to be limited to things actually _reified_ in the Cyc system, but includes (e.g.) every instance -- reified or not, known or not -- of every collection recognized by Cyc.)
> guid: bd5880f4-9c29-11b1-9dad-c379636f7270
> direct instance of: #$VariableOrderCollection
> direct specialization of:
> direct generalization of: #$ProposedPublicConstant #$ReformulatorIrrelevantFORT #$ReformulatorHighlyRelevantFORT #$IndeterminateTerm #$AspectTenseConstant #$CustomaryPathCycConstant #$SubLTemplate #$SubLExpression #$TermPhrasesConstraint #$ELTemplate #$IndexicalConcept #$CycLTerm #$TheTerm #$AttributeValue #$PartiallyIntangible #$TestingConstant #$PartiallyTangible #$SetOrCollection #$Intangible #$ELVariable #$Microtheory #$ELSentence-Assertible #$SubLSymbol #$Relation #$Individual #$Collection #$Dog

#$Individual objects

> #$Individual is the collection of all individuals: things that are _not_ sets or collections. Individuals might be concrete or abstract, and include (among other things) physical objects, events, numbers, relations, and groups. An instance of #$Individual might have parts or structure (including discontinuous parts); but _no_ individual has elements or subsets (see #$elementOf and #$subsetOf). Thus, an individual that has parts (e.g. #$physicalParts or #$groupMembers) is _not_ the same thing as either the set or the collection containing those same parts. For example, your car is an individual, but the collection of all the parts of your car is not an individual but an instance of #$Collection. This collection (unlike the car itself) is abstract: it doesn't have a location, mass, or a top speed; but it does have instances, subcollections, and supercollections. In partial contrast, the #$Group (q.v.) of parts of your car (while also not the same thing as the car itself) _is_ an individual that has location and mass. Another example: A given company, the group consisting of all the company's employees, the collection of those employees, and the set of those employees are four distinct things, and only the first two are individuals.
> guid: bd58da02-9c29-11b1-9dad-c379636f7270
> direct instance of: #$FirstOrderCollection
> direct specialization of: #$Thing
> direct generalization of: #$ReformulatorMode #$PartiallyIntangibleIndividual #$IntangibleIndividual #$TemporalThing #$SpatialThing #$Artifact #$Microtheory #$Relation #$Path-Generic #$PathSystem #$Traversal

#$Collection types of things **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> The collection of all Cyc collections. Cyc collections are natural kinds or classes, as opposed to mathematical sets; their instances have some common attribute(s). Each Cyc collection is like a set in so far as it may have elements, subsets, and supersets, and may not have parts or spatial or temporal properties. Sets, however, differ from collections in that a mathematical set may be an arbitrary set of things which have nothing in common (see #$Set-Mathematical). In contrast, the instances of a collection will all have in common some feature(s), some `intensional' qualities. In addition, two instances of #$Collection can be co-extensional (i.e., have all the same instances) without being identical, whereas if two arbitrary sets had the same elements, they would be considered equal. As with any Cyc constant, an instance of #$Collection should be created only if it is expected to have some purpose or utility. Moreover, the `best' collections to create are the ones which are impossible to define precisely, yet about which there are rules and other things to say. E.g., `WhiteCat' is not a good element of #$Collection to create, because it's easy to define with other Cyc concepts, and there's not much to say about the collection of white cats; but `WhiteCollarWorker' could be a good instance of #$Collection, because it is hard to define exactly, yet there are many things to say about it.
> guid: bd5880cc-9c29-11b1-9dad-c379636f7270
> direct instance of: #$VariableOrderCollection #$CollectionType
> direct specialization of: #$SetOrCollection
> direct generalization of: #$TotallyOrderedCollection #$FixedOrderCollection #$VariableOrderCollection #$SpecifiedCollection #$CollectionType #$ConventionalClassificationType #$NLCollection

#$Individual and #$Collection are disjoint collections: no Cyc constant can be an instance of both.

Any general concept, such as being a person or walking, is represented in Cyc by a collection; e.g., #$Person and #$AnimalWalkingProcess, respectively, each of which #$isa #$Collection. But any particular person or action, such as #$JohnKennedy or #$WorldWarII, #$isa #$Individual. Note that both #$Individual and #$Collection are themselves elements of #$Collection.

#$Predicate pred

> A specialization of #$TruthFunction (q.v.). Each instance of #$Predicate is either a property of things (see #$UnaryPredicate) or a relationship holding between two or more things. Like other truth-functions, predicates, or rather the expressions that represent or denote them, are used to form sentences. More precisely, any CycL expression that denotes an instance of #$Predicate (and only such an expression) can appear in the 0th (or arg0 ) position (i.e. as the term following the opening parenthesis) of a #$CycLAtomicSentence (q.v.). Important specializations of #$Predicate include #$UnaryPredicate, #$BinaryPredicate, #$TernaryPredicate, #$QuaternaryPredicate, and #$QuintaryPredicate. Note that, despite its name, #$Predicate is a collection of _relations_, and not a collection of expressions that represent or denote such relations.
> guid: bd5880d6-9c29-11b1-9dad-c379636f7270
> direct instance of: #$PredicateCategory
> direct specialization of: #$TruthFunction
> direct generalization of: #$SituationTypePredicate #$PropositionPredicate #$KindLevelPredicate #$StageLevelPredicate #$IndividualLevelPredicate #$ComparisonPredicate #$GeneralizedQuantifierRelation #$ReformulatorDirectivePredicate #$MicrotheoryDesignatingPredicate #$AttributePredicate #$CanonicalizerDirectivePredicate #$CycLReformulationRulePredicate #$DocumentationPredicate #$CycInferenceDescriptorPredicate #$EvaluatablePredicate #$SlotTrendPredicate #$RuleMacroPredicate #$DefaultMonotonicPredicate #$UnaryPredicate #$FunctionalPredicate #$Role #$TypePredicate #$MicrotheoryPredicate #$MetaKnowledgePredicate #$QuaternaryPredicate #$TernaryPredicate #$QuintaryPredicate #$PhysicalFeatureDescribingPredicate #$ObjectPredicate #$BookkeepingPredicate #$BinaryPredicate #$CollectionPredicate #$OpenCycNLPredicate #$OpenCycDefinitionalPredicate #$PlanActionRestrictionPredicate #$PossibleDefinitionalPredicate

#$isa isa (taxonomic slot)

> A #$TaxonomicSlot (q.v.) that relates things of any kind to collections (see #$Collection) of which they are instances. (#$isa THING COL) means that THING is an instance of the collection COL. #$isa is by far the most commonly-occurring predicate in the Cyc Knowledge Base, and is one of the relations most fundamental to the Cyc ontology. An important logical feature of #$isa is that it transfers through #$genls (q.v.): (#$isa THING COL) and (#$genls COL SUPERCOL) jointly imply (#$isa THING SUPERCOL). This logical feature is expressed in a rule that -- along with various other rules that also sanction the derivation of #$isa sentences -- has been asserted to the Knowledge Base. As a result, only a small fraction of the #$isa based ground atomic formulas (or GAF s; see #$CycLClosedAtomicSentence) the Cyc system knows to be true have been manually asserted; the vast majority have been derived, or are derivable, automatically by the Cyc inference engine via the use of such rules. See also #$elementOf.
> guid: bd588104-9c29-11b1-9dad-c379636f7270
> direct instance of: #$OpenCycDefinitionalPredicate #$ReformulatorIrrelevantFORT #$DefaultMonotonicPredicate #$TaxonomicSlotForAnyThing #$DefinitionalPredicate
> direct specialization of: #$elementOf

#$genls genls

> A instance of #$TaxonomicSlotForCollections (q.v.) and a specialization of #$generalizations. #$genls relates a given collection (see #$Collection) to those collections that subsume it. More precisely, (#$genls SUBCOL SUPERCOL) means that SUPERCOL is a supercollection of SUBCOL: anything that is an instance of (see #$isa) SUBCOL is also an instance of SUPERCOL. For example, (#$genls #$Dog #$Mammal) holds. #$genls is one of the most commonly-occurring predicates in the Cyc Knowledge Base, and one of the relations most fundamental to the Cyc ontology. See also #$subsetOf.
> guid: bd58810e-9c29-11b1-9dad-c379636f7270
> direct instance of: #$OpenCycDefinitionalPredicate #$ReformulatorIrrelevantFORT #$RuleMacroPredicate #$DefaultMonotonicPredicate #$ReflexiveBinaryPredicate #$TransitiveBinaryPredicate #$TaxonomicSlotForCollections #$KindLevelPredicate #$DefinitionalPredicate
> direct specialization of: #$subsetOf

### Disjoint Collections

#$disjointWith disjoint with

> This predicate relates collections that have no instances in common. (#$disjointWith COL1 COL2) means that COL1 is disjoint with COL2: nothing is an element of both. Note that this predicate is _not_ irreflexive: it is trivially possible for a #$Collection to be disjoint with itself, but only if it is empty (i.e. has no instances). Thus, for example, (#$disjointWith #$Nothing #$Nothing) holds.
> guid: bd5880e3-9c29-11b1-9dad-c379636f7270
> direct instance of: #$OpenCycDefinitionalPredicate #$RuleMacroPredicate #$DefaultMonotonicPredicate #$TaxonomicSlotForCollections #$SymmetricBinaryPredicate #$PossibleDefinitionalPredicate

#$SiblingDisjointCollection sibling disjoint collections **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> A collection of collections of collections (and thus an instance of #$CollectionTypeType, as well as a specialization of #$CollectionType). Each instance SIB of #$SiblingDisjointCollection has the following property: For any two instances COL-1 and COL-2 of SIB, either (#$genls COL-1 COL-2), (#$genls COL-2 COL-1), (#$disjointWith COL-1 COL-2), or (#$siblingDisjointExceptions COL-1 COL-2) holds. Moreover, note that if neither (#$genls COL-1 COL-2), (#$genls COL-2 COL-1), nor (#$siblingDisjointExceptions COL-1 COL-2) is known to hold (see the predicate #$knownSentence) in a context in which all of (#$isa SIB #$SiblingDisjointCollection), (#$isa COL-1 SIB) and (#$isa COL-2 SIB) hold, then (#$disjointWith COL-1 COL-2) will hold by default in that context. For example, both #$Person and #$Dog are instances of #$BiologicalSpecies, an instance of #$SiblingDisjointCollection, in the context of the #$BiologyMt. Moreover, for obvious reasons, neither (#$genls #$Person #$Dog), (#$genls #$Dog #$Person), nor (#$siblingDisjointExceptions #$Person #$Dog) is known to hold in the #$BiologyMt. Consequently, (#$disjointWith #$Person #$Dog) holds by default in the #$BiologyMt. Notable instances of #$SiblingDisjointCollection include #$BiologicalTaxon and its specializations, #$DefaultDisjointScriptType, #$OrganismPartType, and #$RelationshipTypeByArity.
> guid: bd5880e2-9c29-11b1-9dad-c379636f7270
> direct instance of: #$CollectionTypeType #$VariableOrderCollection
> direct specialization of: #$CollectionType #$SiblingDisjointSetOrCollection
> direct generalization of: #$DisjointCollectionType

#$siblingDisjointExceptions sibling disjoint exceptions

> The predicate #$siblingDisjointExceptions is used to state exceptions to constraints normally imposed by some instance of #$SiblingDisjointCollection. (#$siblingDisjointExceptions COL1 COL2) means that the relationship between the collections COL1 and COL2 is exempt from the disjointness constraint which would otherwise be imposed because COL1 and COL2 are both instances of some instance of #$SiblingDisjointCollection. (See #$SiblingDisjointCollection for a full explanation of the constraints.) For example, #$Reading and #$TouchPerception are both instances of #$DefaultDisjointScriptType, which in turn is an instance of #$SiblingDisjointCollection. Consequently, since #$Reading is not a specialization of #$TouchPerception, and #$TouchPerception is not a specialization of #$Reading, the two collections have a default disjointness constraint placed between them. However, such a disjointness constraint should be blocked, since any instance of reading a Braille text is both an instance of #$Reading and an instance of #$TouchPerception. By asserting (#$siblingDisjointExceptions #$Reading #$TouchPerception), we block the disjointness constraint between those two collections, without disturbing the constraints between each of those collections and all the other instances of their parent (disjoint) collection, #$DefaultDisjointScriptType.
> guid: c10b559a-9c29-11b1-9dad-c379636f7270
> direct instance of: #$IrreflexiveBinaryPredicate #$SymmetricBinaryPredicate #$OpenCycDefinitionalPredicate #$DefinitionalPredicate

#$TheCovering the covering (relationship) **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> This is a special variable-arity #$ReifiableFunction that allows one to specify a set of collections or mathematical sets which cover a given set or collection, in order to conveniently state assertions about covering (see #$covering). For example, the fact that the collection #$CreationOrDestructionEvent is covered by the collections #$CreationEvent and #$DestructionEvent can be expressed as (#$covering #$CreationOrDestructionEvent (#$TheCovering #$CreationEvent #$DestructionEvent).
> guid: c0c4ce5a-9c29-11b1-9dad-c379636f7270
> direct instance of: #$CommutativeRelation #$SetDenotingFunction #$ReifiableFunction #$VariableArityRelation #$Individual

#$covering covering (taxonomic slot)

> A #$TaxonomicSlot that relates a #$SetOrCollection (q.v.) to a #$SetOrCollectionType (q.v.) that covers it, i.e. the union of all of the latter's elements (which are themselves sets or collections) includes all of the former's elements. (#$covering SETORCOL COVER) means that COVER is a covering of SETORCOL: the elements of COVER are themselves mathematical sets or collections, and every element of SETORCOL is an element of at least one of the elements of COVER. For example, the Linnaean taxonomy of types of living things (Dog, Mammal, Chordate, Fungus, etc.) is a covering of the set of all animals alive today, as every animal alive today is a member of one or more of the Linnaean categories. Note that COVER may contain extra elements that are not members of SETORCOL. For example, the union of all the Linnaean categories (see #$OrganismClassificationType) is actually much larger than the set of animals alive today, encompassing as it does plants, extinct animal species, etc. In order to express an assertion about covering, one need not create a new constant from scratch to play the role of COVER if such a constant doesn't already exist. Instead, using the function #$TheCovering (q.v.), one can specify a covering by enumerating its elements. (#$TheCovering is a special #$ReifiableFunction whose principal reason-for-being is to facilitate the inference heuristics associated with assertions about covering.)
> guid: bd58d560-9c29-11b1-9dad-c379636f7270
> direct instance of: #$OpenCycDefinitionalPredicate #$TaxonomicSlot

#$ThePartition the partition **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> This is a special variable-arity #$ReifiableFunction that allows one to specify a set of collections or mathematical sets which partition a given set or collection, in order to conveniently state assertions about partitioning (see #$partitionedInto). For example, the fact that the collection #$Whale is partitioned into the collections #$BaleenWhale and #$ToothedWhale can be expressed as (#$partitionedInto #$Whale (#$ThePartition #$BaleenWhale #$ToothedWhale).
> guid: bdc51e07-9c29-11b1-9dad-c379636f7270
> direct instance of: #$PartialDenotationalFunction #$CommutativeRelation #$ReifiableFunction #$VariableArityRelation #$SetDenotingFunction #$Individual

#$partitionedInto partitioned into

> (#$partitionedInto SETORCOL PART) means that the mathematical set or collection PART is a partition of the mathematical set or collection SETORCOL; that is, the elements of PART are themselves mathematical sets or collections, and every element of SETORCOL is an element of exactly one element of PART, and every element of PART is a subset of SETORCOL. In other words, PART is a set or collection of pairwise disjoint sets or collections whose union is co-extensional with SETORCOL. Typically, the #$DisjointSetOrCollection that plays the role of PART in an assertion about partitioning will be a set specified by enumerating its elements, using the function #$ThePartition.
> guid: bd58f530-9c29-11b1-9dad-c379636f7270
> direct instance of: #$OpenCycDefinitionalPredicate #$AsymmetricBinaryPredicate #$TaxonomicSlot #$PossibleDefinitionalPredicate
> direct specialization of: #$covering

### Relations

#$Relation relationships (mathematical concepts)

> 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
> direct specialization of: #$MathematicalObject
> direct generalization of: #$MicrotheoryDesignatingRelation #$PartiallyCommutativeRelation #$AssociativeRelation #$ScopingRelation #$EvaluatableRelation #$CommutativeRelation #$FunctionalRelation #$MacroRelation #$FixedArityRelation #$VariableArityRelation #$Function-Denotational #$TruthFunction

#$arity arity (relation predicate)

> 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 #$DefaultMonotonicPredicate #$FunctionalSlot #$IntangibleObjectRelatingPredicate #$MetaRelation #$DefinitionalPredicate

#$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
> direct specialization of: #$Relation
> direct generalization of: #$SocialOrEconomicAttributeFunction #$VariableArityFunction #$VariableAritySkolemFunction

#$CommutativeRelation commutative relation **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> An important specialization of #$Relation. Each instance of #$CommutativeRelation is a relationship whose argument order can be changed without changing the value or meaning of the expression; e.g., #$PlusFn, #$TimesFn, #$or, #$bordersOn, #$temporallyIntersects, #$teammates. Most #$Relations are NOT commutative: if (#$isa EL COL) is true, it is rare that (#$isa COL EL) is also true.
> guid: bd6449a2-9c29-11b1-9dad-c379636f7270
> direct instance of: #$RelationshipType
> direct specialization of: #$Relation
> direct generalization of: #$SymmetricBinaryPredicate

#$FunctionalRelation functional relations

> A specialization of #$Relation each instance of which is either a denotational function (see #$Function-Denotational) or a predicate that is functional in at least one argument-place (see #$FunctionalPredicate and #$functionalInTheNthArg). Examples include #$IntervalMaxFn, #$ElectricalPotentialDifferenceFn, #$revenueFromType, #$costRateForType, and #$biologicalMother.
> guid: bd5880a3-9c29-11b1-9dad-c379636f7270
> direct instance of: #$RelationshipType
> direct specialization of: #$Relation
> direct generalization of: #$Function-Denotational #$FunctionalPredicate

#$FunctionalPredicate functional predicate

> A specialization of #$Predicate whose instances are those predicates that are functional in at least one argument-place (see #$functionalInArgs and #$SingleEntry). 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 argument-format for PRED's functional argument-place is #$IntervalEntry (q.v.) instead of #$SingleEntry. 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 #$overlapsIntervals and #$subScalarIntervals.) 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
> direct specialization of: #$Predicate #$FunctionalRelation
> direct generalization of: #$FunctionalSlot

#$FunctionalSlot functional slots

> 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 and only 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. In other words, #$FunctionalSlot is 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
> direct specialization of: #$FunctionalPredicate #$BinaryPredicate
> direct generalization of: #$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
> direct specialization of: #$Relation-MathematicalObject
> direct generalization of: #$FixedArityFunction

#$EvaluatableRelation evaluatable relation **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> Instances of #$EvaluatableRelation are functions and predicates for which there is some piece of system code that can be invoked to evaluate an expression using the function or predicate. Functions having this property should be an instance of the more specific #$EvaluatableFunction; in those cases, the result of evaluating the expression is a new term. For example, (#$PlusFn (#$Inch 3) (#$Inch 1)), when evaluated, results in the term (#$Inch 4). Predicates which are evaluatable have a piece of system code associated which can be used to obtain the truth value for any ground formula formed with the predicate. For example, (#$greaterThan (#$Inch 3) (#$Inch 1)) evaluates to ``true''. The predicate #$evaluationDefn is used to state the name of the piece of system code to be used to evaluate expressions formed with an #$EvaluatableRelation.
> guid: bfb0e3f0-9c29-11b1-9dad-c379636f7270
> direct instance of: #$RelationshipType
> direct specialization of: #$Relation
> direct generalization of: #$EvaluatablePredicate #$EvaluatableFunction

#$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 #$DefaultMonotonicPredicate #$InferenceRelatedBookkeepingPredicate #$IntangibleObjectRelatingPredicate #$FunctionalSlot

#$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
> direct specialization of: #$Relation
> direct generalization of: #$Predicate #$LogicalConnective #$Quantifier

### Predicates

#$decodingDeviceType decoding device type **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> This predicate is used to specify the type of device needed for decoding information contained in a particular kind of encoding scheme. (#$decodingDeviceType SCHEME DEV-TYP) means that DEV-TYP is the type of device required to decode the information encoded with encoding scheme SCHEME. For example, a telephone is the kind of device needed to decode audio information sent over telephone lines. A cable TV box is the device type needed to decode cable TV signals. And so on. See also #$EncodingSchemeType.
> guid: bd58cef2-9c29-11b1-9dad-c379636f7270
> direct instance of: #$BinaryPredicate

#$deviceControlledBy device controlled by **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> (#$deviceControlledBy DEV CONTROL) means that CONTROL is a #$ControlDevice that controls #$PhysicalDevice DEV. Most of the time, the controls will be #$physicalParts of the device. However there are some notable exceptions -- one's TV remote control, for example -- which control a device but are not #$physicalParts of that device.
> guid: bd5cbb65-9c29-11b1-9dad-c379636f7270
> direct instance of: #$AsymmetricBinaryPredicate

#$instrument-Generic instrument (actor slot)

> The predicate #$instrument-Generic is used to link a particular event to any of the objects which play an instrumental role in it. (#$instrument-Generic EVENT OBJECT) means that OBJECT plays an intermediate causal role in EVENT, facilitating the occurrence of EVENT, and serving some purpose of some #$Agent. This can happen in at least two ways: either the `doer' of EVENT acts on OBJECT, which in turn acts on something else (as when someone uses a hammer to pound in a nail) or the `doer' of EVENT acts on something, making it possible for OBJECT to act on that thing (as when someone puts wet clothes out in the sun to dry). Typically, an #$instrument-Generic is not significantly altered by playing that role in an event. #$deviceUsed is an important specialization of #$instrument-Generic.
> guid: bd5d4eb3-9c29-11b1-9dad-c379636f7270
> direct instance of: #$IndividualLevelPredicate #$ActorSlot
> direct specialization of: #$actors #$instrumentalRole

#$deviceUsed device used (actor slot)

> The predicate #$deviceUsed relates an event to a device used in that event. (#$deviceUsed EVENT OBJECT) means that the #$PhysicalDevice OBJECT plays an instrumental role in the #$Event EVENT (see the more generalized predicate #$instrument-Generic), OBJECT is intentionally used in EVENT, and standardly (for example, in the #$HumanActivitiesMt) OBJECT's role in EVENT is consistent with the object's #$primaryFunction.
> guid: bd5d0531-9c29-11b1-9dad-c379636f7270
> direct instance of: #$ActorSlot
> direct specialization of: #$instrument-Generic

#$hasInterfaceDevices has interface devices **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> This predicate identifies a particular interface device that is linked to a particular computer. (#$hasInterfaceDevices COMPUTER INTERFACE) means that INTERFACE is a #$ComputerInterfaceDevice for the #$Computer COMPUTER. E.g., this predicate holds between my desktop PC and the mouse that's connected to it, the monitor that's connected to it, the keyboard that's connected to it, etc.
> guid: bd58bb61-9c29-11b1-9dad-c379636f7270
> direct instance of: #$AntiSymmetricBinaryPredicate #$PhysicalPartPredicate

#$energySource energy source (binary role predicate) **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> This predicate is used to identify a particular source of energy used in a particular event. (#$energySource EVENT ENERGYSOURCE) means that ENERGYSOURCE provides (some of) the energy used in EVENT. ENERGYSOURCE might be a battery, the sun, a person, etc.
> guid: bd58ea4e-9c29-11b1-9dad-c379636f7270
> direct instance of: #$IndividualLevelPredicate #$BinaryRolePredicate #$AsymmetricBinaryPredicate
> direct specialization of: #$temporallyIntersects

#$objectControlled controlled object **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> This predicate is used to indicate that a particular object is being controlled in a particular event. (#$objectControlled EVENT OBJ) means that the object OBJ is being controlled in the #$Event EVENT. Note: #$objectControlled does not assume or require physical contact between controller and object controlled.
> guid: bd58bdb0-9c29-11b1-9dad-c379636f7270
> direct instance of: #$ActorSlot
> direct specialization of: #$objectActedOn

#$objectActedOn affected object (actor slot)

> The predicate #$objectActedOn is used to relate an event to an entity or entities significantly affected in that event. The entity or entities in question must exist before the event, but may be either destroyed in the event (see the more specific predicate #$inputsDestroyed), or merely affected by it (for example, see the more specific predicates #$damages and #$objectOfStateChange). (#$objectActedOn EVENT OBJECT) means that OBJECT is altered or affected in EVENT, and the change that OBJECT undergoes is central or focal to understanding EVENT. Thus, scissors are _not_ an #$objectActedOn in a #$HairCuttingEvent. The focal change in a haircut is hair getting shorter; thus, hair is a legitimate #$objectActedOn in a #$HairCuttingEvent. The almost microscopic dulling that scissors undergo in a single haircut is a comparatively insignificant change with respect to a single haircut, considered as a #$HairCuttingEvent.
> guid: bd58bae6-9c29-11b1-9dad-c379636f7270
> direct instance of: #$IndividualLevelPredicate #$ActorSlot
> direct specialization of: #$preActors

#$vehicle vehicle (actor slot) **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> (#$vehicle EVENT VEHICLE) means that VEHICLE is a #$TransportationDevice-Vehicle which is both the #$providerOfMotiveForce and the #$transporter in EVENT. If an object is a #$TransportationDevice-Vehicle and plays the role of #$transporter in some moving event, then it generally will play the role of #$vehicle in that event. Examples: a car plays the role of #$vehicle in driving. Note, however, that a bicycle does not play the role of #$vehicle in bike riding since it is not a provider of motive force. A borderline non-example is someone sitting in their car while it's being pulled by a towtruck; their car is not playing the role of #$vehicle in that event.
> guid: bd58a883-9c29-11b1-9dad-c379636f7270
> direct instance of: #$ActorSlot
> direct specialization of: #$deviceUsed #$transporter #$providerOfMotiveForce

#$stuffUsed stuff used **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> The predicate #$stuffUsed relates an event to some tangible substance which facilitates that event. (#$stuffUsed EVENT STUFF) means that STUFF is a portion of an instance of #$ExistingStuffType which plays an instrumental role in EVENT. STUFF may or may not be consumed in the course of EVENT. Examples: portions of #$Water are #$stuffUsed in instances of #$WashingDishes, #$WashingHair, #$WashingClothesInAMachine, etc.; portions of #$EdibleOil are #$stuffUsed in some instances of #$Frying food and #$BakingBread.
> guid: bd58cadc-9c29-11b1-9dad-c379636f7270
> direct instance of: #$ActorSlot
> direct specialization of: #$instrument-Generic

#$transporter transporter (actor slot) **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> (#$transporter MOVE OBJ) means that OBJ enables or facilitates the conveyance of the #$transportees in the #$TransportationEvent MOVE. OBJ is an #$objectMoving in MOVE that moves along with the #$transportees. OBJ will generally hold, support, contain, pull, or push the #$transportees throughout the MOVE #$Event. OBJ may or may not be the #$providerOfMotiveForce in the event MOVE. If OBJ stays with each #$primaryObjectMoving from the #$fromLocation to the #$toLocation, moving along the same trajectory, then it is also a #$primaryObjectMoving. If OBJ facilitates the motion of the #$primaryObjectMoving but does not itself engage in translational motion it is merely the conveyor of the action, and the role #$conveyor-Stationary should be asserted. If it is unclear whether the conveyor is stationary or not, the role #$conveyor-Generic is used. Specializations of the role #$transporter should be used when possible: although automobiles are #$transporters in many events, they should normally have the more specific role designation of #$vehicle because they are also #$SelfPoweredDevices. When a car is being towed by a towtruck, the car is just a #$transporter of any of its contents while the towtruck is the #$vehicle of that event. An additional role designation for some #$transporters -- those which are #$PhysicalDevices -- is #$deviceUsed; e.g., the use of crutches in hobbling or ice skates in skating. See the #$comment on #$TransportationEvent. Note that an organism may be a #$transportees in a #$Bicycle riding or #$Skating event as well as being the #$providerOfMotiveForce in such cases.
> guid: bd58c1d8-9c29-11b1-9dad-c379636f7270
> direct instance of: #$ActorSlot
> direct specialization of: #$conveyor-Generic #$objectMoving

#$transportees transportee (actor slot) **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> The predicate #$transportees relates a translational motion event to the object(s) transported by a separate object, i.e. a distinctly separate other participant in the event. (#$transportees MOVE OBJ) means that some #$conveyor-Generic facilitates the conveyance of OBJ in MOVE. For example, in a dumptruck driving event, the dirt in the back of the truck is a #$transportees. Any humans in the truck cab (or truck bed) during the trip are also #$transportees; however, a more precise role designation for humans riding in the truck would be either #$passengers or (for the driver) #$driverActor. Borderline positive example #$transportees include the clothes worn by a person walking, or a horseshoe worn by a horse walking. A negative exemplar of a #$transportees is the ear of the person walking. This is because #$transporters do not transport their parts when they move. In other words, #$transporters only transport separate objects. #$translatesFromTo on the other hand, does apply to parts of #$transportees. Note also that parts of #$transportees are not necessarily #$transportees themselves. See also the comments on #$TransportationEvent and #$transporter.
> guid: bd58ae94-9c29-11b1-9dad-c379636f7270
> direct instance of: #$ActorSlot
> direct specialization of: #$primaryObjectMoving #$objectActedOn

#$driverActor driver (actor slot) **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> (#$driverActor DRIVE DRIVER) means that DRIVER controls (see #$ControllingATransporter) the #$transporter in DRIVE. DRIVER steers the wheel, grasps the tiller, controls the throttle, the reins, the brakes, etc., of the #$transporter, e.g., a boat, train, windsurfer, mule, plane, horse and carriage, spaceship, sled, etc. DRIVER is not a #$passengers in DRIVE. Because #$transporter and #$transportees are disjoint and #$driverActor has #$transportees as a #$genlPreds, DRIVER is distinct from the value on #$transporter. Thus a person walking while carrying a watermelon would not be a #$driverActor in their own walking. DRIVER is usually in #$SittingPosture during DRIVE. For any given instant of DRIVE there is exactly one DRIVER. Until we have more extensive vocabulary, #$transportees is the most specific we can be about events in which multiple drivers share driving responsibility throughout the event or if there is a pilot/co-pilot combination.
> guid: bd58bf45-9c29-11b1-9dad-c379636f7270
> direct instance of: #$AgentiveRole
> direct specialization of: #$crewMember #$performedBy #$transportees

### Functions

#$Function-Denotational fn **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> #$Function-Denotational is the collection of functions the CycL expressions for which can be used to form non-atomic terms (NATs). Specifically, when such a function-denoting expression is appropriately combined with other expressions (i.e. the former is in the 0th argument position and the latter are of the correct number and type) the resulting expression is a new CycL term -- a NAT -- that may then freely appear as a component in other CycL expressions. The NAT will itself denote the value (if any) of the function denoted by the former expression for the sequence of arguments denoted, respectively, by the latter expressions. For example, #$GovernmentFn is a unary denotational function, and so the CycL constant '#$GovernmentFn' requires one (syntactic) argument (such as the constant '#$France') to form a NAT (in this case, the expression '(#$GovernmentFn #$France)'). This NAT, which denotes the government of France, can in turn serve as a (syntactic) argument in any CycL expression in which (a term for) an instance of #$RegionalGovernment can occur. Alternatively, we could have created a specific new term `GovernmentOfFrance', asserted that its denotation is an instance of #$RegionalGovernment, and so on. But two related advantages to having NATs in CycL are that they (i) allow for a drastic reduction in the total number of constant terms needed in the CycL vocabulary and (ii) provide a convenient and systematic way to form appropriate new terms as needed out of existing vocabulary (which terms can then inherit from various existing rules and other assertions involving the terms' component expressions). Important subcollections of #$Function-Denotational include #$IndividualDenotingFunction (whose instances always return instances of #$Individual), #$CollectionDenotingFunction, #$SetDenotingFunction, and #$FunctionDenotingFunction (which is itself a subcollection of the first). NATs formed using terms that denote instances of #$FunctionDenotingFunction often denote instances of #$Function-Denotational themselves. Thus, like most other things, denotational functions can be denoted in CycL either by constants (e.g. '#$GovernmentFn') or -- although this is less common -- by NATs (e.g. '(#$FunctionToArg 2 #$biologicalMother)'). Note that the collection #$Function-Denotational does _not_ include all functions whatsoever. Functions that, given their natures and the nature of the CycL language, could not sensibly be denoted by any NAT-forming CycL expression are not denotational functions. Examples include certain provably-existing exotic mathematical functions, such as (probably) any one-to-one function from the positive integers to the rational numbers. (For a more general collection that does include such functions, and for a more general explication of the notion of function itself, see #$Function-MathematicalObject and its comment). Note also that #$Function-Denotational does not include any of the so-called #$TruthFunctions (q.v.): #$Predicates, #$Quantifiers, or #$LogicalConnectives. For these relations (as construed in CycL) are not really functions at all, even though it can be heuristically useful to think of them as if they were functions from sequences of arguments to truth values.
> guid: bd5c40b0-9c29-11b1-9dad-c379636f7270
> direct instance of: #$FunctionCategory
> direct specialization of: #$FunctionalRelation
> direct generalization of: #$UnreifiableFunction #$IndividualDenotingFunction #$ReifiableFunction #$MicrotheoryDesignatingFunction-Denotational #$VariableArityFunction #$FixedArityFunction #$TotalDenotationalFunction #$PartialDenotationalFunction #$QuintaryFunction #$QuaternaryFunction #$TernaryFunction #$BinaryFunction #$CollectionDenotingFunction #$EvaluatableFunction #$UnaryFunction #$SetDenotingFunction

#$resultIsa result isa

> A #$MetaRelation that holds between relations and collections. #$resultIsa is primarily used to indicate that any value returned by a given function is an instance of a given collection. Where FUNC is a #$Function-Denotational, (#$resultIsa FUNC COL) means that FUNC returns an instance of COL for any sequence of arguments for which FUNC is defined. That is, (#$isa (FUNC ARG1 ... ARGn) COL) holds for any sequence for which FUNC has a value (see #$valueOfFunctionForArgs and #$relationDomain). For example, `(#$resultIsa #$PlusFn #$ScalarInterval)' holds, and it entails (e.g.) `(#$isa (#$PlusFn 2 2) #$ScalarInterval)'. #$resultIsa can also be used with a #$LogicalConnective or #$Quantifier to make a syntactic claim about the type of expression (see #$CycLExpressionType) that can be built from connective-denoting or quantifier-denoting expressions. Where CONN is a #$LogicalConnective, (#$resultIsa CONN EXPR-TYPE) means that any semantically well-formed expression constructed by combining a term that denotes CONN with the correct number and type of other terms will itself be an instance of EXPR-TYPE. For example, the sentence `(#$resultIsa #$and #$ELSentence-Assertible)' entails that an expression consisting of `#$and' followed by one or more #$ELSentence-Assertibles (the required argument-types for #$and), with the whole expression-sequence enclosed in parentheses, is itself an #$ELSentence-Assertible. (An analogous account can be given for the case where #$resultIsa is applied to a #$Quantifier.) See also #$resultGenl.
> guid: bd5880f1-9c29-11b1-9dad-c379636f7270
> direct instance of: #$OpenCycDefinitionalPredicate #$RuleMacroPredicate #$MetaRelation #$DefaultMonotonicPredicate #$BinaryPredicate

#$IndividualDenotingFunction individual-denoting functions

> The subcollection of #$Function-Denotational whose instances, when applied to any appropriate (sequence of) arguments, return instances of #$Individual. Examples include #$PerimeterFn, #$GovernmentFn, and #$CavityInteriorRegionFn. See also the collections #$CollectionDenotingFunction and #$SetDenotingFunction.
> guid: bd58fad9-9c29-11b1-9dad-c379636f7270
> direct instance of: #$FunctionCategory
> direct specialization of: #$Function-Denotational
> direct generalization of: #$AttributeDenotingFunction #$DateDenotingFunction #$MetricUnitPrefix #$ShapeFunction #$UnitOfMeasure #$PredicateDenotingFunction #$FunctionDenotingFunction #$SocialOrEconomicAttributeFunction #$AnimalPartRegionFunction #$DerivedWordFormingFunction

#$CollectionDenotingFunction collection-denoting functions **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> The subcollection of #$Function-Denotational whose instances, when applied to any appropriate (sequences of) arguments, return instances of #$Collection. Examples include #$SwimmingEventFn, #$GroupFn, and #$MoleculeFn; (#$MoleculeFn #$Oxygen) denotes the collection of all oxygen molecules. Cf. #$IndividualDenotingFunction and #$SetDenotingFunction.
> guid: bd58806a-9c29-11b1-9dad-c379636f7270
> direct instance of: #$FunctionCategory
> direct specialization of: #$Function-Denotational
> direct generalization of: #$SubcollectionDenotingFunction

#$resultGenl result genl

> A #$MetaRelation that is used to specify that a given collection is a supercollection of any value returned by a given #$CollectionDenotingFunction. (#$resultGenl COLFUNC COL) means that when COLFUNC is applied to any sequence of arguments for which it is defined, the resulting value will be a subcollection of COL. That is, (#$genls (COLFUNC ARG1 ... ARGn) COL) holds. For example, (#$resultGenl #$UsingAFn #$Action) implies that the collection of acts done using any given type of object is a type of action, (#$resultGenl #$AttemptingFn #$PurposefulAction) implies that the attempts at a given type of action constitute a type of purposeful act, and (#$resultGenl #$JointTypeBetweenFn #$Joint-Physical) means that the collection of joints between two given types of things is a type of physical joint. See also #$resultIsa.
> guid: bd58d6ab-9c29-11b1-9dad-c379636f7270
> direct instance of: #$OpenCycDefinitionalPredicate #$RuleMacroPredicate #$MetaRelation #$DefaultMonotonicPredicate #$BinaryPredicate

#$FunctionToArg function to arg **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> #$FunctionToArg and #$Kappa are special functions that generate relationships - #$FunctionToArg generates a function from a predicate. (#$FunctionToArg N PRED) denotes the function generated from the #$FunctionalPredicate PRED, where the N-th argument is taken as the result. Therefore the arity of (#$FunctionToArg N PRED) is one less than the arity of PRED. For example, the term (#$FunctionToArg 2 #$age) denotes the function that returns the age of a person; in other words, because (#$age PERSON AGE) the term ((#$FunctionToArg 2 #$age) PERSON) denotes AGE. To work properly the predicate PRED must be functional in the N-th argument. In some cases, however, determining whether (#$functionalInTheNthArg PRED N) may be very difficult - in particular for uses of #$Kappa. For this reason this functionality constraint is not fully supported by code.
> guid: c0edda9d-9c29-11b1-9dad-c379636f7270
> direct instance of: #$FunctionDenotingFunction #$BinaryRelation #$Individual

#$Kappa kappa **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> This is a function that is used to define a #$Predicate on the fly. In fact, kappa is to relations what lambda is to functions. (#$Kappa (?ARG1 ... ?ARGN) ?FORMULA) where ?ARG1 ... ?ARGN appear as free-variables in ?FORMULA, defines a predicate with arity N that is satisfied for those bindings that satisfy ?FORMULA. #$Kappa is useful to reduce the arity of a predicate by fixing the value for one of its arguments. For example, (#$Kappa (?COUNTRY ?RATE) (#$exportRate ?COUNTRY #$Oil ?RATE)) defines a binary predicate that relates a country to its export rate of oil. For example, (#$Kappa (?PERSON ?NAME) (#$thereExists ?FATHER (#$and (#$father ?PERSON ?FATHER) (#$lastName ?FATHER ?NAME))) returns the predicate that relates a person and his father's last name. Note that #$Kappa in combination with #$FunctionToArg can be used to define lambda-expressions. For example, (#$FunctionToArg 2 (#$Kappa (?PERSON ?NAME) (#$and (#$father ?PERSON ?FATHER) (#$lastName ?FATHER ?NAME)))) is the function that returns my father's last name. Care is advised when doing this, because #$FunctionToArg assumes predicates that are functional in the relevant argument, whereas #$Kappa can return any predicate.
> guid: c0937fa3-9c29-11b1-9dad-c379636f7270
> direct instance of: #$ScopingRelation #$PredicateDenotingFunction #$BinaryFunction #$Individual

### Mathematical Functions

#$DifferenceFn subtraction **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> #$DifferenceFn is Cyc's subtraction operator; it is a binary mathematical function. (#$DifferenceFn MINUEND SUBTRAHEND) yields a new quantity that is the result of subtracting SUBTRAHEND from MINUEND. Both arguments to #$DifferenceFn must be elements of #$ScalarInterval, as is its result. Examples: (#$DifferenceFn 88 11) returns 77; (#$DifferenceFn (#$Kilogram 4.2) (#$Kilogram 3)) returns (#$Kilogram 1.2).
> guid: bd5880a6-9c29-11b1-9dad-c379636f7270
> direct instance of: #$FunctionFromQuantitiesToQuantities #$BinaryFunction #$Individual

#$PlusFn plus fn **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> #$PlusFn is Cyc's addition operator; it is a variable-arity mathematical function. #$PlusFn takes a variable number of quantities as arguments, and it yields a new quantity which is the result of adding those arguments together. All of the arguments to #$PlusFn must be elements of #$ScalarInterval, as is its result. Examples: (#$PlusFn 2 3 4) returns 9; (#$PlusFn (#$Meter 1.5) (#$Meter 0.7)) returns (#$Meter 2.2). See also #$VariableArityRelation.
> guid: bd5880ae-9c29-11b1-9dad-c379636f7270
> direct instance of: #$AssociativeRelation #$FunctionFromQuantitiesToQuantities #$VariableArityRelation #$CommutativeRelation #$Individual

#$PlusInfinity plus infinity **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> #$PlusInfinity represents an infinitely large positive number (roughly akin to aleph-null).
> guid: bd5884b2-9c29-11b1-9dad-c379636f7270
> direct instance of: #$Cardinal-Mathematical #$Individual

### Reifiable Functions

#$ReifiableFunction reifiable functions **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> The collection of all Cyc functions whose values can be reified and treated like Cyc constants. Using reifiable functions allow us to add to the KB efficiently; e.g., (#$GovernmentFn #$France) can be treated more or less the same as if we had created a new constant term called `GovernmentOfFrance', and #$GovernmentFn can be applied to any instance of #$GeopoliticalEntity to produce such a reified term representing the region's government. On the other hand, it is not desirable to reify every non-atomic term; for example, all the measurable quantities, such as (#$Inch 5), and the numbers which result from using instances of #$FunctionFromQuantitiesToQuantities (e.g., #$PlusFn), should all be instances of #$UnreifiableFunction instead. Thus, #$IndividualDenotingFunction does not and should NOT have #$ReifiableFunction as a #$genls, because #$IndividualDenotingFunction includes the instances of #$UnitOfMeasure and other functions whose uses we don't want to reify. See also #$Function-Denotational, #$CycLReifiableDenotationalTerm, #$UnreifiableFunction.
> guid: bd588002-9c29-11b1-9dad-c379636f7270
> direct instance of: #$FunctionCategory
> direct specialization of: #$Function-Denotational
> direct generalization of: #$SkolemFunction #$SubcollectionFunction #$UnaryIntersectionFunction #$MetricUnitPrefix #$SymmetryMemberFunction #$AnimalPartRegionFunction #$DerivedWordFormingFunction

#$CycLReifiableDenotationalTerm CycL reifiable denotational terms **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> A subcollection of both #$CycLClosedDenotationalTerm and #$CycLIndexedTerm (qq.v.). #$CycLReifiableDenotationalTerm is the collection of all CycL terms that both may be reified and may denote something in the universe of discourse. It thus includes all instances of #$CycLConstant as well as any NAT (see #$CycLNonAtomicTerm and #$Function-Denotational) whose functor denotes an instance of #$ReifiableFunction. For example, the NAT `(#$GovernmentFn #$France)' is a #$CycLReifiableDenotationalTerm, since #$GovernmentFn is an instance of #$ReifiableFunction. Similarly, `(#$JuvenileFn #$Platypus)' is a #$CycLReifiableDenotationalTerm; although it is not currently reified in the KB, it is reifiable and denotational (see #$CycLClosedDenotationalTerm). Finally, `(#$BorderBetweenFn #$Canada #$Mexico)' is a #$CycLReifiableDenotationalTerm; although it happens not to denote anything in the universe of discourse, it is nonetheless the kind of NAT that can and often does denote. Note that #$CycLVariables are not considered reifiable terms.
> guid: bd63a0ce-9c29-11b1-9dad-c379636f7270
> direct instance of: #$CycLExpressionType
> direct specialization of:
> direct generalization of: #$CycLReifiedDenotationalTerm #$ELReifiableDenotationalTerm #$HLReifiedDenotationalTerm #$CycLConstant #$CycLReifiableNonAtomicTerm

#$termOfUnit term of unit **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> #$termOfUnit is an inference-related Cyc predicate which appears in system-generated assertions; #$termOfUnit represents a mapping between a non-atomic term (NAT) and a Cyc constant that was reified by the system especially for that NAT. Assertions with #$termOfUnit are created by the system when a certain kind of non-atomic term (NAT) first appears in a Cyc formula; such a NAT consists of a Cyc function that is an instance of #$ReifiableFunction, together with the correct number and type of arguments. When such a NAT is first used in a formula, the Cyc system automatically creates a Cyc-constant data-structure to reify the NAT. A name is automatically assigned to the new constant (i.e., the data-structure) by the Cyc system; currently (1997), the system is using for most of those constant names a string which is identical to the NAT. One should not be misled by that into thinking that #$termOfUnit is a specialization of #$equals. The predicate #$termOfUnit maps between the system-generated data-structure and the original non-atomic term. (#$termOfUnit NAT-CONSTANT NAT-EXPRESSION) tells us that the constant data-structure NAT-CONSTANT was created to reify the value of the non-atomic term NAT-EXPRESSION. From now on, NAT-EXPRESSION will refer to the constant NAT-CONSTANT. Examples of non-atomic terms (NATs) include: (#$Giga #$DollarsPerYear) and (#$RepairingFn #$Automobile). See also #$Function-Denotational, #$CycLReifiableDenotationalTerm. Note: #$termOfUnit assertions are entered in the #$BaseKB because the mapping between a NAT and the constant that was reified for it holds universally. One should view #$termOfUnit assertions as bits of bookkeeping knowledge which are very rarely, if ever, entered into the KB by hand.
> guid: bd5880e4-9c29-11b1-9dad-c379636f7270
> direct instance of: #$ReformulatorIrrelevantFORT #$DefaultMonotonicPredicate #$BinaryPredicate #$InferenceRelatedBookkeepingPredicate

#$SkolemFunction skolem function **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> #$SkolemFunction is a collection of Cyc system-generated functions that implement existential quantifications in Cyc. Whenever someone asserts to Cyc an expression that contains a `#$thereExists', Cyc automatically creates a new instance of #$SkolemFunction and rewrites the assertion using that Skolem function, as described in what follows. (Most Cyc users don't need to know the following details, which are supplied only for the curious.) Suppose we tell Cyc that every animal has a birth date; i.e., for each animal, there exists a date such that the animal was born on that date --- in CycL, (#$implies (#$isa ?X #$Animal)(#$thereExists ?Y (#$birthDate ?X ?Y))). In response to that CycL formula, Cyc would create a new element of #$SkolemFunction -- we might call it the `BirthDateFn' -- whose single argument would be an animal and whose resultant value would be a date, namely, that animal's date of birth. Subsequently, Cyc would automatically use the `BirthDateFn' in asserting our rule, eliminating the need for a `#$thereExists'. Our formula would thus be rewritten by the system, as follows: (#$implies (#$and (#$isa ?X #$Animal) (#$termOfUnit ?Y (`BirthDateFn' ?X))) (#$birthDate ?X ?Y)). See also #$termOfUnit. Note: Although our example uses the name 'BirthDateFn' for our Skolem function, at this time (4/97), Skolem functions are automatically named by the Cyc system using the prefix `SKF-' followed by a number.
> guid: c05813b7-9c29-11b1-9dad-c379636f7270
> direct instance of: #$RelationshipType
> direct specialization of: #$ReifiableFunction
> direct generalization of: #$SkolemFuncN #$VariableAritySkolemFunction #$FixedAritySkolemFunction

### Argument Type

Argument-type predicates are used to constrain the arguments of all relations, including predicates and functions. For each argument position that a relation takes, it must have an ``arg-isa'' for that position, even if it also has an ``arg-genls'' for the same position.

#$arg1Isa arg 1 isa

> A binary #$ArgIsaPredicate (q.v.). (#$arg1Isa RELN COL) means that semantic well-formedness requires that anything given as the first argument to RELN must be an instance of COL. That is, (RELN ARG1 ...) is semantically well-formed only if (#$isa ARG1 COL) holds. For an explanation of semantic well-formedness, see #$CycLExpression-Assertible and its specializations. See #$argIsa for a similar but more flexible ternary predicate.
> guid: bd588118-9c29-11b1-9dad-c379636f7270
> direct instance of: #$OpenCycDefinitionalPredicate #$ArgIsaBinaryPredicate #$DefaultMonotonicPredicate

#$arg2Isa arg 2 isa

> A binary #$ArgIsaPredicate (q.v.). (#$arg2Isa RELN COL) means that semantic well-formedness requires that anything given as the second argument to RELN must be an instance of COL. That is, (RELN ARG1 ARG2 ...) is semantically well-formed only if (#$isa ARG2 COL) holds. For an explanation of semantic well-formedness, see #$CycLExpression-Assertible and its specializations. See #$argIsa for a similar but more flexible ternary predicate.
> guid: bd588117-9c29-11b1-9dad-c379636f7270
> direct instance of: #$OpenCycDefinitionalPredicate #$DefaultMonotonicPredicate #$ArgIsaBinaryPredicate

#$arg3Isa arg 3 isa

> A binary #$ArgIsaPredicate (q.v.). (#$arg3Isa RELN COL) means that semantic well-formedness requires that anything given as the third argument to RELN must be an instance of COL. That is, (RELN ARG1 ARG2 ARG3 ...) is semantically well-formed only if (#$isa ARG3 COL) holds. For an explanation of semantic well-formedness, see #$CycLExpression-Assertible and its specializations. See #$argIsa for a similar but more flexible ternary predicate.
> guid: bd588116-9c29-11b1-9dad-c379636f7270
> direct instance of: #$OpenCycDefinitionalPredicate #$DefaultMonotonicPredicate #$ArgIsaBinaryPredicate

#$arg4Isa arg 4 isa

> A binary #$ArgIsaPredicate (q.v.). (#$arg4Isa RELN COL) means that semantic well-formedness requires that anything given as the fourth argument to RELN must be an instance of COL. That is, (RELN ARG1 ARG2 ARG3 ARG4 ...) is semantically well-formed only if (#$isa ARG4 COL) holds. For an explanation of semantic well-formedness, see #$CycLExpression-Assertible and its specializations. See #$argIsa for a similar but more flexible ternary predicate.
> guid: bd588115-9c29-11b1-9dad-c379636f7270
> direct instance of: #$OpenCycDefinitionalPredicate #$DefaultMonotonicPredicate #$ArgIsaBinaryPredicate

#$arg5Isa arg 5 isa

> A binary #$ArgIsaPredicate (q.v.). (#$arg5Isa RELN COL) means that semantic well-formedness requires that anything given as the fifth argument to RELN must be an instance of COL. That is, (RELN ARG1 ARG2 ARG3 ARG4 ARG5 ...) is semantically well-formed only if (#$isa ARG5 COL) holds. For an explanation of semantic well-formedness, see #$CycLExpression-Assertible and its specializations. See #$argIsa for a similar but more flexible ternary predicate.
> guid: bd588114-9c29-11b1-9dad-c379636f7270
> direct instance of: #$OpenCycDefinitionalPredicate #$DefaultMonotonicPredicate #$ArgIsaBinaryPredicate

#$argsIsa args isa

> A binary #$ArgIsaPredicate (q.v.) that is used to put a specified #$isa based argument-type constraint on all of a given relation's argument-places at once. (#$argsIsa RELN COL) means that semantic well-formedness requires that each argument to which RELN is applied (regardless of argument-place) be an instance of COL. For example, `(#$argsIsa #$PlusFn #$ScalarInterval)' means that the function #$PlusFn must only be applied to scalar intervals. #$argsIsa is particularly useful for constraining (any and all of) the arguments to a #$VariableArityRelation (the preceding example being a case in point); though #$argsIsa may be applied to fixed-arity relations as well. For an explanation of semantic well-formedness, see #$CycLExpression-Assertible and its immediate specializations. See also #$argsGenl.
> guid: bd58803d-9c29-11b1-9dad-c379636f7270
> direct instance of: #$OpenCycDefinitionalPredicate #$DefaultMonotonicPredicate #$ArgIsaBinaryPredicate

### Argument Genl

The ``arg-genls'' predicates are another way (besides ``arg-isa'') to constrain the arguments of relations. Use of these predicates is optional and frankly not even very common. Of course, one can state more complicated sorts of constraints than ``arg-isa'' and ``arg-genls'' by asserting a longer Cyc formula, but these two types of short-cuts handle the most common cases.

#$arg1Genl arg 1 genl

> A binary #$ArgGenlPredicate (q.v.). (#$arg1Genl RELN COL) means that semantic well-formedness requires that anything given as the first argument to RELN must be a subcollection of COL. That is, (RELN ARG1 ...) is semantically well-formed only if (#$genls ARG1 COL) holds. For an explanation of semantic well-formedness, see #$CycLExpression-Assertible and its specializations. See #$argGenl for a similar but more flexible ternary predicate.
> guid: bd588b1d-9c29-11b1-9dad-c379636f7270
> direct instance of: #$OpenCycDefinitionalPredicate #$DefaultMonotonicPredicate #$ArgGenlBinaryPredicate

#$arg2Genl arg 2 genl

> A binary #$ArgGenlPredicate (q.v.). (#$arg2Genl RELN COL) means that semantic well-formedness requires that anything given as the second argument to RELN must be a subcollection of COL. That is, (RELN ARG1 ARG2 ...) is semantically well-formed only if (#$genls ARG2 COL) holds. For an explanation of semantic well-formedness, see #$CycLExpression-Assertible and its specializations. See #$argGenl for a similar but more flexible ternary predicate.
> guid: bd58dcda-9c29-11b1-9dad-c379636f7270
> direct instance of: #$OpenCycDefinitionalPredicate #$DefaultMonotonicPredicate #$ArgGenlBinaryPredicate

#$arg3Genl arg 3 genl

> A binary #$ArgGenlPredicate (q.v.). (#$arg3Genl RELN COL) means that semantic well-formedness requires that anything given as the third argument to RELN must be a subcollection of COL. That is, (RELN ARG1 ARG2 ARG3 ...) is semantically well-formed only if (#$genls ARG3 COL) holds. For an explanation of semantic well-formedness, see #$CycLExpression-Assertible and its specializations. See #$argGenl for a similar but more flexible ternary predicate.
> guid: bd58b8c3-9c29-11b1-9dad-c379636f7270
> direct instance of: #$OpenCycDefinitionalPredicate #$DefaultMonotonicPredicate #$ArgGenlBinaryPredicate

#$arg4Genl arg 4 genl

> A binary #$ArgGenlPredicate (q.v.). (#$arg4Genl RELN COL) means that semantic well-formedness requires that anything given as the fourth argument to RELN must be a subcollection of COL. That is, (RELN ARG1 ARG2 ARG3 ARG4 ...) is semantically well-formed only if (#$genls ARG4 COL) holds. For an explanation of semantic well-formedness, see #$CycLExpression-Assertible and its specializations. See #$argGenl for a similar but more flexible ternary predicate.
> guid: bd67e911-9c29-11b1-9dad-c379636f7270
> direct instance of: #$ArgGenlBinaryPredicate #$OpenCycDefinitionalPredicate #$DefaultMonotonicPredicate

#$arg5Genl arg 5 genl

> A binary #$ArgGenlPredicate (q.v.). (#$arg5Genl RELN COL) means that semantic well-formedness requires that anything given as the fifth argument to RELN must be a subcollection of COL. That is, (RELN ARG1 ARG2 ARG3 ARG4 ARG5 ...) is semantically well-formed only if (#$genls ARG5 COL) holds. For an explanation of semantic well-formedness, see #$CycLExpression-Assertible and its specializations. See #$argGenl for a similar but more flexible ternary predicate.
> guid: bd5d7783-9c29-11b1-9dad-c379636f7270
> direct instance of: #$ArgGenlBinaryPredicate #$OpenCycDefinitionalPredicate #$DefaultMonotonicPredicate

#$argsGenl args genl

> A binary #$ArgGenlPredicate (q.v.) that is used to put a specified #$genls based argument-type constraint on all of a given relation's argument-places at once. (#$argsGenl RELN COL) means that semantic well-formedness requires that each argument to which RELN is applied (regardless of argument-place) be an subcollection of COL. For example, `(#$argsGenl #$PerformSimultaneouslyFn #$Event)' means that the function #$PerformSimultaneouslyFn must only be applied to types of events. #$argsGenl is particularly useful for constraining (any and all of) the arguments to a #$VariableArityRelation (the preceding example being a case in point); though #$argsGenl may be applied to fixed-arity relations as well. For an explanation of semantic well-formedness, see #$CycLExpression-Assertible and its immediate specializations. See also #$argsIsa.
> guid: bd651c1b-9c29-11b1-9dad-c379636f7270
> direct instance of: #$ArgGenlBinaryPredicate #$OpenCycDefinitionalPredicate #$DefaultMonotonicPredicate

### Entry Format

#$arg1Format arg 1 format

> An instance of #$ArgFormatPredicate (q.v.) used to place a particular #$Format (q.v.) constraint on the first (or arg1 ) argument-place of a given predicate. (#$arg1Format PRED FORMAT) means that PRED's arg1 is constrained to FORMAT. See the reified instances #$Format for further details.
> guid: bd61886b-9c29-11b1-9dad-c379636f7270
> direct instance of: #$ArgFormatBinaryPredicate #$OpenCycDefinitionalPredicate

#$arg2Format arg 2 format

> An instance of #$ArgFormatPredicate (q.v.) used to place a particular #$Format (q.v.) constraint on the second (or arg2 ) argument-place of a given predicate. (#$arg2Format PRED FORMAT) means that PRED's arg2 is constrained to FORMAT. See the reified instances #$Format for further details.
> guid: bd5a142d-9c29-11b1-9dad-c379636f7270
> direct instance of: #$ArgFormatBinaryPredicate #$OpenCycDefinitionalPredicate

#$arg3Format arg 3 format

> An instance of #$ArgFormatPredicate (q.v.) used to place a particular #$Format (q.v.) constraint on the third (or arg3 ) argument-place of a given predicate. (#$arg3Format PRED FORMAT) means that PRED's arg3 is constrained to FORMAT. See the reified instances #$Format for further details.
> guid: bd5b6d60-9c29-11b1-9dad-c379636f7270
> direct instance of: #$ArgFormatBinaryPredicate #$OpenCycDefinitionalPredicate

#$arg4Format arg 4 format

> An instance of #$ArgFormatPredicate (q.v.) used to place a particular #$Format (q.v.) constraint on the fourth (or arg4 ) argument-place of a given predicate. (#$arg4Format PRED FORMAT) means that PRED's arg4 is constrained to FORMAT. See the reified instances #$Format for further details.
> guid: bd678812-9c29-11b1-9dad-c379636f7270
> direct instance of: #$ArgFormatBinaryPredicate #$OpenCycDefinitionalPredicate

#$arg5Format arg 5 format

> An instance of #$ArgFormatPredicate (q.v.) used to place a particular #$Format (q.v.) constraint on the fifth (or arg5 ) argument-place of a given predicate. (#$arg5Format PRED FORMAT) means that PRED's arg5 is constrained to FORMAT. See the reified instances #$Format for further details.
> guid: bd60a887-9c29-11b1-9dad-c379636f7270
> direct instance of: #$ArgFormatBinaryPredicate #$OpenCycDefinitionalPredicate

#$Format format **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> Elements of the collection #$Format are attributes that are used to constrain the multi-valued nature of a #$Predicate. Consider a predicate PRED which takes five arguments, and fix any four of those arguments -- say arguments 1, 2, 4, and 5. The number of different legal values there can be for the third argument (given that we've already chosen the other four) is determined by which #$Format attribute has been specified for the 3rd argument place of PRED.. (1) If the #$arg3Format for PRED is #$SingleEntry, then there can be at most one single term that's legal (and thus at most one assertion), for those given values of arguments 1, 2, 4, and 5. To illustrate, let's consider a predicate with a lower #$arity, say (#$mother CHILD MOM), which says that the mother of CHILD is MOM. The #$arg2Format for #$mother should be #$SingleEntry, since an animal can have only one biological mother. (2) If the #$arg3Format of PRED is #$SetTheFormat, then there may be any number of assertions with different terms in the third argument position, but sharing the same values for arguments 1, 2, 4, and 5. E.g., the #$arg1Format for #$mother should be #$SetTheFormat, since a female can have multiple children. (3) If the #$arg3Format of PRED is #$IntervalEntry, then there may be multiple assertions sharing the values of 1, 2, 4, and 5, but with different terms in the 3rd argument; however, all the values for the 3rd argument must be overlapping elements of #$ScalarInterval (q.v.). E.g., the height of a person might be specified in several ways, with slightly different margins of error (or approximation), which is fine, but all those alternate values had better have SOME overlap since the person really just has one particular true height at any given time.
> guid: bd589a1d-9c29-11b1-9dad-c379636f7270
> direct instance of: #$Collection
> direct specialization of: #$IntangibleIndividual

#$SingleEntry single entry **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> Argument places of Cyc predicates may have specified formats that constrain their values. #$SingleEntry is a format constraint used to indicate that there is at most one value in a certain argument place, when all other arguments are fixed. For example, the #$arg2Format of #$biologicalMother is #$SingleEntry, since an animal can only have one biological mother. See also #$Format, and contrast with #$SetTheFormat.
> guid: bd5880eb-9c29-11b1-9dad-c379636f7270
> direct instance of: #$Format #$Individual

#$SetTheFormat Set The Format **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> Any argument place of a Cyc predicate may have a specified format that constrains its possible value(s). If an argument position has #$SetTheFormat as its entry format, then --- given some fixed set of values for the other arguments to that predicate --- any number of assertions can still be true in the KB with different terms in that argument position. E.g., the #$arg1Format for #$mother is #$SetTheFormat, since a woman can have any number of children. See also #$Format, and contrast with #$SingleEntry.
> guid: bd589408-9c29-11b1-9dad-c379636f7270
> direct instance of: #$Format #$Individual

#$PartsFormat Parts Format **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> Argument positions of Cyc predicates may have specified formats that constrain how many and what kind of terms may occupy that position, given some fixed list of terms in the other argument positions of the predicate. If a predicate P has #$PartsFormat for argument position N, then given some particular list of terms that occupy the other argument positions of P, there may be multiple assertions with different terms in position N (keeping the other arguments fixed), but only so long as the terms in position N are all #$physicalParts of the same #$PartiallyTangible. For example, the #$arg1Format of #$physicalParts is #$PartsFormat. This allows us to represent that JosephsRightThumbnail is a #$physicalParts of JosephsRightThumb, of JosephsRightHand, and of Joseph. This is more restrictive than #$SetTheFormat, which allows multiple unrelated values. In contrast, specifying only (#$arg1Format #$physicalParts #$SetTheFormat) would not prevent JosephsRightThumb from being a #$physicalParts of both JosephsRightHand and of JamesRightHand.
> guid: c0fb3343-9c29-11b1-9dad-c379636f7270
> direct instance of: #$Format #$Individual

#$IntervalEntry interval entry **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> Arguments to Cyc predicates may have specified formats that constrain their values. #$IntervalEntry is the format used to constrain argument positions that must be filled with measurable quantities. If #$IntervalEntry is the entry format of some Nth argument to a predicate PRED, then all assertions with PRED that contain the same particular values in their other arguments must have, in the Nth (i.e., #$IntervalEntry) argument, quantitative values that `overlap'. (See #$ScalarInterval and #$overlapsIntervals.) #$IntervalEntry is provided because, for functional arguments like the second argument to #$volumeOfObject, we know that a single `real' value does exist, though we may have various ways of concluding limits on that value in the form of intervals. As long as all the intervals overlap, those assertions are not contradictory. For more explanation, see #$Format and the related predicates #$arg1Format, #$arg2Format, etc.
> guid: bd5880e0-9c29-11b1-9dad-c379636f7270
> direct instance of: #$Format #$Individual

#$functionalInArgs functional in args

> A #$MetaPredicate for specifying the argument-place(s) with respect to which a given #$FunctionalPredicate (q.v) is functional . (#$functionalInArgs PRED N) means that PRED is functional in its Nth argument-place. That is, for any particular way of fixing all of PRED's other arguments, there will be at most one thing that, if taken as the Nth argument, would result in a true sentence. For example, #$biologicalMother is functional in its second argument, as nothing has more than one biological mother. In most cases, the entry-format (see #$Format) of a functional argument-place should be #$SingleEntry (q.v.). In some cases, however, the entry-format is #$IntervalEntry (q.v.), and then the meaning of (#$functionalInArgs PRED N) deviates slightly from that described above. In such a case there might be more than one instance of #$ScalarInterval (q.v.) that, when taken as PRED's Nth argument (and keeping the other arguments fixed), yields a true statement; but if so, all such (equivalently truth-yielding ) scalar-intervals must _overlap_ one another (see #$overlapsIntervals). For example, #$heightOfObject's second, functional argument-place has the interval-entry format, reflecting the fact that it might be true to say of a given basketball player (e.g.) _either_ that he is 6-feet-11-inches in height or that he is between 6-feet-10 and 7-feet in height. Obviously, the specified integer N must be less than or equal to the arity (see #$arity) of PRED. Note that, for some ways of fixing the other arguments, there might be _nothing_ that would yield a true sentence when put in PRED's functional argument-place. For example, #$dictator is functional in its second argument because a given country can have at most one dictator at a given time; but of course some countries have no dictator.
> guid: bd58dcb9-9c29-11b1-9dad-c379636f7270
> direct instance of: #$OpenCycDefinitionalPredicate #$MetaPredicate #$BinaryPredicate

#$scopingArg scoping arg **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> (#$scopingArg RELATION N) indicates the Nth argument of #$ScopingRelation RELATION denotes one or more scoped variables.
> guid: c03d1910-9c29-11b1-9dad-c379636f7270
> direct instance of: #$BinaryPredicate

#$ScopingRelation scoping relation **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> Relations that are used to define a scope with respect to one or more variables and to bind any occurrences of those variables that are inside that scope.
> guid: c0960de2-9c29-11b1-9dad-c379636f7270
> direct instance of: #$RelationshipType
> direct specialization of: #$Relation
> direct generalization of: #$Quantifier

### Logical Connectives

#$implies implies **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> The predicate #$implies represents the material implication relation in Cyc. #$implies is a logical connective taking two arguments, each of which must be an instance of #$ELSentence-Assertible. (#$implies ANTE CONSEQ) means that either the formula ANTE is false, or the formula CONSEQ is true (possibly both); equivalently, it is not the case that ANTE is true and CONSEQ is false. Cyc assertions that begin with #$implies are used during inference, both in modus ponens and modus tollens.
> guid: bd5880f8-9c29-11b1-9dad-c379636f7270
> direct instance of: #$MacroRelation #$BinaryRelation #$LogicalConnective #$Individual

#$not not **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> The logical connective #$not is the negation operator in Cyc. #$not takes a single instance of #$ELSentence-Assertible as its argument. (#$not FORM) is true if and only if the formula FORM is false in Cyc.
> guid: bd5880fb-9c29-11b1-9dad-c379636f7270
> direct instance of: #$UnaryRelation #$LogicalConnective #$Individual

#$and and **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> The predicate #$and is the conjunction relation in Cyc. #$and is a variable-arity predicate and takes any number of elements of #$ELSentence-Assertible as its arguments. (#$and P Q ... Z) is true if all of the formulas P, Q, ..., and Z are true in Cyc.
> guid: bd5880f9-9c29-11b1-9dad-c379636f7270
> direct instance of: #$AssociativeRelation #$VariableArityRelation #$CommutativeRelation #$LogicalConnective #$Individual

#$or or **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> The predicate #$or is the disjunction relation in Cyc. #$or is a variable-arity relation and takes any number of elements of #$ELSentence-Assertible as its arguments. (#$or P Q ... Z) is true if at least one of the formulas P, Q, ..., or Z is true in Cyc.
> guid: bd5880fa-9c29-11b1-9dad-c379636f7270
> direct instance of: #$AssociativeRelation #$VariableArityRelation #$CommutativeRelation #$LogicalConnective #$Individual

#$forAll for all **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> The predicate #$forAll is Cyc's version of the universal quantifier of predicate calculus (i.e., the operator symbolized in one common notation by an upside-down `A'). As its two arguments, #$forAll takes a variable (which is an instance of #$ELVariable) and an instance of #$ELSentence-Assertible, respectively. (#$forAll VAR FORM) means that FORM is true whenever all the occurrences of the variable VAR in the formula FORM are replaced by any object in the Cyc universe. For example, to say that every person is a mammal, we could assert: (#$forAll ?X (#$implies (#$isa ?X #$Person) (#$isa ?X #$Mammal). In addition, CycL follows a convention that allows #$forAll to be omitted; that is, when no explicit quantifier is used, seemingly unbound variables inside formulas are assumed to be universally quantified. With that convention, the sample assertion could be written more compactly as: (#$implies (#$isa ?X #$Person) (#$isa ?X #$Mammal). [Developer-level footnote: There are many `flavors' of quantification `on the market' these days; here is how the Cyc system currently handles axioms that involve #$forAll: When processing an FI-ASK about whether an assertion of the form (#$forAll VAR FORM) is true or not, Cyc determines extensionally whether or not any known VAR (anything in the knowledge base) could make FORM false. When processing an FI-PROVE about whether an assertion of the form (#$forAll VAR FORM) is true or not, Cyc tries to construct an intensional proof (at least at a default-true level) that FORM must be true regardless of what VAR is ever inserted therein. When processing an FI-ASSERT in which a user or program tells Cyc that an assertion of the form (#$forAll VAR FORM) is true, Cyc records it intensionally so that it can later serve as part of an intensional proof, when some future FI-PROVE request is processed.]
> guid: bd5880f7-9c29-11b1-9dad-c379636f7270
> direct instance of: #$BinaryRelation #$Quantifier #$Individual

#$thereExists there exists **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> The predicate #$thereExists is Cyc's version of the existential quantifier of predicate calculus (i.e., the operator symbolized in one common notation by a backwards 'E'). As its two arguments, #$thereExists takes a variable (which is an instance of #$ELVariable) and an instance of #$ELSentence-Assertible, respectively. (#$thereExists VAR FORM) means that FORM is true in at least one case (and possibly more) in which all occurrences of the variable VAR in FORM are replaced by an object in the Cyc universe. For example, to say that every person has a mother, we could assert: (#$forAll ?X (#$implies (#$isa ?X #$Person) (#$thereExists ?Y (#$mother ?X ?Y)))). [Developer-level footnote: There are many `flavors' of quantification `on the market' these days; here is how the Cyc system currently handles axioms that involve #$thereExists: When processing an FI-ASK about whether (#$thereExists VAR FORM) is true or not, Cyc determines extensionally whether or not any known VAR (anything in the knowledge base) satisfies FORM (makes it true.) When processing an FI-PROVE about whether (#$thereExists VAR FORM) is true or not, Cyc tries to construct an intensional proof (at least at a default-true level) that there must exist some value of VAR --- which may or may not already be known in the KB -- for which FORM must be true. When processing an FI-ASSERT in which a user or program tells Cyc that (#$thereExists VAR FORM) is true, Cyc records the assertion intensionally so that it can later serve as part of an intensional proof, when some future FI-PROVE request is processed. It does this by creating a new #$SkolemFunction (q.v.). When modus ponens is used with a rule of the form (#$implies ANTECEDENT (#$thereExists VAR FORM)), and the formula ANTECEDENT is true, then Cyc will generate a new term for VAR, add that to its language, and assert that the new term satisfies FORM.]
> guid: bd5880f6-9c29-11b1-9dad-c379636f7270
> direct instance of: #$BinaryRelation #$ExistentialQuantifier #$Individual

#$thereExistAtLeast there exist at least **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> The predicate #$thereExistAtLeast is a specialized form of #$thereExists (q.v.). (#$thereExistAtLeast 5 X FORM) means that there are at least five distinct objects in the Cyc universe which, when substituted for the #$ELVariable X in the #$ELSentence-Assertible FORM, make FORM true. See #$thereExists for more information about existential quantification.
> guid: c10af5e7-9c29-11b1-9dad-c379636f7270
> direct instance of: #$ExistentialQuantifier #$TernaryRelation #$Individual

#$thereExistAtMost there exist at most **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> The predicate #$thereExistAtMost is a specialized form of #$thereExists (q.v.). (#$thereExistAtMost 5 X FORM) means that there are no more than five distinct objects in the (relevant) universe of discourse which, when substituted for the #$ELVariable X in the #$ELSentence-Assertible FORM, make FORM true. See #$thereExists for more information about existential quantification.
> guid: c10af932-9c29-11b1-9dad-c379636f7270
> direct instance of: #$ExistentialQuantifier #$TernaryRelation #$Individual

#$thereExistExactly there exist exactly **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> The predicate #$thereExistExactly is a specialized form of #$thereExists (q.v.). (#$thereExistExactly 5 X FORM) means that there are no more and no less than five distinct objects in the (relevant) universe of discourse which, when substituted for the #$ELVariable X in the #$ELSentence-Assertible FORM, make FORM true. See #$thereExists for more information about existential quantification.
> guid: c10ae7b8-9c29-11b1-9dad-c379636f7270
> direct instance of: #$ExistentialQuantifier #$TernaryRelation #$Individual

#$True true (mathematical concept) **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> An instance of #$TruthValue. #$True is logical truth in Cyc; this is the abstract logical notion--not to be confused with Lisp's T, nor with the English word `true'.
> guid: bd5880d9-9c29-11b1-9dad-c379636f7270
> direct instance of: #$TruthValue #$Individual

#$False false (mathematical concept) **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> An instance of #$TruthValue. #$False is logical falsehood in Cyc; this is the abstract logical notion--not to be confused with Lisp's NIL, nor with the English word `false'.
> guid: bd5880d8-9c29-11b1-9dad-c379636f7270
> direct instance of: #$TruthValue #$Individual

#$equals equals **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> The predicate #$equals is the CycL version of the identity relation. (#$equals THING1 THING2) means that THING1 and THING2 are numerically identical, i.e. they are one and the same thing. A formula of this form is true if and only if the terms occupying #$equals's two argument-places denote the same thing.
> guid: bd5880c9-9c29-11b1-9dad-c379636f7270
> direct instance of: #$EquivalenceRelation #$DefaultMonotonicPredicate

#$evaluate evaluate (binary predicate) **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> If the arg1 of #$evaluate is a variable, (#$evaluate VAR EXPRESSION) is satisfied by an HL module which evaluates EXPRESSION and binds VAR to the result. For example, (#$evaluate ?SUM (#$PlusFn 1 2)) would bind ?SUM to 3. If the arg1 is a fully-bound expression, then the HL module checks to see if the arg2 evaluates to the arg1. For example, asking (#$evaluate 3 (#$PlusFn 1 2)) returns #$True.
> guid: c03afa6d-9c29-11b1-9dad-c379636f7270
> direct instance of: #$BinaryPredicate

#$different having a distinct identity from **GAFs NOT REVIEWED**

> A variable-arity predicate (see #$VariableArityRelation) that is used to state the non-identity of two or more things. (#$different THING1..THINGn) means that for any THINGi and THINGj (where 0 <= i <= n, 0 <= j <= n, and i =/ j), THINGi is not identical with THINGj. That is, each of THING1, ..., THINGn is distinct from all of the others. Cf. #$equals.
> guid: bd63f343-9c29-11b1-9dad-c379636f7270
> direct instance of: #$EvaluatablePredicate #$VariableArityRelation #$CommutativeRelation #$ComparisonPredicate
> direct specialization of: #$differentSymbols

### Expressions

#$CycLExpression CycL expressions

> The collection of all syntactically well-formed expressions in the CycL language. This includes constants, variables, non-atomic terms, formulas, sentences, etc. Since the CycL syntax allows any CycL expression to be used as a term, #$CycLExpression is actually coextensional with #$CycLTerm (q.v.). Note that #$CycLExpression, like most #$CycLExpressionTypes, is a #$quotedCollection (q.v.).
> guid: be90c21d-9c29-11b1-9dad-c379636f7270
> direct instance of: #$CycLExpressionType
> direct specialization of:
> direct generalization of: #$CycLExpression-Askable #$CycLDenotationalTerm #$HLExpression #$ELExpression #$CycLSentence #$CycLFormula #$CycLClosedExpression #$CycLOpenExpression #$CycLAtomicTerm #$CycLTerm

#$ELSentence-Assertible assertible EL sentences **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> The collection of syntactically and semantically well-formed #$ELSentences. Each instance of #$ELSentence-Assertible meets the necessary criteria for being asserted into the Cyc Knowledge Base (at which time it is transformed into one or more #$HLAssertions by the #$CycCanonicalizer). Of course, a sentence's being assertible does not entail that it is actually asserted, but only that it could be asserted. An assertible EL sentence consists of an EL expression denoting a logical relation (i.e. a #$Predicate or #$TruthFunction) followed by an appropriate number of EL terms (in accordance with the #$arity of the logical relation), with the entire sequence enclosed in parentheses. Example: (#$and (#$isa #$Pittman #$HumanCyclist) (#$residesInRegion #$Pittman #$CityOfAustinTX). For a thorough discussion of what constitutes a well-formed CycL formula, see the Cyc documentation.
> guid: bd58809e-9c29-11b1-9dad-c379636f7270
> direct instance of: #$CycLExpressionType #$LinguisticObjectType
> direct specialization of: #$LinguisticObject
> direct generalization of: #$ELAssertion

#$ELVariable EL variables

> The collection of all #$CycLVariables that are also #$ELExpressions (q.v.). An #$ELVariable is a character string consisting of a question mark `?' (as its initial character) followed by one or more characters, where each of these latter characters is either an (upper- or lower-case) Roman letter, an Arabic numeral (i.e. `0' through `9'), a hyphen (`-'), an underscore (`_'), or another question mark. (The letters occurring in an EL variable used in an actual assertion will typically be all uppercase; but this convention is not enforced in any formal way.) Examples: `?WHAT', `?OBJ-TYPE', and `?var0'. Note that this collection, like most instances of #$CycLExpressionType, is quoted (see #$quotedCollection).
> guid: bd61ff36-9c29-11b1-9dad-c379636f7270
> direct instance of: #$CycLExpressionType
> direct specialization of:

### Default Reasoning

#$overrides is used when the assertions involved are general rules (axioms with quantifiers) and where those assertions will produce contradictory results in some situations. #$overrides makes it possible to resolve the contradictions by giving one of the assertions priority over the other.

To take a trite example:

P1 = "If something is a penguin, it can't fly."
P2 = "If something is a bird, it can fly."
P1 overrides P2.

#$exceptFor and #$exceptWhen are ``user interface'' predicates for stating rules about defaults. Statements using them are transformed into statements using #$abnormal by the system.
#$overrides overrides **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> The predicate #$overrides is used to tell Cyc which rule to prefer when it encounters two conflicting rules while reasoning with default assertions. (#$overrides FIRST SECOND) means that if the assertions FIRST and SECOND both appear in conflicting arguments for and against some proposition, favor the argument that contains FIRST.
> guid: bd58a273-9c29-11b1-9dad-c379636f7270
> direct instance of: #$MetaKnowledgePredicate #$AsymmetricBinaryPredicate #$TransitiveBinaryPredicate

#$exceptFor except for **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> (#$exceptFor TERM ASSERTION) means that TERM is a thing, about which ASSERTION is known not to hold. #$exceptFor is a special case of #$exceptWhen (q.v.), applicable when ASSERTION has only one universally quantified variable. (#$exceptFor TERM ASSERTION) prevents TERM from binding to that variable, thereby blocking the conclusions about TERM that Cyc might otherwise draw from ASSERTION. In other words, if ASSERTION is an implication, then whatever proposition(s) -- call that Q -- that Cyc might have concluded about TERM from ASSERTION may or may not be true in Cyc, but (due to the exception) they would no longer be justified, even partially, by ASSERTION. Also, assertions made at the EL level with #$exceptFor are canonicalized into statements that do not reference #$exceptFor, but instead reference the predicate #$abnormal (see #$EmptinessOfAbnormalityNote). Note that the exception TERM should be a particular binding for the rule, not a collection, all of whose members the rule does not apply to.
> guid: bd65cd99-9c29-11b1-9dad-c379636f7270
> direct instance of: #$ExceptionRelation #$BinaryRelation

#$exceptWhen except when **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> As of Sept 2001 there is no support for exceptWhen clauses on forward rules. See system problem 768: http://localhost/cycdoc/mail-archive/problem-archive.20010821/msg03825.html
> guid: bd595e7e-9c29-11b1-9dad-c379636f7270
> direct instance of: #$ExceptionRelation #$BinaryRelation

#$abnormal abnormal (default monotonic predicate) **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> Every default rule in our system P(x1,...,xn) => Q(x1,...,xn) is implicitly treated as (not(abnormal(x1,...,xn)) and P(x1,...,xn) => Q(x1,...,xn) This allows rules without exceptions to never have to incur the overhead of default reasoning. Exceptions to rules are written like so: (#$exceptWhen R(x1,...,xn) Rule001) and get canonicalized into rules concluding abnormal like so: R(x1,...,xn) => (#$abnormal(x1,....,xn) Rule001) Since a different 'abnormality' predicte is needed for every default rule in the system, we instead handle this uniqueness requirement by having a single #$abnormal predicate which takes the rule in question as an argument. Also, the variables over which abnormality is computed is given as a single list. This allows #$abnormal to be binary rather than arbitrary arity.
> guid: bd5880bd-9c29-11b1-9dad-c379636f7270
> direct instance of: #$DefaultMonotonicPredicate #$BinaryPredicate

#$NoteAboutStatingExceptionsInCycL note about stating exceptions in cyc l **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> The formula (#$exceptWhen P(?x0 ... ?xn) Q(?x0 ... ?xn))) states that, in situations where assertion Q would apply to a set of bindings for variables ?x0 ... ?xn, the conclusion is allowed `except when' P(?x0 ... ?xn) is true for these variable bindings. The formula (#$exceptFor [term] Q(?x0)) states that, in situations where assertion Q would apply to a variable ?x0, the conclusion is allowed `except for' the situations where [term] is the binding for ?x0. To be well-formed, Q must be a rule with exactly one free variable. By definition, #$exceptFor is merely syntactic sugar: (#$exceptFor [term] Q(?x0)) <=> (#$exceptWhen (equals ?x0 [term]) Q(?x0)) Since an #$exceptWhen statement is a meta-statement about some rule Q(?x0 ... ?xn), the statement is not well-formed if Q(?x0 ... ?xn) is not already an assertion in the KB. Also, strictly speaking, P and Q in the #$exceptWhen merely must share some variables rather than all variables as it's been written above. These constructs replace `abnormal' at the EL (epistemological level). Old assertions of the form: (#$implies P(?x0 ... ?xn) (abnormal R(?x0 ... ?xn) Q(?x0 ... ?xn))) become: (#$exceptWhen P(?x0 ... ?xn) Q(?x0 ... ?xn)) The predicate `abnormal' has not actually gone away, but was modified for use as the HL (Heuristic Level) implementation of #$exceptWhen. Like #$termOfUnit, `abnormal' should be viewed as an inference-maintained predicate, and human beings should not be manually asserting things using `abnormal.' ;;; ;; EXAMPLES ;;; Rule1: `birds fly' (#$implies (#$isa ?BIRD #$Bird) (#$behaviorCapable ?BIRD #$Flying-FlappingWings #$performedBy) Exception1: `for penguins, the ``birds fly'' rule does not apply' (#$exceptWhen (#$isa ?BIRD #$Penguin) [Rule1]) Exception2: `the ``birds fly'' rule does not apply to Tweety' (#$exceptFor Tweety [Rule1]) Exception3: `for an animal with an injured wing, the ``birds fly'' rule does not apply' (#$exceptWhen (#and (#$anatomicalParts ?BIRD ?WING) (#$isa ?WING #$Wing-AnimalBodyPart) (#$hasPhysiologicalAttributes ?WING #$Injured) [Rule1]) Rule2: ``dogs who like the same cat like each other'' (#$implies (?and (#$isa ?DOG1 #$Dog) (#$isa ?DOG2 #$Dog) (#$isa ?CAT #$Cat) (#$likesAsFriend ?DOG1 ?CAT) (#$likesAsFriend ?DOG2 ?CAT)) (#$likesAsFriend ?DOG1 ?DOG2)) Exception3: `Rex does not like other dogs according to ``Rule2''' (#$exceptWhen (#$equals ?DOG1 Rex) [Rule2]) Exception4: `Fifi is not liked by other dogs according to `Rule2''' (#$exceptWhen (#$equals ?DOG2 Fifi) [Rule2]) Exception5: `Morris is not such a cat according to ``Rule2''' (#$exceptWhen (#$equals ?CAT Morris) [Rule2])
> guid: be660580-9c29-11b1-9dad-c379636f7270
> direct instance of: #$Individual

#$MetaAssertionsForPolyCanonicalizingAssertions meta assertions for poly canonicalizing assertions **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> If one wishes to state a fact M about an formula F, i.e. if one wishes to assert the meta-assertion M(F) and if F canonicalizes into multiple assertions, a_1, a_2...a_n, then one may have to do a non-standard procedure. If F canonicalizes into a_1, a_2...a_n *and* when any of a_1, a_2...a_n uncanonicalize back into A then the meta assertion M(F) gets automatically distributed to each of a_1, a_2...a_n. In such a case M(F) ends up in the knowledge base as several assertions, i.e. M(a_1), M(a_2), ... M(a_n). In other cases (i.e. where a polycanonicalizing formula does not uncanonicalize back into itself) (typically rarer), one will have to do the non-standard procedure of distributing the meta-assertions by hand. Example (of the more standard case): (fi-assert '(#$implies (#$isa ?x #$Animal) (#$thereExists ?y (#$and (#$isa ?y #$FemaleAnimal) (#$mother ?x ?y)))) #$BaseKB) produces in the two assertions: #(#$and (#$isa ?X #$Animal) (#$termOfUnit ?Y (SKF-16480338 ?X))) (#$mother ?X ?Y)):#$BaseKB> #(#$and (#$isa ?X #$Animal) (#$termOfUnit ?Y (SKF-16480338 ?X))) (#$isa ?Y #$FemaleAnimal)):#$BaseKB> Note that these two assertions share the common EL formula: (#$implies (#$isa ?x #$Animal) (#$thereExists ?y (#$and (#$isa ?y #$FemaleAnimal) (#$mother ?x ?y)))) Now if we add a meta assertion that references this formula: (fi-assert '(#$salientAssertions #$mother (#$implies (#$isa ?x #$Animal) (#$thereExists ?y (#$and (#$isa ?y #$FemaleAnimal) (#$mother ?x ?y))))) #$BaseKB) the meta formula automatically distributes over the two assertions: #(#$and (#$isa ?X #$Animal) (#$termOfUnit ?Y (SKF-16480338 ?X))) (#$mother ?X ?Y)):#$BaseKB):#$BaseKB> #(#$and (#$isa ?X #$Animal) (#$termOfUnit ?Y (SKF-16480338 ?X))) (#$isa ?Y #$FemaleAnimal)):#$BaseKB):#$BaseKB> This new behavior was added to the system on December 9, 1998. It can be turned-off by setting the parameter CYC::*DISTRIBUTE-META-OVER-COMMON-EL?* to nil.
> guid: bfb7415a-9c29-11b1-9dad-c379636f7270
> direct instance of: #$Individual

### Attributes

#$AttributeValue attribute values **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> The collection of all property-like attributes. These are attributes that can be said to be true of an individual intrinsically, and not in relation to other objects in the universe when considered in the appropriate microtheory. Examples include #$BlueColor, #$BelowFreezingOnEarth, #$AFewHoursDuration #$Haploid, and #$BloodTypeO. Attributes such as #$TallPhysicalBuild and #$AverageStrength are not #$AttributeValues, but instead #$RelativeAttributeValues. All instances ATT of #$AttributeValue must make sense as the second argument for some thing THING in (#$hasAttributes THING ATT). The number 6 and #$GenericQuantities such as #$HighToVeryHigh are not elements of #$AttributeValue.
> guid: bd5880c5-9c29-11b1-9dad-c379636f7270
> direct instance of: #$ObjectType
> direct specialization of: #$Thing
> direct generalization of: #$SocialOrEconomicAttribute #$Flammability #$NLResponseAttribute #$ColorTingeAttribute #$ReformulatorRuleProperty #$GenericAttribute #$AttributePointValue #$HumanBehavioralAttribute #$CycLAssertionDirection #$LocationStateAttribute #$EnvironmentalAttribute

#$AttributeType types of attribute **GAFs NOT REVIEWED**

> A collection of collections. Each element of #$AttributeType is a collection of either attributes or relative attributes. Each element of #$AttributeType is a subset either of #$AttributeValue (q.v.) or #$RelativeAttributeValue. Examples include #$SensoryAttribute #$BodyPartPosition, #$RelationalAttribute, #$Texture, and many more.
> guid: bd590364-9c29-11b1-9dad-c379636f7270
> direct instance of: #$SecondOrderCollection
> direct specialization of: #$ObjectType
> direct generalization of: #$IllocutionaryForceType #$PartialOrderAttributeType #$SiblingDisjointAttributeType #$CompositeScalarIntervalType

#$hasAttributes trait (attribute predicate) **GAFs NOT REVIEWED**

> A very general predicate that relates a thing to an attribute or property (see #$AttributeValue) that it has. (#$hasAttributes THING ATT) means that ATT characterizes THING. There are a large number of more specialized predicates in CycL that represent more specific ways in which an attribute might characterize a thing; such predicates should be used instead of #$hasAttributes when possible. Thus #$mainColorOfObject is preferrable to #$hasAttributes for stating that a physical object has a particular main color. See also #$AttributeType.
> guid: bd58d1f6-9c29-11b1-9dad-c379636f7270
> direct instance of: #$IndividualLevelPredicate #$BinaryAttributePredicate

#$genlAttributes genl attributes

> An instance of #$TaxonomicSlot and a specialization of #$generalizations. #$genlAttributes can be used to relate a more-specific instance of #$AttributeValue to other instances that are correlatively more-general. (#$genlAttributes SPEC-ATT GENL-ATT) means that SPEC-ATT generalizes to GENL-ATT in the sense that anything that possesses the former attribute possesses the latter as well. That is, for any THING, (#$hasAttributes THING SPEC-ATT) implies (#$hasAttributes THING GENL-ATT). For example, (#$genlAttributes #$SilverColor #$Grayish) means that anything that is silver-colored is also grayish.
> guid: bd588072-9c29-11b1-9dad-c379636f7270
> direct instance of: #$OpenCycDefinitionalPredicate #$RuleMacroPredicate #$ReflexiveBinaryPredicate #$TaxonomicSlot #$IntangibleObjectPredicate #$TransitiveBinaryPredicate #$DefinitionalPredicate
> direct specialization of: #$generalizations

#$negationAttribute negation attribute

> This predicate relates attributes that are mutually incompatible. (#$negationAttribute ATT1 ATT2) means nothing has, or could have, both ATT1 and ATT2 as attributes at the same time. This implies more than mere material non-coincidence (e.g. being a 5-star restaurant and being colored hot-pink are _not_ negation-attributes, even if there happen to be no hot-pink 5-star restaurants in existence); but #$negationAttribute does subsume both physical and logical (or conceptual ) incompatibility between attributes. Note that it is presupposed that ATT1 and ATT2 are distinct. (Otherwise, any self-contradictory or impossible-to-have attribute would trivially qualify as a negation-attribute of itself, and #$negationAttribute could not be considered an #$IrreflexiveBinaryPredicate.)
> guid: bd58a5b5-9c29-11b1-9dad-c379636f7270
> direct instance of: #$IrreflexiveBinaryPredicate #$SymmetricBinaryPredicate #$OpenCycDefinitionalPredicate #$PossibleDefinitionalPredicate
> direct specialization of: #$different

#$oppositeAttributes opposite attributes

> This specialization of #$negationAttribute (q.v.) relates incompatible attributes that are direct opposites of each other. (#$oppositeAttributes ATTR1 ATTR2) means that ATTR1 is the directly opposite #$AttributeValue of ATTR2 (and vice versa). The sense of opposite intended here is intuitively familiar, but difficult to define precisely. In some cases, ATTR1 and ATTR2 will constitute the only two instances of a certain #$AttributeType ATTRTYPE, and there is a certain natural class of things ATTRTYPERANGE each member of which has ATTR1 if and only if it fails to have ATTR2; e.g. any device that is operational and in the #$attributeRange of #$DeviceOn and #$DeviceOff will have one of these attributes iff it does not have the other. In other cases, ATTR1 and ATTR2 will be instances of an ATTRTYPE that has other instances as well, but is structured such that ATTR1 and ATTR2 are maximally different from or diametrically opposed to each other with respect to their positions in this structure; e.g with respect to the instances of #$GeographicalDirection-General, #$North-Generally and #$South-Generally are opposites.
> guid: bd58a37b-9c29-11b1-9dad-c379636f7270
> direct instance of: #$FunctionalSlot #$SymmetricBinaryPredicate #$AntiTransitiveBinaryPredicate #$DefinitionalPredicate
> direct specialization of: #$negationAttribute

#$UnorderedAttributeType unordered attribute type **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> A collection of collections, and a specialization of #$AttributeType. Each instance ATT-COL of #$UnorderedAttributeType is a collection of attributes having the following property: for any two instances ATT-1 and ATT-2 of ATT-COL, neither (#$followingValue ATT-1 ATT-2) nor (#$followingValue ATT-2 ATT-1) holds. In other words, any two instances of ATT-COL are incommensurable with each other. Instances of #$UnorderedAttributeType include #$GenderOfLivingThing and #$HumanSkinColor.
> guid: bd58d593-9c29-11b1-9dad-c379636f7270
> direct instance of: #$SecondOrderCollection #$SiblingDisjointCollection
> direct specialization of: #$ObjectType

#$PrimitiveScalarIntervalType primitive attribute types **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> A collection of collections. Each instance of #$PrimitiveScalarIntervalType is a specialization of #$ScalarInterval whose instances are totally ordered by some relation (See #$TotallyOrderedCollection). Moreover, each instance of #$PrimitiveScalarIntervalType is a type of quantity (such as mass) that is not derived from other quantities. Instances of #$PrimitiveScalarIntervalType include #$Time-Quantity, #$Mass, and #$Happiness.
> guid: bd58812a-9c29-11b1-9dad-c379636f7270
> direct instance of: #$SecondOrderCollection
> direct specialization of: #$TotallyOrderedScalarIntervalType
> direct generalization of: #$ScriptPerformanceAttributeType #$FundamentalNumericScalarIntervalType #$FeelingType #$SensoryReactionType

#$GenericAttribute generic attribute **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> guid: bf2df9a8-9c29-11b1-9dad-c379636f7270
> direct instance of: #$ObjectType
> direct specialization of: #$AttributeValue

#$CompositeScalarInterval composite scalar intervals **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> A specialization of #$ScalarInterval. Each instance of #$CompositeScalarInterval is an attribute that is essentially a vector with many dimensions. Instances of #$Color are good examples; colors have intensity, hue, and saturation as independent dimensions.
> guid: bd58d8d8-9c29-11b1-9dad-c379636f7270
> direct instance of: #$Collection
> direct specialization of: #$ScalarInterval

#$CompositeScalarIntervalType composite attribute types **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> A collection of collections. Every instance of #$CompositeScalarIntervalType is a specialization of #$CompositScalarInterval (q.v.).
> guid: bd588238-9c29-11b1-9dad-c379636f7270
> direct instance of: #$SecondOrderCollection
> direct specialization of: #$ObjectType

#$primitiveAttributeTypes primitive attribute types (binary predicate) **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> The predicate #$primitiveAttributeTypes is used to relate a type of complex attribute to its basic components. (#$primitiveAttributeTypes COMP PRIM) means that PRIM is an instance of #$PrimitiveAttributeType that makes up the #$CompositeAttributeType, COMP. PRIM can be thought of as one axis for the composite scale. For example, hue, intensity, and saturation are each a primitive scale for the composite attribute `color'. Another case: #$Speed is a primitive component of the composite attribute #$VelocityVector.
> guid: bd58cb9a-9c29-11b1-9dad-c379636f7270
> direct instance of: #$BinaryPredicate

#$DerivedNumericScalarIntervalType derived numeric attribute type

> A collection of collections. Each instance of #$DerivedNumericScalarIntervalType is a collection of numerically measurable #$ScalarIntervals whose units are complex (that is, in units derived from some more basic units of measure). Instances include #$Volume, #$Area, and #$Acceleration. See also the related collection #$FundamentalNumericScalarIntervalType.
> guid: bd58dae0-9c29-11b1-9dad-c379636f7270
> direct instance of: #$SecondOrderCollection #$SiblingDisjointCollection
> direct specialization of: #$MeasurableScalarIntervalType
> direct generalization of: #$MaterialStrengthType

#$MeasurableScalarIntervalType measurable attribute type **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> A collection of collections. Each instance of #$MeasurableScalarIntervalType is a collection of #$ScalarIntervals which are quantifiable (i.e., they can be assigned a numeric value). Instances of #$MeasurableScalarIntervalType include #$RateOfRotation, #$ConcentrationPerVolume, and #$Time-Quantity.
> guid: bd58d9b3-9c29-11b1-9dad-c379636f7270
> direct instance of: #$SecondOrderCollection
> direct specialization of: #$TotallyOrderedScalarIntervalType
> direct generalization of: #$IntegerTypeByRange #$FundamentalNumericScalarIntervalType

#$SiblingDisjointAttributeType sibling disjoint attribute type **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> A collection of collections. Each instance of #$SiblingDisjointAttributeType is a collection of attributes. If COL is such a collection, then nothing can have two instances of COL as attributes unless those two instances are related in a #$genlAttributes relationship to each other. For example, #$MaritalStatusOfPeople is an instance of #$SiblingDisjointAttributeType; no person can have (at the same time) the #$maritalStatus #$Married and the #$maritalStatus #$Single. However, a person could have both the status #$Single and the status #$Divorced, if #$Single is a #$genlAttributes of #$Divorced. See also #$SiblingDisjointCollection.
> guid: bd590951-9c29-11b1-9dad-c379636f7270
> direct instance of: #$SecondOrderCollection
> direct specialization of: #$ObjectType

### Negation Relations

#$negationPreds negation preds

> A #$MetaPredicate for stating that two predicates are logical contraries of one another. (#$negationPreds PRED1 PRED2) means that if PRED1 holds among a given sequence of things, then PRED2 does _not_ hold among that sequence (and vice versa). In other words, (#$negationPreds PRED1 PRED2) is equivalent to (#$not (#$and (PRED1 . ARGS) (PRED2 . ARGS))). For example, (#$negationPreds #$owns #$rents) holds, as one cannot both own and rent a given thing at the same time. Note that PRED1 and PRED2 are constrained (see e.g. #$interArgIsa) either to both having the same fixed-arity (see #$FixedArityRelation) or to both having variable-arity (see #$VariableArityRelations). See also #$genlPreds and #$negationInverse.
> guid: bd610a5c-9c29-11b1-9dad-c379636f7270
> direct instance of: #$TaxonomicSlotForPredicates #$OpenCycDefinitionalPredicate #$RuleMacroPredicate #$DefaultMonotonicPredicate #$IrreflexiveBinaryPredicate #$SymmetricBinaryPredicate

#$negationInverse negation inverse

> A #$MetaPredicate for stating that each of two binary predicates is a logical contrary of the other's inverse. (#$negationInverse BINPRED1 BINPRED2) means that if BINPRED1 holds between a pair , then BINPRED2 does _not_ hold between the inverse pair (and vice versa). In other words, (#$negationInverse BINPRED1 BINPRED2) is equivalent to (#$not (#$and (BINPRED1 ARG1 ARG2) (BINPRED2 ARG2 ARG1))). Note that any #$AsymmetricBinaryPredicate is related to itself by #$negationInverse. For example, (#$negationInverse #$subordinates #$subordinates) holds, since if one person is a subordinate of another, the latter person cannot at the same time also be a subordinate of the former. See also #$negationPreds and #$genlInverse.
> guid: bd5c44e1-9c29-11b1-9dad-c379636f7270
> direct instance of: #$TaxonomicSlotForPredicates #$OpenCycDefinitionalPredicate #$RuleMacroPredicate #$SymmetricBinaryPredicate

### Connections To The Computational Substrate

#$defnSufficient defn sufficient

> (#$defnSufficient COL TEST) means that TEST is the name of a piece of code in the SubL implementation of Cyc, and TEST acts as a sufficient definition for inclusion in the #$Collection COL. If TEST returns T [True] when applied to a particular item, that item is considered to be an instance of COL. Note that TEST isn't necessarily a necessary test for membership in COL; that is, not all instances of COL must pass the test, unless TEST is also a #$defnNecessary for COL. See the related predicates #$defnNecessary and #$defnIff.
> guid: bd5880ee-9c29-11b1-9dad-c379636f7270
> direct instance of: #$CycInferenceDescriptorPredicate #$BinaryPredicate #$InferenceRelatedBookkeepingPredicate

#$defnIff defn iff **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> (#$defnIff COL TEST) means that TEST is the name of a piece of code in the Cyc system substrate, and TEST acts as a necessary and sufficient test for inclusion in the #$Collection COL. If TEST returns T [True] when applied to a particular item, that item is considered an instance of COL; all instances of COL must fulfill TEST's requirements. Cf. #$defnNecessary, #$defnSufficient.
> guid: bd5880ed-9c29-11b1-9dad-c379636f7270
> direct instance of: #$CycInferenceDescriptorPredicate #$InferenceRelatedBookkeepingPredicate #$FunctionalSlot
> direct specialization of: #$defnSufficient #$defnNecessary

#$defnNecessary defn necessary **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> (#$defnNecessary COL TEST) means that TEST is the name of a piece of code in the Cyc system substrate, and TEST acts as a necessary definition for membership in the Cyc #$Collection COL. Only if TEST returns T [True] when applied to a particular item can that item be considered an instance of COL; all instances of COL must fulfill TEST's requirements, although there may be additional requirements for membership in COL as well. Cf. #$defnIff and #$defnSufficient.
> guid: bd60e145-9c29-11b1-9dad-c379636f7270
> direct instance of: #$CycInferenceDescriptorPredicate #$InferenceRelatedBookkeepingPredicate #$BinaryPredicate

#$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 #$DefaultMonotonicPredicate #$InferenceRelatedBookkeepingPredicate #$IntangibleObjectRelatingPredicate #$FunctionalSlot

#$SubLList sub l list

> A collection of list-denoting expressions that are not represented in CycL (i.e. they are not #$CycLConstants or #$CycLNonAtomicTerms) but are represented in SubL, the underlying implementation language of the Cyc system. Each instance of #$SubLList is a sequence of #$SubLListOrAtoms (q.v.) enclosed in parentheses. SubL lists are those things that pass the #$defnIff LISTP. Note that this collection is quoted (see #$quotedCollection).
> guid: bd589695-9c29-11b1-9dad-c379636f7270
> direct instance of: #$ObjectType
> direct specialization of: #$SubLListOrAtom
> direct generalization of: #$SubLListOfStrings #$CycELVariableList #$TemplateParsingSyntacticConstraint

#$SubLSymbol Cyc system symbols

> The collection of all #$SubLAtoms that are also symbols in the SubL language. That is, each instance of #$SubLSymbol satisfies the #$defnIff SYMBOLP. Note that `symbol' has a very specific, technical meaning in SubL. Save for those that are variables (see #$SubLVariable), #$SubLSymbols are rarely used in CycL assertions, except within those built with certain #$CycInferenceDescriptorPredicates like #$defnIff. Examples of SubL symbols include the symbols `GENLS' and `CYC-SYSTEM-NON-VARIABLE-SYMBOL-P'. Note also that #$SubLSymbol is a quoted-collection (see #$quotedCollection).
> guid: bd58a644-9c29-11b1-9dad-c379636f7270
> direct instance of: #$ObjectType
> direct specialization of:
> direct generalization of: #$SubLNonVariableSymbol #$SubLKeyword #$SubLVariable #$ELVariable

#$SubLRealNumber Cyc system real numbers

> The collection of all number-denoting expressions in the CycL language that are _not_ CycL constants or NATs, but are terms of SubL, the underlying implementation language of the Cyc system. #$SubLRealNumbers are numeric strings of the Arabic decimal system, including the decimal point and scientific notation. Examples include the terms `212' and `3.14159d0'. Non-examples include the expressions `#$One', `(#$Meter 6)', `(#$Unity 3)', `:34', `#$PlusInfinity', and `Avogadro's number'. Note that this collection, like most instances of #$CycLExpressionType, is quoted (see #$quotedCollection).
> guid: bd59086c-9c29-11b1-9dad-c379636f7270
> direct instance of: #$CycLExpressionType
> direct specialization of: #$RationalNumber #$SubLAtomWithValue
> direct generalization of: #$SubLInteger

#$EvaluatableFunction evaluatable functions **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> A collection of Cyc functions. Each instance of #$EvaluatableFunction is a Cyc function which is associated (via #$evaluationDefn) with a piece of Heuristic Level (SubL) code that computes the result of applying the function to legal arguments. See #$PlusFn for a good example. An evaluatable function is evaluated only if none of its arguments is unbound. See also the more general #$EvaluatableRelation.
> guid: bd58829b-9c29-11b1-9dad-c379636f7270
> direct instance of: #$RelationshipType
> direct specialization of: #$EvaluatableRelation #$UnreifiableFunction
> direct generalization of: #$NumericQuantifier #$FunctionFromQuantitiesToQuantities

Copyright© 1996-2002. All rights reserved. See Terms of Usage.