holds (holds)

(holds P N1 ... NK) is true just in case the tuple of objects denoted by N1,..., NK is an element of the Relation P.

Ontologie

SUMO / STRUCTURAL-ONTOLOGY

Class(es)

třída

inheritable relation

predikát

relace s proměnným počtem argumentů
is instance of

holds

Související termín(y)

assignment fn greatest common divisor fn least common multiple fn list fn contrary attribute disjoint decomposition disjoint relation exhaustive attribute exhaustive decomposition partition

Typy argumentů

holds(relace)

Axiomy (34)

Jestliže rel1 je inverzní k rel2, potom pro všechny inst1,inst2 platí: rel1(inst1,inst2) holds tehdy a jen tehdy pokud rel2(inst2,inst1) holds.

(=>
      (inverse ?REL1 ?REL2)
      (forall
            (?INST1 ?INST2)
            (<=>
                  (holds ?REL1 ?INST1 ?INST2)
                  (holds ?REL2 ?INST2 ?INST1))))

Jestliže rel1 je a subrelation of rel2 a rel1() holds, potom rel2() holds.

(=>
      (and
            (subrelation ?REL1 ?REL2)
            (holds ?REL1 @ROW))
      (holds ?REL2 @ROW))

Jestliže rel1 se rovná rel2, potom pro všechny platí: rel1() holds tehdy a jen tehdy pokud rel2() holds.

(=>
      (equal ?REL1 ?REL2)
      (forall
            (@ROW)
            (<=>
                  (holds ?REL1 @ROW)
                  (holds ?REL2 @ROW))))

jestliže obj1 se rovná obj2,
potom jestliže obj1 se rovná "numberth element of "()"" a obj2 se rovná "numberth element of "()"" a "()" se rovná "()", potom () holds tehdy a jen tehdy pokud () holds

(=>
      (equal ?OBJ1 ?OBJ2)
      (=>
            (and
                  (equal
                        ?OBJ1
                        (ListOrderFn
                              (ListFn @ROW1)
                              ?NUMBER))
                  (equal
                        ?OBJ2
                        (ListOrderFn
                              (ListFn @ROW2)
                              ?NUMBER))
                  (equal
                        (ListFn @ROW1)
                        (ListFn @ROW2)))
            (<=>
                  (holds @ROW1)
                  (holds @ROW2))))

Jestliže and ? are disjoint a rel1 je a member of "()" a rel2 je a member of "()" a rel1 se nerovná rel2 a rel1() holds, potom rel2() doesn't hold.

(=>
      (and
            (disjointRelation @ROW1)
            (inList
                  ?REL1
                  (ListFn @ROW1))
            (inList
                  ?REL2
                  (ListFn @ROW1))
            (not
                  (equal ?REL1 ?REL2))
            (holds ?REL1 @ROW2))
      (not
            (holds ?REL2 @ROW2)))

Jestliže rel(,inst) holds a rel je instancí třídy funkce, potom "rel()" se rovná inst.

(=>
      (and
            (holds ?REL @ROW ?INST)
            (instance ?REL Function))
      (equal
            (AssignmentFn ?REL @ROW)
            ?INST))

Jestliže rel je instancí třídy relace, potom rel() holds tehdy a jen tehdy pokud rel() platí.

(=>
      (instance ?REL Relation)
      (<=>
            (holds ?REL @ROW)
            (?REL @ROW)))

rel je instancí třídy relace s jedinou hodnotou tehdy a jen tehdy pokud pro všechny ,item1,item2 platí: jestliže rel(,item1) holds a rel(,item2) holds, potom item1 se rovná item2.

(<=>
      (instance ?REL SingleValuedRelation)
      (forall
            (@ROW ?ITEM1 ?ITEM2)
            (=>
                  (and
                        (holds ?REL @ROW ?ITEM1)
                        (holds ?REL @ROW ?ITEM2))
                  (equal ?ITEM1 ?ITEM2))))

rel je instancí třídy úplná relace tehdy a jen tehdy pokud existuje valence tak, že rel je instancí třídy relace a rel has valence argument(s) a

jestliže pro všechny number,element,class platí: jestliže number je menší než valence a numberth argument of rel je an instance of class a element se rovná "numberth element of "()"", potom element je instancí třídy class,
potom existuje item tak, že rel(,item) holds

