Select language: english | cesky | deutsch | italiano | simplified chinese | traditional chinese | hindi Concept: English word: Home

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

## Ontology

SUMO / STRUCTURAL-ONTOLOGY

## Class(es)

 class

inheritable relation

predicate
 variable arity relation

holds

## Coordinate term(s)

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

holds(relation)

## Axioms (34)

If rel1 is an inverse of rel2, then for all inst1,inst2 holds: rel1(inst1,inst2) holds if and only if rel2(inst2,inst1) holds.
```(=>
(inverse ?REL1 ?REL2)
(forall
(?INST1 ?INST2)
(<=>
(holds ?REL1 ?INST1 ?INST2)
(holds ?REL2 ?INST2 ?INST1))))```

If rel1 is a subrelation of rel2 and rel1() holds, then rel2() holds.
```(=>
(and
(subrelation ?REL1 ?REL2)
(holds ?REL1 @ROW))
(holds ?REL2 @ROW))```

If rel1 is equal to rel2, then for all holds: rel1() holds if and only if 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))))```

If and ? are disjoint and rel1 is a member of "()" and rel2 is a member of "()" and rel1 is not equal to rel2 and rel1() holds, then 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)))```

If rel(,inst) holds and rel is an instance of function, then "rel()" is equal to inst.
```(=>
(and
(holds ?REL @ROW ?INST)
(instance ?REL Function))
(equal
(AssignmentFn ?REL @ROW)
?INST))```

If rel is an instance of relation, then rel() holds if and only if rel() holds.
```(=>
(instance ?REL Relation)
(<=>
(holds ?REL @ROW)
(?REL @ROW)))```

rel is an instance of single valued relation if and only if for all ,item1,item2 holds: if rel(,item1) holds and rel(,item2) holds, then item1 is equal to item2.
```(<=>
(instance ?REL SingleValuedRelation)
(forall
(@ROW ?ITEM1 ?ITEM2)
(=>
(and
(holds ?REL @ROW ?ITEM1)
(holds ?REL @ROW ?ITEM2))
(equal ?ITEM1 ?ITEM2))))```

rel is an instance of total valued relation if and only if there exists valence so that rel is an instance of relation and rel %&has valence argument(s) and
• if for all number,element,class holds: if number is less than valence and the number number argument of rel is an instance of class and element is equal to "numberth element of "()"", then element is an instance of class,
• then there exists item so that 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))))))```

If rel is an instance of binary relation, then there don't exist item1,item2,item3, so that 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)))```

If rel is an instance of irreflexive relation, then for all inst holds: 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))))```

If rel is an instance of trichotomizing relation, then for all inst1,inst2 holds: rel(inst1,inst2) holds or inst1 is equal to inst2 or 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)))))```

If rel is an instance of total ordering relation, then for all inst1,inst2 holds: rel(inst1,inst2) holds or rel(inst2,inst1) holds.
```(=>
(instance ?REL TotalOrderingRelation)
(forall
(?INST1 ?INST2)
(or
(holds ?REL ?INST1 ?INST2)
(holds ?REL ?INST2 ?INST1))))```

If rel is an instance of intentional relation and rel(agent,) holds and obj is a member of "()", then agent is interested in obj.
```(=>
(and
(instance ?REL IntentionalRelation)
(holds ?REL ?AGENT @ROW)
(inList
?OBJ
(ListFn @ROW)))
(inScopeOfInterest ?AGENT ?OBJ))```

If rel is an instance of ternary relation, then there don't exist item1,item2,item3,item4, so that rel(item1,item2,item3,item4,) holds.
```(=>
(instance ?REL TernaryRelation)
(not
(exists
(?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 @ROW)
(holds ?REL ?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 @ROW))))```

If rel is an instance of quaternary relation, then there don't exist item1,item2,item3,item4,item5, so that 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))))```

If rel is an instance of quintary relation, then there don't exist item1,item2,item3,item4,item5,item6, so that 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))))```

If the number number argument of rel is an instance of class and rel() holds, then "numberth element of "()"" is an instance of class.
```(=>
(and
(domain ?REL ?NUMBER ?CLASS)
(holds ?REL @ROW))
(instance
(ListOrderFn
(ListFn @ROW)
?NUMBER)
?CLASS))```

If the number number argument of rel is a subclass of class and rel() holds, then "numberth element of "()"" is a subclass of 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))))```

• if relation is reflexive on class,
• then for all inst holds: if inst is an instance of class, then relation(inst,inst) holds
• .
```(=>
(reflexiveOn ?RELATION ?CLASS)
(forall
(?INST)
(=>
(instance ?INST ?CLASS)
(holds ?RELATION ?INST ?INST))))```

• if relation is irreflexive on class,
• then for all inst holds: if inst is an instance of class, then relation(inst,inst) doesn't hold
• .
```(=>
(irreflexiveOn ?RELATION ?CLASS)
(forall
(?INST)
(=>
(instance ?INST ?CLASS)
(not
(holds ?RELATION ?INST ?INST)))))```

• if relation is trichotomizing on class,
• then for all inst1,inst2 holds: if inst1 is an instance of class and inst2 is an instance of class, then relation(inst1,inst2) holds or relation(inst2,inst1) holds or inst1 is equal to 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)))))```

If role is an instance of case role and role(arg1,arg2) holds and arg1 is an instance of proc, then arg2 is 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)))))```

If rel(inst1,inst2) holds during interval and inst1 is an instance of physical and inst2 is an instance of physical, then inst1 exists during interval and inst2 exists during interval.
```(=>
(and
(holdsDuring
?INTERVAL
(holds ?REL ?INST1 ?INST2))
(instance ?INST1 Physical)
(instance ?INST2 Physical))
(and
(time ?INST1 ?INTERVAL)
(time ?INST2 ?INTERVAL)))```

If rel is an instance of spatial relation and rel(obj1,obj2) holds, then "the time of existence of obj2" overlaps "the time of existence of obj1".
```(=>
(and
(instance ?REL SpatialRelation)
(holds ?REL ?OBJ1 ?OBJ2))
(overlapsTemporally
(WhenFn ?OBJ1)
(WhenFn ?OBJ2)))```

If rel is an instance of case role and rel(process,obj) holds, then there exists time so that "the place where process was at time" overlaps with obj.
```(=>
(and
(instance ?REL CaseRole)
(holds ?REL ?PROCESS ?OBJ))
(exists
(?TIME)
(overlapsSpatially
(WhereFn ?PROCESS ?TIME)
?OBJ)))```