in list (inList)

The analog of element and instance for Lists. (inList obj list) means that obj is in the List list. For example, (inList Tuesday (ListFn Monday Tuesday Wednesday)) would be true.

Ontology

SUMO / BASE-ONTOLOGY

Class(es)

Classe

inheritable relation

PredicatoBinario
is instance of

RelazioneNonRiflessiva
is instance of

RelazioneAsimmetrica
is instance of

in list

Coordinate term(s)

back fn cardinality fn front fn principal host fn probability fn skin fn arc weight attribute authors before before or equal causes causes subclass citizen closed on completely fills connected connected engineering components contains information cooccur copy crosses date decreases likelihood developmental form disjoint distributes documentation duration during earlier editor element employs equal equivalence relation on exploits expressed in language faces family relation fills finishes frequency graph part greater than greater than or equal to has purpose has skill holds during holds obligation holds right hole identity element immediate instance immediate subclass in scope of interest increases likelihood independent probability inhabits inhibits initial list instance interior part inverse irreflexive on larger less than less than or equal to manner material measure meets spatially meets temporally member modal attribute overlaps partially overlaps temporally parent partial ordering on partially fills partly located path length penetrates possesses precondition prevents proper part properly fills property publishes range range subclass realization refers reflexive on related internal concept sibling smaller starts sub attribute sub collection sub graph sub list sub organizations sub plan sub process sub proposition subclass subrelation subsumes content class subsumes content instance successor attribute successor attribute closure superficial part surface temporal part time total ordering on trichotomizing on uses valence version

Type restrictions

inList(Entitá, Lista)

Related WordNet synsets

listed: on a list

See more related synsets on a separate page.

Axioms (21)

Se e ? sono disgiunti e rel é un é membro di "(", allora rel é un' istanza di Relazione.

(=>
      (and
            (disjointRelation @ROW)
            (inList
                  ?REL
                  (ListFn @ROW)))
      (instance ?REL Relation))