(<=>
      (instance ?REL TotalValuedRelation)
      (exists
            (?VALENCE)
            (and
                  (instance ?REL Relation)
                  (valence ?REL ?VALENCE)
                  (=>
                        (forall
                              (?NUMBER ?ELEMENT ?CLASS)
                              (=>
                                    (and
                                          (lessThan ?NUMBER ?VALENCE)
                                          (domain ?REL ?NUMBER ?CLASS)
                                          (equal
                                                ?ELEMENT
                                                (ListOrderFn
                                                      (ListFn @ROW)
                                                      ?NUMBER)))
                                    (instance ?ELEMENT ?CLASS)))
                        (exists
                              (?ITEM)
                              (holds ?REL @ROW ?ITEM))))))

Jestliže rel je instancí třídy binární relace, potom neexistují item1,item2,item3, tak, že rel(item1,item2,item3,) holds.

(=>
      (instance ?REL BinaryRelation)
      (not
            (exists
                  (?ITEM1 ?ITEM2 ?ITEM3 @ROW)
                  (holds ?REL ?ITEM1 ?ITEM2 ?ITEM3 @ROW))))

jestliže rel je instancí třídy reflexivní relace,
potom jestliže rel(inst1,inst2) holds nebo rel(inst2,inst1) holds, potom rel(inst1,inst1) holds

(=>
      (instance ?REL ReflexiveRelation)
      (=>
            (or
                  (holds ?REL ?INST1 ?INST2)
                  (holds ?REL ?INST2 ?INST1))
            (holds ?REL ?INST1 ?INST1)))

Jestliže rel je instancí třídy ireflexivní relace, potom pro všechny inst platí: rel(inst,inst) doesn't hold.

(=>
      (instance ?REL IrreflexiveRelation)
      (forall
            (?INST)
            (not
                  (holds ?REL ?INST ?INST))))

jestliže rel je instancí třídy symetrická relace,
potom pro všechny inst1,inst2 platí: jestliže rel(inst1,inst2) holds, potom rel(inst2,inst1) holds

(=>
      (instance ?REL SymmetricRelation)
      (forall
            (?INST1 ?INST2)
            (=>
                  (holds ?REL ?INST1 ?INST2)
                  (holds ?REL ?INST2 ?INST1))))

jestliže rel je instancí třídy antisymetrická relace,
potom pro všechny inst1,inst2 platí: jestliže rel(inst1,inst2) holds a rel(inst2,inst1) holds, potom inst1 se rovná inst2

(=>
      (instance ?REL AntisymmetricRelation)
      (forall
            (?INST1 ?INST2)
            (=>
                  (and
                        (holds ?REL ?INST1 ?INST2)
                        (holds ?REL ?INST2 ?INST1))
                  (equal ?INST1 ?INST2))))

Jestliže rel je instancí třídy trichotomická relace, potom pro všechny inst1,inst2 platí: rel(inst1,inst2) holds nebo inst1 se rovná inst2 nebo rel(inst2,inst1) holds.

(=>
      (instance ?REL TrichotomizingRelation)
      (forall
            (?INST1 ?INST2)
            (or
                  (holds ?REL ?INST1 ?INST2)
                  (equal ?INST1 ?INST2)
                  (holds ?REL ?INST2 ?INST1))))

jestliže rel je instancí třídy tranzitivní relace,
potom pro všechny inst1,inst2,inst3 platí: jestliže rel(inst1,inst2) holds a rel(inst2,inst3) holds, potom rel(inst1,inst3) holds

(=>
      (instance ?REL TransitiveRelation)
      (forall
            (?INST1 ?INST2 ?INST3)
            (=>
                  (and
                        (holds ?REL ?INST1 ?INST2)
                        (holds ?REL ?INST2 ?INST3))
                  (holds ?REL ?INST1 ?INST3))))

jestliže rel je instancí třídy netranzitivní relace,
potom pro všechny inst1,inst2,inst3 platí: jestliže rel(inst1,inst2) holds a rel(inst2,inst3) holds, potom rel(inst1,inst3) doesn't hold

