inListe (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)

Kategorie

inheritable relation

zweistellige Prädikat
is instance of

irreflexive Relation
is instance of

asymmetrische Relation
is instance of

inListe

Coordinate term(s)

RückseiteFn KardinalitätFn FrontseiteFn HauptwirtFn Wahrscheinlichkeit OberflächeFn arctusGewicht attribut schreibt vor vorOderGleichzeitig verursacht causes subclass bürger aufgeschlossen fülltVollständig angeschlossen angeschlosseneTechnikKomponenten enthältInformationen zusammenGeschiecht kopie kreuzt datum verringertWahrscheinlichkeit entwicklungsForm disjunkt istDistributiv dokumentation &%dauer von %1 ist %2 %n{nicht} während früh herausgeber element beschäftigt %1 ist gleich %2 %n{nicht} äquivalenzrelationMit nutztAus inSpracheAusgedrückt stelltGegenüber verwandt füllt beendet frequenz graphenTeil grösserAls grösserAlsOderGleich hatZweck hatFähigkeit hältWährend hatVerpflichtung hatRecht loch identitätsElement direkterFall direckteTeilkategorie imBereichInteresses vergrössertWahrscheinlichkeit Unabhänigkeitswahrscheinlichkeit wohnt hemmt ausgangsList fall innenteil umkehrFunktion irreflexivAur grösser kleinerAls kleinerAlsOderGleich weise material mass schliesstRäumlichAn schliesstZeitlichAn mitglied modalesAttribute decktSichTeilweise decktSichZeitlich elternteil teilweiseEinrichtung fülltTeilweise befindetSichTeils pfadLänge dringtEin besitzt vorbedingung verhindert korrektesTeil fülltRichtig eigenschaft veröffentlicht &%bildbereich von %1 ist ein fall von %2 {nicht} bildbereichTeilkategorie realizierung beziehtSichAuf reflexivAuf verwandtesInnenkonzept geschwister kleiner beginnt teilAttribut teilsammlung teilGraph teilliste unterOrganisation teilplan subProzess %1 ist eine &%teilangelegenheit von %2 %n{nicht} teilkategorie teilrelation fasstInhaltsKategorieZusammen fasstInhaltsFallZusammen nachfolgerAttribut nachfolgerAttributSchliessung oberflächichesTeil fläche zeitlichesTeil zeit gesamteinrichtung trichotomizierungAuf verwendet valenz version

Type restrictions

inList(Wesen, Liste)

Related WordNet synsets

listed: on a list

See more related synsets on a separate page.

Axioms (21)

Wenn und ? werden disjunkt und rel ist ein Mitglied von "()", dann rel ist ein fall von Relation .

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

Wenn und ? werden disjunkt und rel1 ist ein Mitglied von "()" und rel2 ist ein Mitglied von "()" und rel1 hat number argument(e), dann rel2 hat number argument(e).

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

Wenn und ? werden disjunkt und rel1 ist ein Mitglied von "()" und rel2 ist ein Mitglied von "()" und rel1 ist gleich rel2 nicht und rel1() gilt , dann rel2() gilt nicht.

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

wenn wird ? entgegengesetzet ,
dann wenn element ist ein Mitglied von "()", dann element ist ein fall von Attribut

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

wenn exhaustive attribute(class,) gilt,
dann wenn attr ist ein Mitglied von "()", dann attr ist ein fall von Attribut

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

wenn exhaustive attribute(class,) gilt,
dann für jeden obj gilt: wenn attr1 ist ein fall von class , dann es gibt ein attr2 der attr2 ist ein Mitglied von "()" und attr1 ist gleich attr2

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

wenn wird mit behandelt,
dann wenn element ist ein Mitglied von "()", dann element ist ein fall von Kategorie

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

wenn wird zusammenhanglos auf disjunkt,
dann wenn element ist ein Mitglied von "()", dann element ist ein fall von Kategorie

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

Wenn rel ist ein fall von intentional relation und rel(agent,) gilt und obj ist ein Mitglied von "()", dann agent ist an obj interessiert .

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

list ist gleich null list nur wenn es gibt kein item der item ist ein Mitglied von list.

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

wenn class wird mit behandelt,
dann für jeden obj gilt: wenn obj ist ein fall von class , dann es gibt ein item der item ist ein Mitglied von "()" und obj ist ein fall von item

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

wenn class wird zusammenhanglos auf disjunkt,
dann für jeden item gilt: wenn item ist ein Mitglied von "()", dann item ist eine teilkategorie von class

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

wenn class wird zusammenhanglos auf disjunkt,
dann für jeden item1,item2 gilt: wenn item1 ist ein Mitglied von "()" und item2 ist ein Mitglied von "()" und item1 ist gleich item2 nicht, dann item1 ist dijunkt von item2

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

item ist ein Mitglied von list nur wenn es gibt ein number der "numberte mitglied von list" ist gleich item .

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

wenn list1 ist eine teilliste von list2 ,
dann für jeden item gilt: wenn item ist ein Mitglied von list1, dann item ist ein Mitglied von list2

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

wenn list1 ist eine teilliste von list2 ,
dann es gibt ein number3 der für jeden item gilt: wenn item ist ein Mitglied von list1, dann es gibt ein number1,number2 der "number1te mitglied von list1" ist gleich item und "number2te mitglied von list2" ist gleich item und number2 ist gleich "(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))))))))

wenn "die größte gemeinsamer teiler von " ist gleich number ,
dann für jeden element gilt: wenn element ist ein Mitglied von "()", dann "element betrag number" ist gleich

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

wenn "die größte gemeinsamer teiler von " ist gleich number ,
dann es gibt kein greater der greater ist grösserAls number und für jeden element gilt: wenn element ist ein Mitglied von "()", dann "element betrag greater" ist gleich

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

wenn "das kleinste gemeinsames vielfach von " ist gleich number ,
dann für jeden element gilt: wenn element ist ein Mitglied von "()", dann "number betrag element" ist gleich

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

wenn "das kleinste gemeinsames vielfach von " ist gleich number ,
dann es gibt kein less der less ist kleinerAls number und für jeden element gilt: wenn element ist ein Mitglied von "()", dann "less betrag element" ist gleich

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

Wenn obj1 ist attr1 hinsichlich obj2 und wird ? entgegengesetzet und attr1 ist ein Mitglied von "()" und attr2 ist ein Mitglied von "()" und attr1 ist gleich attr2 nicht, dann obj1 ist attr2 hinsichlich obj2 nicht.

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