Se e ? sono disgiunti e rel1 é un é membro di "(" e rel2 é un é membro di "(" e rel1 %&ha number argomento(s, allora rel2 %&ha number argomento(s.

(=>
      (and
            (disjointRelation @ROW)
            (inList
                  ?REL1
                  (ListFn @ROW))
            (inList
                  ?REL2
                  (ListFn @ROW))
            (valence ?REL1 ?NUMBER))
      (valence ?REL2 ?NUMBER))

Se e ? sono disgiunti e rel1 é un é membro di "(" e rel2 é un é membro di "(" e rel1 is not uguale a rel2 e rel1( vales, allora rel2( non vale.

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

se é opposto a ?,
allora se element é un é membro di "(", allora element é un' istanza di Attributo

(=>
      (contraryAttribute @ROW)
      (=>
            (inList
                  ?ELEMENT
                  (ListFn @ROW))
            (instance ?ELEMENT Attribute)))

se exhaustive attribute(class,) vale,
allora se attr é un é membro di "(", allora attr é un' istanza di Attributo

(=>
      (exhaustiveAttribute ?CLASS @ROW)
      (=>
            (inList
                  ?ATTR
                  (ListFn @ROW))
            (instance ?ATTR Attribute)))

se exhaustive attribute(class,) vale,
allora per ogni obj vale: se attr1 é un' istanza di class, allora esiste attr2 tale che attr2 é un é membro di "(" e attr1 is uguale a attr2

(=>
      (exhaustiveAttribute ?CLASS @ROW)
      (forall
            (?OBJ)
            (=>
                  (instance ?ATTR1 ?CLASS)
                  (exists
                        (?ATTR2)
                        (and
                              (inList
                                    ?ATTR2
                                    (ListFn @ROW))
                              (equal ?ATTR1 ?ATTR2))))))

se é coperto da ,
allora se element é un é membro di "(", allora element é un' istanza di Classe

(=>
      (exhaustiveDecomposition @ROW)
      (=>
            (inList
                  ?ELEMENT
                  (ListFn @ROW))
            (instance ?ELEMENT Class)))

se é scomposto disgiuntivamente in ,
allora se element é un é membro di "(", allora element é un' istanza di Classe

(=>
      (disjointDecomposition @ROW)
      (=>
            (inList
                  ?ELEMENT
                  (ListFn @ROW))
            (instance ?ELEMENT Class)))

Se rel é un' istanza di intentional relation e rel(agent, vales e obj é un é membro di "(", allora agent é interessato a obj.

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

list is uguale a null list se e solo se non esiste item tale che item é un é membro di list.

(<=>
      (equal ?LIST NullList)
      (not
            (exists
                  (?ITEM)
                  (inList ?ITEM ?LIST))))

se class é coperto da ,
allora per ogni obj vale: se obj é un' istanza di class, allora esiste item tale che item é un é membro di "(" e obj é un' istanza di item

(=>
      (exhaustiveDecomposition ?CLASS @ROW)
      (forall
            (?OBJ)
            (=>
                  (instance ?OBJ ?CLASS)
                  (exists
                        (?ITEM)
                        (and
                              (inList
                                    ?ITEM
                                    (ListFn @ROW))
                              (instance ?OBJ ?ITEM))))))

se class é scomposto disgiuntivamente in ,
allora per ogni item vale: se item é un é membro di "(", allora item é una sottoclasse di class

(=>
      (disjointDecomposition ?CLASS @ROW)
      (forall
            (?ITEM)
            (=>
                  (inList
                        ?ITEM
                        (ListFn @ROW))
                  (subclass ?ITEM ?CLASS))))

se class é scomposto disgiuntivamente in ,
allora per ogni item1,item2 vale: se item1 é un é membro di "(" e item2 é un é membro di "(" e item1 is not uguale a item2, allora item1 é disgiunto da item2

(=>
      (disjointDecomposition ?CLASS @ROW)
      (forall
            (?ITEM1 ?ITEM2)
            (=>
                  (and
                        (inList
                              ?ITEM1
                              (ListFn @ROW))
                        (inList
                              ?ITEM2
                              (ListFn @ROW))
                        (not
                              (equal ?ITEM1 ?ITEM2)))
                  (disjoint ?ITEM1 ?ITEM2))))

item é un é membro di list se e solo se esiste number tale che "numberth elemento di list" is uguale a item.

(<=>
      (inList ?ITEM ?LIST)
      (exists
            (?NUMBER)
            (equal
                  (ListOrderFn ?LIST ?NUMBER)
                  ?ITEM)))

se list1 é una sottolista di list2,
allora per ogni item vale: se item é un é membro di list1, allora item é un é membro di list2

(=>
      (subList ?LIST1 ?LIST2)
      (forall
            (?ITEM)
            (=>
                  (inList ?ITEM ?LIST1)
                  (inList ?ITEM ?LIST2))))

se list1 é una sottolista di list2,
allora esiste number3 tale che per ogni item vale: se item é un é membro di list1, allora esiste number1,number2 tale che "number1th elemento di list1" is uguale a item e "number2th elemento di list2" is uguale a item e number2 is uguale a "(number1+number3"

(=>
      (subList ?LIST1 ?LIST2)
      (exists
            (?NUMBER3)
            (forall
                  (?ITEM)
                  (=>
                        (inList ?ITEM ?LIST1)
                        (exists
                              (?NUMBER1 ?NUMBER2)
                              (and
                                    (equal
                                          (ListOrderFn ?LIST1 ?NUMBER1)
                                          ?ITEM)
                                    (equal
                                          (ListOrderFn ?LIST2 ?NUMBER2)
                                          ?ITEM)
                                    (equal
                                          ?NUMBER2
                                          (AdditionFn ?NUMBER1 ?NUMBER3))))))))

se "il massimo comune divisore di" is uguale a number,
allora per ogni element vale: se element é un é membro di "(", allora "element mod number" is uguale a

(=>
      (equal
            (GreatestCommonDivisorFn @ROW)
            ?NUMBER)
      (forall
            (?ELEMENT)
            (=>
                  (inList
                        ?ELEMENT
                        (ListFn @ROW))
                  (equal
                        (RemainderFn ?ELEMENT ?NUMBER)
                        0))))

se "il massimo comune divisore di" is uguale a number,
allora non esiste greater tale che greater é più grande di number e per ogni element vale: se element é un é membro di "(", allora "element mod greater" is uguale a

(=>
      (equal
            (GreatestCommonDivisorFn @ROW)
            ?NUMBER)
      (not
            (exists
                  (?GREATER)
                  (and
                        (greaterThan ?GREATER ?NUMBER)
                        (forall
                              (?ELEMENT)
                              (=>
                                    (inList
                                          ?ELEMENT
                                          (ListFn @ROW))
                                    (equal
                                          (RemainderFn ?ELEMENT ?GREATER)
                                          0)))))))

se "il minimo comune multiplo di " is uguale a number,
allora per ogni element vale: se element é un é membro di "(", allora "number mod element" is uguale a

(=>
      (equal
            (LeastCommonMultipleFn @ROW)
            ?NUMBER)
      (forall
            (?ELEMENT)
            (=>
                  (inList
                        ?ELEMENT
                        (ListFn @ROW))
                  (equal
                        (RemainderFn ?NUMBER ?ELEMENT)
                        0))))

se "il minimo comune multiplo di " is uguale a number,
allora non esiste less tale che less é meno dinumber e per ogni element vale: se element é un é membro di "(", allora "less mod element" is uguale a

(=>
      (equal
            (LeastCommonMultipleFn @ROW)
            ?NUMBER)
      (not
            (exists
                  (?LESS)
                  (and
                        (lessThan ?LESS ?NUMBER)
                        (forall
                              (?ELEMENT)
                              (=>
                                    (inList
                                          ?ELEMENT
                                          (ListFn @ROW))
                                    (equal
                                          (RemainderFn ?LESS ?ELEMENT)
                                          0)))))))

Se obj1 é attr1 a obj2 e é opposto a ? e attr1 é un é membro di "(" e attr2 é un é membro di "(" e attr1 is not uguale a attr2, allora obj1 é not attr2 a obj2.

(=>
      (and
            (orientation ?OBJ1 ?OBJ2 ?ATTR1)
            (contraryAttribute @ROW)
            (inList
                  ?ATTR1
                  (ListFn @ROW))
            (inList
                  ?ATTR2
                  (ListFn @ROW))
            (not
                  (equal ?ATTR1 ?ATTR2)))
      (not
            (orientation ?OBJ1 ?OBJ2 ?ATTR2)))