(=>
      (instance ?REL IntransitiveRelation)
      (forall
            (?INST1 ?INST2 ?INST3)
            (=>
                  (and
                        (holds ?REL ?INST1 ?INST2)
                        (holds ?REL ?INST2 ?INST3))
                  (not
                        (holds ?REL ?INST1 ?INST3)))))

Jestliže rel je instancí třídy relace úplné uspořádání, potom pro všechny inst1,inst2 platí: rel(inst1,inst2) holds nebo rel(inst2,inst1) holds.

(=>
      (instance ?REL TotalOrderingRelation)
      (forall
            (?INST1 ?INST2)
            (or
                  (holds ?REL ?INST1 ?INST2)
                  (holds ?REL ?INST2 ?INST1))))

Jestliže rel je instancí třídy intentional relation a rel(agent,) holds a obj je a member of "()", potom agent je interested in obj.

(=>
      (and
            (instance ?REL IntentionalRelation)
            (holds ?REL ?AGENT @ROW)
            (inList
                  ?OBJ
                  (ListFn @ROW)))
      (inScopeOfInterest ?AGENT ?OBJ))

Jestliže rel je instancí třídy terciální relace, potom neexistují item1,item2,item3,item4, tak, že rel(item1,item2,item3,item4,) holds.

(=>
      (instance ?REL TernaryRelation)
      (not
            (exists
                  (?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 @ROW)
                  (holds ?REL ?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 @ROW))))

Jestliže rel je instancí třídy relace se čtyřmi argumenty, potom neexistují item1,item2,item3,item4,item5, tak, že rel(item1,item2,item3,item4,item5,) holds.

(=>
      (instance ?REL QuaternaryRelation)
      (not
            (exists
                  (?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 ?ITEM5 @ROW)
                  (holds ?REL ?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 ?ITEM5 @ROW))))

Jestliže rel je instancí třídy relace s pěti argumenty, potom neexistují item1,item2,item3,item4,item5,item6, tak, že rel(item1,item2,item3,item4,item5,item6,) holds.

(=>
      (instance ?REL QuintaryRelation)
      (not
            (exists
                  (?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 ?ITEM5 ?ITEM6 @ROW)
                  (holds ?REL ?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 ?ITEM5 ?ITEM6 @ROW))))

Jestliže numberth argument of rel je an instance of class a rel() holds, potom "numberth element of "()"" je instancí třídy class.

(=>
      (and
            (domain ?REL ?NUMBER ?CLASS)
            (holds ?REL @ROW))
      (instance
            (ListOrderFn
                  (ListFn @ROW)
                  ?NUMBER)
            ?CLASS))

Jestliže numberth argument of rel je a subclass of class a rel() holds, potom "numberth element of "()"" je podtřídou class.

(=>
      (and
            (domainSubclass ?REL ?NUMBER ?CLASS)
            (holds ?REL @ROW))
      (subclass
            (ListOrderFn
                  (ListFn @ROW)
                  ?NUMBER)
            ?CLASS))

jestliže rel has number argument(s),
potom pro všechny platí: jestliže rel() holds, potom "length of "()"" se rovná number

(=>
      (valence ?REL ?NUMBER)
      (forall
            (@ROW)
            (=>
                  (holds ?REL @ROW)
                  (equal
                        (ListLengthFn
                              (ListFn @ROW))
                        ?NUMBER))))

jestliže relation je reflexive on class,
potom pro všechny inst platí: jestliže inst je instancí třídy class, potom relation(inst,inst) holds

(=>
      (reflexiveOn ?RELATION ?CLASS)
      (forall
            (?INST)
            (=>
                  (instance ?INST ?CLASS)
                  (holds ?RELATION ?INST ?INST))))

jestliže relation je irreflexive on class,
potom pro všechny inst platí: jestliže inst je instancí třídy class, potom relation(inst,inst) doesn't hold

(=>
      (irreflexiveOn ?RELATION ?CLASS)
      (forall
            (?INST)
            (=>
                  (instance ?INST ?CLASS)
                  (not
                        (holds ?RELATION ?INST ?INST)))))

jestliže relation je trichotomizing on class,
potom pro všechny inst1,inst2 platí: jestliže inst1 je instancí třídy class a inst2 je instancí třídy class, potom relation(inst1,inst2) holds nebo relation(inst2,inst1) holds nebo inst1 se rovná inst2

