(VectorDirectionFn VECTOR) denotes the direction which is the direction of VECTOR.")
;; isas
(isa VectorDirectionFn UnreifiableFunction)
(isa VectorDirectionFn UnaryFunction)
;; arity
(arity VectorDirectionFn 1)
;; arg isas
(arg1Isa VectorDirectionFn VectorInterval)
;; results isa
(resultIsa VectorDirectionFn Direction)
;; ---- VectorMagnitudeFn
;; --------------------------
(isa VectorMagnitudeFn Function-Denotational)
;; comment
(comment VectorMagnitudeFn "(VectorMagnitudeFn VECTOR) denotes the scalar interval which is the magnitude of VECTOR.")
;; isas
(isa VectorMagnitudeFn UnreifiableFunction)
(isa VectorMagnitudeFn UnaryFunction)
;; arity
(arity VectorMagnitudeFn 1)
;; arg isas
(arg1Isa VectorMagnitudeFn VectorInterval)
;; results isa
(resultIsa VectorMagnitudeFn ScalarInterval)
;; ---- VectorQuantityOfFn
;; --------------------------
(isa VectorQuantityOfFn Function-Denotational)
;; comment
(comment VectorQuantityOfFn "(VectorQuantityOfFn VECTOR-QUANT-TYPE) is a
function-denoting function which returns a temporally qualifiable function when given a specialization of VectorQuantity as an argument. ((VectorQuantityOfFn VECTOR-QUANT-TYPE) THING) is the quantity of VECTOR-QUANT-TYPE that THING has, whether or not that quantity is measured or even measurable. For example, ((VectorQuantityOfFn LinearVelocityVector) RMS-Lusitania-TheShip) denotes a linear velocity: namely, the linear velocity of the Lusitania. Functions denoted by QPQuantityFn are typically used in conjunction with valueOf (q.v.). For example, (valueOf ((VectorQuantityOfFn LinearVelocityVector) RMS-Lusitania-TheShip) (VectorFn North-Generally (MetersPerSecond 0.5))) could have been true at some time.")
;; isas
(isa VectorQuantityOfFn FunctionDenotingFunction)
(isa VectorQuantityOfFn ReifiableFunction)
(isa VectorQuantityOfFn UnaryFunction)
;; arity
(arity VectorQuantityOfFn 1)
;; arg isas
(arg1Isa VectorQuantityOfFn Collection)
;; results isa
(resultIsa VectorQuantityOfFn FixedArityFunction)
(resultArity VectorQuantityOfFn 1)
;;;; File name: preds-defns.meld
;;;; Modified: Saturday, June 17, 2006 at 17:47:03 by forbus
;; ---- accelerationDueToGravityOnPlanetaryBody
;; --------------------------
(isa accelerationDueToGravityOnPlanetaryBody Predicate)
;; comment
(comment accelerationDueToGravityOnPlanetaryBody "(accelerationDueToGravityOnPlanetaryBody BODY RATE) means that near the surace of the planetary body BODY, the force of gravity causes objects to accelerate at RATE towards the center of mass of BODY. For example, (accelerationDueToGravityOnPlanetaryBody PlanetEarth (MetersPerSecondPerSecond 9.80619)) is true.")
;; isas
(isa accelerationDueToGravityOnPlanetaryBody FunctionalSlot)
(isa accelerationDueToGravityOnPlanetaryBody BinaryQuantityPredicate)
(isa accelerationDueToGravityOnPlanetaryBody BinaryPredicate)
;; arity
(arity accelerationDueToGravityOnPlanetaryBody 2)
;; arg isas
(arg1Isa accelerationDueToGravityOnPlanetaryBody PlanetaryBody)
(arg2Isa accelerationDueToGravityOnPlanetaryBody Acceleration)
;; ---- constantThroughoutEvent-Fluent
;; --------------------------
(isa constantThroughoutEvent-Fluent Predicate)
;; comment
(comment constantThroughoutEvent-Fluent "This predicate is used to state that the value of a fluent remains constant for a fixed object throughout an event. (constantThroughoutEvent-Fluent FLUENT EVENT) is true if and only if for every pair of sub-events SUB1 and SUB2 of EVENT there exist values VAL1 and VAL2 such that if
(and (startsAfterEndingOf SUB1 SUB2) (valueOf (MeasurementAtFn FLUENT SUB1) VAL1)) (valueOf (MeasurementAtFn FLUENT SUB2) VAL2))it follows that
(numericallyEquals VAL1 VAL2)is true. See also decreasesThroughoutEvent-Fluent and increasesThroughoutEvent-Fluent.") ;; isas (isa constantThroughoutEvent-Fluent BinaryPredicate) ;; arity (arity constantThroughoutEvent-Fluent 2) ;; arg isas (arg1Isa constantThroughoutEvent-Fluent ScalarOrVectorInterval) (arg2Isa constantThroughoutEvent-Fluent Event) ;; negationPreds (negationPreds constantThroughoutEvent-Fluent increasesThroughoutEvent-Fluent) (negationPreds constantThroughoutEvent-Fluent decreasesThroughoutEvent-Fluent) ;; ---- directionOfPulling ;; -------------------------- (isa directionOfPulling Predicate) ;; comment (comment directionOfPulling "(directionOfPulling PULL DIR) means that in the pulling event PULL, the object pulled is pulled in the direction DIR. ") ;; isas (isa directionOfPulling VectorIntervalSlot) (isa directionOfPulling BinaryPredicate) ;; arity (arity directionOfPulling 2) ;; arg isas (arg1Isa directionOfPulling PullingAnObject) (arg2Isa directionOfPulling UnitVectorInterval) ;; genlPreds (genlPreds directionOfPulling directionOfForceApplication) ;; ---- equationForSolution ;; -------------------------- (isa equationForSolution Predicate) ;; comment (comment equationForSolution "(equationForSolution SOLUTION EQUATION) means that EQUATION is a mathematical equation that is useful for working out the WorkedSolution, SOLUTION.") ;; isas (isa equationForSolution BinaryPredicate) ;; arity (arity equationForSolution 2) ;; arg isas (arg1Isa equationForSolution WorkedSolution) (argQuotedIsa equationForSolution 2 CycLSentence) ;; ---- equationFormFor ;; -------------------------- (isa equationFormFor Predicate) ;; comment (comment equationFormFor "(equationFormFor PRINCIPLE EQUATION) means that EQUATION is the form of a mathematical equation that corresponds to the physical principle, PRINCIPLE. For example, NewtonsSecondLaw, as it is commonly expressed, corresponds to the equation F=ma, where F is the sum of the forces acting on an object, m is its mass and a is its accelerration.") ;; isas (isa equationFormFor StrictlyFunctionalSlot) ;; arity (arity equationFormFor 2) ;; arg isas (arg1Isa equationFormFor PhysicalPrinciple) (argQuotedIsa equationFormFor 2 CycLSentence) ;; ---- except ;; -------------------------- (isa except Predicate) ;; comment (comment except "(except ASSERTION) means that there is an exception to ASSERTION in the current microtheory such that ASSERTION is not known to be true. If ASSERTION is a rule, it will not fire.") ;; isas (isa except UnaryPredicate) ;; arity (arity except 1) ;; arg isas (argQuotedIsa except 1 CycLAssertion) ;; ---- firstSolutionStep ;; -------------------------- (isa firstSolutionStep Predicate) ;; comment (comment firstSolutionStep "A specialization of hasSolutionSteps (q.v.). (firstSolutionStep SOL STEP) means that STEP is the unique first step in the larger solution, SOL.") ;; isas (isa firstSolutionStep StrictlyFunctionalSlot) (isa firstSolutionStep CoexistingObjectsPredicate) (isa firstSolutionStep NonPhysicalPartPredicate) (isa firstSolutionStep IrreflexiveBinaryPredicate) ;; arity (arity firstSolutionStep 2) ;; arg isas (arg1Isa firstSolutionStep WorkedSolution) (arg2Isa firstSolutionStep WorkedSolutionStep) ;; genlPreds (genlPreds firstSolutionStep hasSolutionSteps) ;; ---- forceActsOnObjectThroughout ;; -------------------------- (isa forceActsOnObjectThroughout Predicate) ;; isas (isa forceActsOnObjectThroughout TernaryPredicate) ;; arity (arity forceActsOnObjectThroughout 3) ;; arg isas (arg1Isa forceActsOnObjectThroughout ForceVector) (arg2Isa forceActsOnObjectThroughout PartiallyTangible) (arg3Isa forceActsOnObjectThroughout TemporalThing) ;; ---- hasSolutionSteps ;; -------------------------- (isa hasSolutionSteps Predicate) ;; comment (comment hasSolutionSteps "A specialization of textualPCWSubSections (q.v.). (hasSolutionSteps SOL STEP) means that STEP is a step in the larger solutioon, SOL.") ;; isas (isa hasSolutionSteps CoexistingObjectsPredicate) (isa hasSolutionSteps NonPhysicalPartPredicate) (isa hasSolutionSteps IrreflexiveBinaryPredicate) ;; arity (arity hasSolutionSteps 2) ;; arg isas (arg1Isa hasSolutionSteps WorkedSolution) (arg2Isa hasSolutionSteps WorkedSolutionStep) ;; genlPreds (genlPreds hasSolutionSteps textualPCWSubSections) ;; spec preds (genlPreds lastSolutionStep hasSolutionSteps) (genlPreds firstSolutionStep hasSolutionSteps) ;; ---- hypotheticalMicrotheoryOfTest ;; -------------------------- (isa hypotheticalMicrotheoryOfTest Predicate) ;; comment (comment hypotheticalMicrotheoryOfTest "(microtheoryOfQuery T HMT) means that the test T is asked, and has its hypthetical preconditions (if any) reified in HMT.") ;; isas (isa hypotheticalMicrotheoryOfTest BinaryPredicate) ;; arity (arity hypotheticalMicrotheoryOfTest 2) ;; arg isas (arg1Isa hypotheticalMicrotheoryOfTest KBContentTest) (arg2Isa hypotheticalMicrotheoryOfTest Microtheory) ;; ---- increasesThroughoutEvent-Fluent ;; -------------------------- (isa increasesThroughoutEvent-Fluent Predicate) ;; comment (comment increasesThroughoutEvent-Fluent "This predicate is used to state that the value of a fluent remains constant for a fixed object throughout an event.
(increasesThroughoutEvent-Fluent FLUENT EVENT) is true if and only if for every pair of sub-events SUB1 and SUB2 of EVENT there exist values VAL1 and VAL2 such that if
(and (startsAfterEndingOf SUB1 SUB2) (valueOf (MeasurementAtFn FLUENT SUB1) VAL1)) (valueOf (MeasurementAtFn FLUENT SUB2) VAL2))it follows that
(lessThan VAL1 VAL2)is true. See also decreasesThroughoutEvent-Fluent and constantThroughoutEvent-Fluent.") ;; isas (isa increasesThroughoutEvent-Fluent BinaryPredicate) ;; arity (arity increasesThroughoutEvent-Fluent 2) ;; arg isas (arg1Isa increasesThroughoutEvent-Fluent ScalarOrVectorInterval) (arg2Isa increasesThroughoutEvent-Fluent Event) ;; negationPreds (negationPreds increasesThroughoutEvent-Fluent constantThroughoutEvent-Fluent) (negationPreds increasesThroughoutEvent-Fluent decreasesThroughoutEvent-Fluent) ;; ---- lastSolutionStep ;; -------------------------- (isa lastSolutionStep Predicate) ;; comment (comment lastSolutionStep "A specialization of hasSolutionSteps (q.v.). (lastSolutionStep SOL STEP) means that STEP is the unique last step in the larger solution, SOL.") ;; isas (isa lastSolutionStep StrictlyFunctionalSlot) (isa lastSolutionStep CoexistingObjectsPredicate) (isa lastSolutionStep NonPhysicalPartPredicate) (isa lastSolutionStep IrreflexiveBinaryPredicate) ;; arity (arity lastSolutionStep 2) ;; arg isas (arg1Isa lastSolutionStep WorkedSolution) (arg2Isa lastSolutionStep WorkedSolutionStep) ;; genlPreds (genlPreds lastSolutionStep hasSolutionSteps) ;; ---- mathEquals ;; -------------------------- (isa mathEquals Predicate) ;; comment (comment mathEquals "
(mathEquals INTERVAL1 INTERVAL2) means that INTERVAL1 is mathematically equal to INTERVAL1 with respect to some scale that they are both on. If INTERVAL1 and INTERVAL2 have upper and lower bounds, those bounds are identical.
Note that mathEquals is not a specialization of equals (q.v.), as mathematical values of different sorts can be mathematically equivalent without being considered identical (e.g. the Integer 1 and the RealNumber 1.0).
See also the typed specialization of mathEquals, numericallyEquals, which applies only to scalar values.")
;; isas
(isa mathEquals EquivalenceRelation)
;; arity
(arity mathEquals 2)
;; arg isas
(arg1Isa mathEquals ScalarOrVectorInterval)
(arg2Isa mathEquals ScalarOrVectorInterval)
;; genlPreds
(genlPreds mathEquals intangibleParts)
;; spec preds
(genlPreds valueOf mathEquals)
(genlPreds numericallyEquals mathEquals)
;; ---- maximumMotionInDirection
;; --------------------------
(isa maximumMotionInDirection Predicate)
;; comment
(comment maximumMotionInDirection "(maximumMotionInDirection EVENT SUBEVENT DIRECTION) means that in the subevent SUBEVENT of
EVENT, the object that is the primary object moving in
SUBEVENT moves a distance in direction
DIRECTION that is no less than the distance the object moves
in that direction in any other subevent of EVENT.")
;; isas
(isa maximumMotionInDirection TernaryPredicate)
;; arity
(arity maximumMotionInDirection 3)
;; arg isas
(arg1Isa maximumMotionInDirection MovementEvent)
(arg2Isa maximumMotionInDirection MovementEvent)
(arg3Isa maximumMotionInDirection Direction)
;; ---- multipleChoiceSingleOptionList
;; --------------------------
(isa multipleChoiceSingleOptionList Predicate)
;; comment
(comment multipleChoiceSingleOptionList "(multipleChoiceSingleOptionList TEST LIST) means that for the KBContentTest TEST, the LIST whose first element is a CycL term and whose second element is a string corresponds to one answer choice out of several answer choices offered in the context in which TEST is asked.")
;; isas
(isa multipleChoiceSingleOptionList BinaryPredicate)
;; arity
(arity multipleChoiceSingleOptionList 2)
;; arg isas
(arg1Isa multipleChoiceSingleOptionList KBContentTest)
(arg2Isa multipleChoiceSingleOptionList List)
;; ---- nearestScalarInSet
;; --------------------------
(isa nearestScalarInSet Predicate)
;; comment
(comment nearestScalarInSet "A TernaryPredicate that relates a ScalarInterval to a ScalarInterval to a set of ScalarIntervals. (nearestScalarInSet A B SET) means that B is a member of SET and the absolute value of A minus B is less than the absolute value of the difference between A and any other member of SET. For example, the following is true:
(nearestScalarInSet 7 8 (TheSet 5 8 10)).") ;; isas (isa nearestScalarInSet TernaryPredicate) (isa nearestScalarInSet FunctionalPredicate) ;; arity (arity nearestScalarInSet 3) ;; arg isas (arg1Isa nearestScalarInSet ScalarInterval) (arg2Isa nearestScalarInSet ScalarInterval) (arg3Isa nearestScalarInSet (SetOfTypeFn ScalarInterval)) ;; ---- objectStationary ;; -------------------------- (isa objectStationary Predicate) ;; comment (comment objectStationary "
(objectStationary EVENT OBJ) means that in the PhysicalEvent EVENT, the instance of PartiallyTangible, OBJ, does not move.
For example, during a baseball game, the field that the game is played on does not move, so (relationAllExists objectStationary BaseballGame BaseballField) is true.")
;; isas
(isa objectStationary ActorSlot)
;; arity
(arity objectStationary 2)
;; arg isas
(arg1Isa objectStationary PhysicalEvent)
(arg2Isa objectStationary PartiallyTangible)
;; genlPreds
(genlPreds objectStationary objectStationary-Generalized)
(genlPreds objectStationary actors)
;; negationPreds
(negationPreds objectStationary objectMoving)
;; ---- objectStationary-Generalized
;; --------------------------
(isa objectStationary-Generalized Predicate)
;; comment
(comment objectStationary-Generalized "A BinaryPredicate that relates a TemporalThing to a PartiallyTangible. (objectStationary-Generalized TT OBJ) means that throughout TT, OBJ, does not move. An important specialization is the ActorSlot objectStationary.")
;; isas
(isa objectStationary-Generalized BinaryPredicate)
;; arity
(arity objectStationary-Generalized 2)
;; arg isas
(arg1Isa objectStationary-Generalized TemporalThing)
(arg2Isa objectStationary-Generalized PartiallyTangible)
;; genlPreds
(genlPreds objectStationary-Generalized temporallyIntersects)
;; spec preds
(genlPreds objectStationary objectStationary-Generalized)
;; negationPreds
(negationPreds objectStationary-Generalized objectMoving)
;; ---- objectTopSide
;; --------------------------
(isa objectTopSide Predicate)
;; comment
(comment objectTopSide "(objectTopSide OBJECT TOPSIDE) means that TOPSIDE is the entire top surface part of OBJECT. See also TopAndBottomSidedObject and TopSide.")
;; isas
(isa objectTopSide AsymmetricBinaryPredicate)
(isa objectTopSide StrictlyFunctionalSlot)
(isa objectTopSide PhysicalPartPredicate)
;; arity
(arity objectTopSide 2)
;; arg isas
(arg1Isa objectTopSide PartiallyTangible)
(arg2Isa objectTopSide SurfaceRegion-Tangible)
;; genlPreds
(genlPreds objectTopSide objectSides)
;; negationPreds
(negationPreds objectTopSide objectBottomSide)
(negationPreds objectTopSide objectFrontSide)
(negationPreds objectTopSide objectBackSide)
(negationPreds objectTopSide objectRightSide)
(negationPreds objectTopSide objectLeftSide)
;; ---- objectsInContact
;; --------------------------
(isa objectsInContact Predicate)
;; comment
(comment objectsInContact "(objectsInContact CONTACT OBJECT) means that OBJECT is one of the PartiallyTangibles in contact in the PhysicalContactSituation CONTACT.")
;; isas
(isa objectsInContact BinaryRolePredicate)
;; arity
(arity objectsInContact 2)
;; arg isas
(arg1Isa objectsInContact PhysicalContactSituation)
(arg2Isa objectsInContact PartiallyTangible)
;; genlPreds
(genlPreds objectsInContact situationConstituents)
;; spec preds
(genlPreds borderingNeighbors objectsInContact)
;; ---- partFarthestInDirection
;; --------------------------
(isa partFarthestInDirection Predicate)
;; isas
(isa partFarthestInDirection StrictlyFunctionalPredicate)
(isa partFarthestInDirection TemporallyQualifiableRelation)
(isa partFarthestInDirection RelativeLocationalPredicate)
(isa partFarthestInDirection TernaryPredicate)
;; arity
(arity partFarthestInDirection 3)
;; arg isas
(arg1Isa partFarthestInDirection PartiallyTangible)
(arg2Isa partFarthestInDirection Direction)
(arg3Isa partFarthestInDirection PartiallyTangible)
;; ---- priorSolutionStep
;; --------------------------
(isa priorSolutionStep Predicate)
;; comment
(comment priorSolutionStep "(priorSolutionStep LATER EARLIER) means that in the larger solution of which they are steps, EARLIER is a step that comes after LATER. priorSolutionStep imposes a total ordering on the steps in a worked solution.")
;; isas
(isa priorSolutionStep StrictlyFunctionalSlot)
(isa priorSolutionStep AsymmetricBinaryPredicate)
;; arity
(arity priorSolutionStep 2)
;; arg isas
(arg1Isa priorSolutionStep WorkedSolutionStep)
(arg2Isa priorSolutionStep WorkedSolutionStep)
;; ---- querySentenceOfQuery
;; --------------------------
(isa querySentenceOfQuery Predicate)
;; comment
(comment querySentenceOfQuery "(querySentenceOfQuery QUERY SENTENCE) means that SENTENCE is the query sentence for QUERY.")
;; isas
(isa querySentenceOfQuery DefaultMonotonicPredicate)
(isa querySentenceOfQuery StrictlyFunctionalSlot)
;; arity
(arity querySentenceOfQuery 2)
;; arg isas
(arg1Isa querySentenceOfQuery CycLQuerySpecification)
(arg2Isa querySentenceOfQuery Thing)
(argQuotedIsa querySentenceOfQuery 2 CycLSentence-Askable)
;; ---- solutionStepOperationType
;; --------------------------
(isa solutionStepOperationType Predicate)
;; comment
(comment solutionStepOperationType "(solutionStepOperationType STEP OPERATION-TYPE) means that WorkedSolutionStep STEP involves the ocurrence of an instance of the specialization of Event, OPERATION-TYPE. Typically, the instance of OPERATION-TYPE will be an action performed by the agent solving the pertinent problem with the worked solution of which STEP is a part. For example, it may be the process of instantiating a physical principle, or it may be balancing an equation.")
;; isas
(isa solutionStepOperationType BinaryPredicate)
;; arity
(arity solutionStepOperationType 2)
;; arg isas
(arg1Isa solutionStepOperationType WorkedSolutionStep)
(arg2Isa solutionStepOperationType SolutionStepEventType)
;; ---- solutionStepResult
;; --------------------------
(isa solutionStepResult Predicate)
;; comment
(comment solutionStepResult "(solutionStepResult STEP SENT) means that PhysicsWorkedSolutionStep STEP results in the addition of SENT to the worked solution of which it is a component. This predicate is not functional in argument 2, for a solution step may have more than one result.")
;; isas
(isa solutionStepResult BinaryPredicate)
;; arity
(arity solutionStepResult 2)
;; arg isas
(arg1Isa solutionStepResult WorkedSolutionStep)
(arg2Isa solutionStepResult Thing)
(argQuotedIsa solutionStepResult 2 CycLSentence-Assertible)
;; ---- solutionStepUses
;; --------------------------
(isa solutionStepUses Predicate)
;; comment
(comment solutionStepUses "(solutionStepUses STEP SENT) means that WorkedSolutionStep STEP appeals to the sentence SENT. Generally, SENT will be a component of the statement of the problem to the worked solution of which STEP is a part, or it will be the statement of a general principle that is pertinent to solving the problem.")
;; isas
(isa solutionStepUses BinaryPredicate)
;; arity
(arity solutionStepUses 2)
;; arg isas
(arg1Isa solutionStepUses WorkedSolutionStep)
(arg2Isa solutionStepUses Thing)
(argQuotedIsa solutionStepUses 2 CycLSentence-Askable)
;; ---- termToSolveFor
;; --------------------------
(isa termToSolveFor Predicate)
;; comment
(comment termToSolveFor "(termToSolveFor Q-SPEC SENT TERM) means that in the context of the query Q-SPEC, the term to be solved for in inference is TERM, a term that occurs in SENT. This predicate is intended to be used together with querySentenceOfQuery (q.v.).")
;; isas
(isa termToSolveFor TernaryPredicate)
;; arity
(arity termToSolveFor 3)
;; arg isas
(arg1Isa termToSolveFor CycLQuerySpecification)
(argQuotedIsa termToSolveFor 2 CycLSentence-Askable)
(arg3Isa termToSolveFor Thing)
(argQuotedIsa termToSolveFor 3 CycLTerm)
;; ---- testAnswers-SingleCorrectMultipleChoice
;; --------------------------
(isa testAnswers-SingleCorrectMultipleChoice Predicate)
;; comment
(comment testAnswers-SingleCorrectMultipleChoice "(testAnswers-SingleCorrectMultipleChoiceValue TEST ANSWER) means that ANSWER is the single correct choice among the labels (typically numbers of letters) of the multiple choice answers for the question associated with TEST.")
;; isas
(isa testAnswers-SingleCorrectMultipleChoice StrictlyFunctionalSlot)
(isa testAnswers-SingleCorrectMultipleChoice DefaultMonotonicPredicate)
;; arity
(arity testAnswers-SingleCorrectMultipleChoice 2)
;; arg isas
(arg1Isa testAnswers-SingleCorrectMultipleChoice KBContentTest-FullySpecified)
(arg2Isa testAnswers-SingleCorrectMultipleChoice Thing)
;; ---- testQuerySpecification
;; --------------------------
(isa testQuerySpecification Predicate)
;; isas
(isa testQuerySpecification BinaryPredicate)
(isa testQuerySpecification TimeDependentRelation)
;; arity
(arity testQuerySpecification 2)
;; arg isas
(arg1Isa testQuerySpecification KBContentTest)
(arg2Isa testQuerySpecification CycLQuerySpecification)
;; ---- thingAttached
;; --------------------------
(isa thingAttached Predicate)
;; comment
(comment thingAttached "A specialization of configuredObjects. (thingAttached ATTACH THING) means that THING is attached to some other object (see the predicate thingAttachedTo) in the attachment configuration ATTACH.")
;; isas
(isa thingAttached BinaryRolePredicate)
;; arity
(arity thingAttached 2)
;; arg isas
(arg1Isa thingAttached Attachment)
(arg2Isa thingAttached PartiallyTangible)
;; genlPreds
(genlPreds thingAttached configuredObjects)
;; ---- thingAttachedTo
;; --------------------------
(isa thingAttachedTo Predicate)
;; comment
(comment thingAttachedTo "A specialization of configuredObjects. (thingAttachedTo ATTACH THING) means that some other object is attached to THING in the attachment configuration ATTACH.")
;; isas
(isa thingAttachedTo BinaryRolePredicate)
;; arity
(arity thingAttachedTo 2)
;; arg isas
(arg1Isa thingAttachedTo Attachment)
(arg2Isa thingAttachedTo PartiallyTangible)
;; genlPreds
(genlPreds thingAttachedTo configuredObjects)
;; ---- thingIrrelevantToThing
;; --------------------------
(isa thingIrrelevantToThing Predicate)
;; comment
(comment thingIrrelevantToThing "(thingIrrelevantToThing THING1 THING2) means that when reasoning about THING2, it is not necessary to draw in considerations about THING1. For example, (thingIrrelevantToThing ((VectorQuantityOfFn FrictionVector) Obj001) Obj001)) means that the friction vectors that might ordinarily be applicable to Obj001 are in fact irrelevant to considerations about Obj001.")
;; isas
(isa thingIrrelevantToThing BinaryPredicate)
;; arity
(arity thingIrrelevantToThing 2)
;; arg isas
(arg1Isa thingIrrelevantToThing FirstOrderCollection)
(arg2Isa thingIrrelevantToThing Thing)
;; ---- valueOf
;; --------------------------
(isa valueOf Predicate)
;; comment
(comment valueOf "A BinaryPredicate and specialization of mathEquals. (valueOf X Y) means that the term 'X' is, in effect, a definite description that (contingently) picks out the ScalarOrVectorInterval that is directly denoted by 'Y'.
For example, (valueOf ((QPQuantityFn Mass) EiffelTower) (MetricTon 10100)) is true.")
;; isas
(isa valueOf AsymmetricBinaryPredicate)
(isa valueOf FunctionalSlot)
;; arity
(arity valueOf 2)
;; arg isas
(arg1Isa valueOf ScalarOrVectorInterval)
(argQuotedIsa valueOf 1 CycLDenotationalTerm)
(arg2Isa valueOf ScalarOrVectorInterval)
(argQuotedIsa valueOf 2 CycLDenotationalTerm)
;; genlPreds
(genlPreds valueOf mathEquals)
(genlPreds valueOf intangibleParts)
;; ---- workedSolutionForKBContentTest
;; --------------------------
(isa workedSolutionForKBContentTest Predicate)
;; comment
(comment workedSolutionForKBContentTest "(workedSolutionForKBContentTest TEST SOLUTION) means that SOLUTION is a worked solution for TEST.")
;; isas
(isa workedSolutionForKBContentTest BinaryPredicate)
;; arity
(arity workedSolutionForKBContentTest 2)
;; arg isas
(arg1Isa workedSolutionForKBContentTest KBContentTest)
(arg2Isa workedSolutionForKBContentTest WorkedSolution)
;; ---- workedSolutionMtForTestMt
;; --------------------------
(isa workedSolutionMtForTestMt Predicate)
;; comment
(comment workedSolutionMtForTestMt "(workedSolutionMtForTestMt T WS) means that WS is a worked solutiuon for T.")
;; isas
(isa workedSolutionMtForTestMt BinaryPredicate)
;; arity
(arity workedSolutionMtForTestMt 2)
;; arg isas
(arg1Isa workedSolutionMtForTestMt Microtheory)
(arg2Isa workedSolutionMtForTestMt Microtheory)
;;;; File name: steps-defns.meld
;;;; Modified: Saturday, June 17, 2006 at 17:46:49 by forbus
;; ---- DeterminingSpecificScalarOrVectorValuesFromContext
;; --------------------------
(isa DeterminingSpecificScalarOrVectorValuesFromContext Collection)
;; comment
(comment DeterminingSpecificScalarOrVectorValuesFromContext "A specialization of SolvingAProblem. Each instance of DeterminingSpecificScalarOrVectorValuesFromContext
is an event in which an agent determines the specific values of certain scalars or vectors based on contextual information.
An example would be determining that the speed at which Bob is travelling is 65 miles per hour based on the contextual information that Bob is travelling at the speed limit and the speed limit is 65 miles per hour.") ;; genls (genls DeterminingSpecificScalarOrVectorValuesFromContext SolvingAProblem) ;; isas (isa DeterminingSpecificScalarOrVectorValuesFromContext PhysicsCoreSolutionStepEventType) (isa DeterminingSpecificScalarOrVectorValuesFromContext TemporalObjectType) ;; ---- SanityCheckingPhysicsProblemSolution ;; -------------------------- (isa SanityCheckingPhysicsProblemSolution Collection) ;; comment (comment SanityCheckingPhysicsProblemSolution "A specialization of SolvingAProblem. Each instance of SanityCheckingPhysicsProblemSolution is an event in which an agent checks the results of calculations performed to solve a physics problem to see whether they are reasonable.") ;; genls (genls SanityCheckingPhysicsProblemSolution SolvingAProblem) ;; isas (isa SanityCheckingPhysicsProblemSolution TemporalObjectType) (isa SanityCheckingPhysicsProblemSolution PhysicsCoreSolutionStepEventType) ;; ---- CategorizingAPhysicsProblem ;; -------------------------- (isa CategorizingAPhysicsProblem Collection) ;; comment (comment CategorizingAPhysicsProblem "A specialization of SolvingAProblem and GroupingThingsMentally. Each instance of CategorizingAPhysicsProblem is an event in which an agent determines which category a specific physics problem belongs to.") ;; genls (genls CategorizingAPhysicsProblem SolvingAProblem) (genls CategorizingAPhysicsProblem GroupingThingsMentally) ;; isas (isa CategorizingAPhysicsProblem PhysicsCoreSolutionStepEventType) (isa CategorizingAPhysicsProblem TemporalObjectType) ;; ---- SubstitutingBindingsForVariables ;; -------------------------- (isa SubstitutingBindingsForVariables Collection) ;; comment (comment SubstitutingBindingsForVariables "A specialization of SolvingAProblem. Each instance of SubstitutingBindingsForVariables is an event in which an agent substitutes known bindings for variables in a formula.") ;; genls (genls SubstitutingBindingsForVariables SolvingAProblem) ;; isas (isa SubstitutingBindingsForVariables PhysicsCoreSolutionStepEventType) ;; ---- SolvingAMathematicalEquation ;; -------------------------- (isa SolvingAMathematicalEquation Collection) ;; comment (comment SolvingAMathematicalEquation "Taking an equation and determining the value of a variable in terms of constants and other variables within the rules of algebra. The catalyst to creating this unit was skills required effort.") ;; genls (genls SolvingAMathematicalEquation SolvingAProblem) (genls SolvingAMathematicalEquation DoingMath) (genls SolvingAMathematicalEquation IntelligentAgentActivity) ;; isas (isa SolvingAMathematicalEquation PhysicsCoreSolutionStepEventType) (isa SolvingAMathematicalEquation TechniqueType) ;; ---- DeterminingTheBestAnswerFromASetOfChoices ;; -------------------------- (isa DeterminingTheBestAnswerFromASetOfChoices Collection) ;; comment (comment DeterminingTheBestAnswerFromASetOfChoices "A specialization of SolvingAProblem. Each instance of DeterminingTheBestAnswerFromASetOfChoices is an event in which an agent determines the best answer from a set of choices.") ;; genls (genls DeterminingTheBestAnswerFromASetOfChoices PurposefulAction) ;; isas (isa DeterminingTheBestAnswerFromASetOfChoices PhysicsCoreSolutionStepEventType) ;; ---- IdentifyingAWholeWithTheSumOfItsParts ;; -------------------------- (isa IdentifyingAWholeWithTheSumOfItsParts Collection) ;; comment (comment IdentifyingAWholeWithTheSumOfItsParts "A specialization of AnalyzingSomething. Each instance of IdentifyingAWholeWithTheSumOfItsParts is an event in which an agent explicitly equates or identifies a thing with the sum of (certain of) its parts. An example would be the act of explicitly observing that the territory of the United States is the spatial sum of the territories of each of the fifty states.") ;; genls (genls IdentifyingAWholeWithTheSumOfItsParts AnalyzingSomething) ;; isas (isa IdentifyingAWholeWithTheSumOfItsParts PhysicsOptionalSolutionStepEventType) ;; ---- MakingNecessaryBackgroundAssumptions ;; -------------------------- (isa MakingNecessaryBackgroundAssumptions Collection) ;; comment (comment MakingNecessaryBackgroundAssumptions "A specialization of DecidingToDoSomething and AssumingSomethingToBeTrue. Each instance of MakingNecessaryBackgroundAssumptions is an event in which an agent makes background assumptions that are necessary for solving a problem.") ;; genls (genls MakingNecessaryBackgroundAssumptions AssumingSomethingToBeTrue) (genls MakingNecessaryBackgroundAssumptions DecidingToDoSomething) ;; isas (isa MakingNecessaryBackgroundAssumptions TemporalObjectType) (isa MakingNecessaryBackgroundAssumptions PhysicsOptionalSolutionStepEventType) ;;;; --------------------------------------------------------------------------- ;;;; End of Code