Zvolte jazyk: english | cesky | deutsch | italiano | simplified chinese | traditional chinese | hindi Koncept: Anglické slovo: Hlavní stránka

# 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ů

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

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

```(=>
(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))))```

```(=>
(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))))```

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

```(=>
(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))))```

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

```(=>
(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))```

```(=>
(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))```

```(=>
(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)))))```

```(=>
(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)))```