(=>
      (trichotomizingOn ?RELATION ?CLASS)
      (forall
            (?INST1 ?INST2)
            (=>
                  (and
                        (instance ?INST1 ?CLASS)
                        (instance ?INST2 ?CLASS))
                  (or
                        (holds ?RELATION ?INST1 ?INST2)
                        (holds ?RELATION ?INST2 ?INST1)
                        (equal ?INST1 ?INST2)))))

Jestliže role je instancí třídy case role a role(arg1,arg2) holds a arg1 je instancí třídy proc, potom arg2 je capable to do proc in role role.

(=>
      (and
            (instance ?ROLE CaseRole)
            (holds ?ROLE ?ARG1 ?ARG2)
            (instance ?ARG1 ?PROC))
      (capability ?PROC ?ROLE ?ARG2))

jestliže rel je instancí třídy relace rozšířená na veličiny a rel je instancí třídy terciální relace a number1 je instancí třídy reálné číslo a number2 je instancí třídy reálné číslo a rel(number1,number2,value) holds,
potom pro všechny unit platí: jestliže unit je instancí třídy měrná jednotka, potom rel("number1 unit(s)","number2 unit(s)","value unit(s)") holds

(=>
      (and
            (instance ?REL RelationExtendedToQuantities)
            (instance ?REL TernaryRelation)
            (instance ?NUMBER1 RealNumber)
            (instance ?NUMBER2 RealNumber)
            (holds ?REL ?NUMBER1 ?NUMBER2 ?VALUE))
      (forall
            (?UNIT)
            (=>
                  (instance ?UNIT UnitOfMeasure)
                  (holds
                        ?REL
                        (MeasureFn ?NUMBER1 ?UNIT)
                        (MeasureFn ?NUMBER2 ?UNIT)
                        (MeasureFn ?VALUE ?UNIT)))))

jestliže rel je instancí třídy relace rozšířená na veličiny a rel je instancí třídy binární relace a number1 je instancí třídy reálné číslo a number2 je instancí třídy reálné číslo a rel(number1,number2) holds,
potom pro všechny unit platí: jestliže unit je instancí třídy měrná jednotka, potom rel("number1 unit(s)","number2 unit(s)") holds

(=>
      (and
            (instance ?REL RelationExtendedToQuantities)
            (instance ?REL BinaryRelation)
            (instance ?NUMBER1 RealNumber)
            (instance ?NUMBER2 RealNumber)
            (holds ?REL ?NUMBER1 ?NUMBER2))
      (forall
            (?UNIT)
            (=>
                  (instance ?UNIT UnitOfMeasure)
                  (holds
                        ?REL
                        (MeasureFn ?NUMBER1 ?UNIT)
                        (MeasureFn ?NUMBER2 ?UNIT)))))

Jestliže rel(inst1,inst2) holds během interval a inst1 je instancí třídy fyzický objekt a inst2 je instancí třídy fyzický objekt, potom inst1 exists during interval a inst2 exists during interval.

(=>
      (and
            (holdsDuring
                  ?INTERVAL
                  (holds ?REL ?INST1 ?INST2))
            (instance ?INST1 Physical)
            (instance ?INST2 Physical))
      (and
            (time ?INST1 ?INTERVAL)
            (time ?INST2 ?INTERVAL)))

Jestliže rel je instancí třídy prostorová relace a rel(obj1,obj2) holds, potom "doba existence obj2" overlaps "doba existence obj1".

(=>
      (and
            (instance ?REL SpatialRelation)
            (holds ?REL ?OBJ1 ?OBJ2))
      (overlapsTemporally
            (WhenFn ?OBJ1)
            (WhenFn ?OBJ2)))

Jestliže rel je instancí třídy case role a rel(process,obj) holds, potom existuje time tak, že "místo kde process byl v čase time" se překrývá s obj.

(=>
      (and
            (instance ?REL CaseRole)
            (holds ?REL ?PROCESS ?OBJ))
      (exists
            (?TIME)
            (overlapsSpatially
                  (WhereFn ?PROCESS ?TIME)
                  ?OBJ)))