kleinerAls (lessThan)

(lessThan number1 number2) is true just in case the Quantity number1 is less than the Quantity number2.

Ontology

SUMO / BASE-ONTOLOGY

Class(es)

Kategorie

inheritable relation

zweistellige Prädikat
is instance of

transitive Relation
is instance of

irreflexive Relation
is instance of

Kategorie

inheritable relation

Relation erweitert auf Quantitäten
is instance of

kleinerAls

Coordinate term(s)

AdditionFn RückseiteFn DivisionFn ExponentiationFn FrontseiteFn MaximumFn MinumumFn MultiplikationFn ReziprokerWert RestFn RundFn SubtraktionFn arctusGewicht attribut schreibt vor vorOderGleichzeitig verursacht causes subclass bürger aufgeschlossen 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 beendet frequenz graphenTeil grösserAls grösserAlsOderGleich hatZweck hatFähigkeit hältWährend hatVerpflichtung hatRecht loch identitätsElement inListe imBereichInteresses vergrössertWahrscheinlichkeit Unabhänigkeitswahrscheinlichkeit wohnt hemmt ausgangsList fall innenteil umkehrFunktion irreflexivAur grösser kleinerAlsOderGleich weise material mass schliesstRäumlichAn schliesstZeitlichAn modalesAttribute decktSichTeilweise decktSichZeitlich elternteil teilweiseEinrichtung befindetSichTeils pfadLänge besitzt vorbedingung verhindert korrektesTeil eigenschaft veröffentlicht &%bildbereich von %1 ist ein fall von %2 {nicht} bildbereichTeilkategorie 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 zeitlichesTeil zeit gesamteinrichtung trichotomizierungAuf verwendet valenz version

Type restrictions

lessThan(Eigenschaft, Eigenschaft)

Related WordNet synsets

less: smaller in amount or degree: "the less I see of you the better"; "people have lost their heads for less"

See more related synsets on a separate page.

Axioms (21)

kleinerAls ist eine trichotomizierung auf reelle Zahl .

(trichotomizingOn lessThan RealNumber)

grösserAls ist eine inverse von kleinerAls .

(inverse greaterThan lessThan)

number1 ist kleinerAlsOderGleich number2 nur wenn number1 ist gleich number2 oder number1 ist kleinerAls number2 .

(<=>
      (lessThanOrEqualTo ?NUMBER1 ?NUMBER2)
      (or
            (equal ?NUMBER1 ?NUMBER2)
            (lessThan ?NUMBER1 ?NUMBER2)))

number ist ein fall von negative reelle Zahl nur wenn number ist kleinerAls und number ist ein fall von reelle Zahl .

(<=>
      (instance ?NUMBER NegativeRealNumber)
      (and
            (lessThan ?NUMBER 0)
            (instance ?NUMBER RealNumber)))

rel ist ein fall von totalwertige Relation nur wenn es gibt ein valence der rel ist ein fall von Relation und rel hat valence argument(e) und

wenn für jeden number,element,class gilt: wenn number ist kleinerAls valence und die Zahl number Argument von rel ist ein fall von class und element ist gleich "numberte mitglied von "()"" , dann element ist ein fall von class ,
dann es gibt ein item der rel(,item) gilt

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

Wenn formula1 verringert die Wahrscheinlichkeit von formula2 und "die wahrscheinlichkeit von formula2" ist gleich number1 und Gesetzt den Fall, dass formula2 gilt, ist die wahrscheinlichkeit von formula1 number2, dann number2 ist kleinerAls number1 .

(=>
      (and
            (decreasesLikelihood ?FORMULA1 ?FORMULA2)
            (equal
                  (ProbabilityFn ?FORMULA2)
                  ?NUMBER1)
            (conditionalProbability ?FORMULA1 ?FORMULA2 ?NUMBER2))
      (lessThan ?NUMBER2 ?NUMBER1))

wenn list ist ein fall von Liste ,
dann es gibt ein number1 der es gibt ein item1 der "number1te mitglied von list" ist gleich item1 nicht und für jeden number2 gilt: wenn number2 ist ein fall von positive Ganzzahl und number2 ist kleinerAls number1 , dann es gibt ein item2 der "number2te mitglied von list" ist gleich item2

(=>
      (instance ?LIST List)
      (exists
            (?NUMBER1)
            (exists
                  (?ITEM1)
                  (and
                        (not
                              (equal
                                    (ListOrderFn ?LIST ?NUMBER1)
                                    ?ITEM1))
                        (forall
                              (?NUMBER2)
                              (=>
                                    (and
                                          (instance ?NUMBER2 PositiveInteger)
                                          (lessThan ?NUMBER2 ?NUMBER1))
                                    (exists
                                          (?ITEM2)
                                          (equal
                                                (ListOrderFn ?LIST ?NUMBER2)
                                                ?ITEM2))))))))

Wenn "die oberstegrenze von number" ist gleich int , dann es gibt kein Ganzzahl otherint der otherint ist grösserAlsOderGleich number und otherint ist kleinerAls int .

(=>
      (equal
            (CeilingFn ?NUMBER)
            ?INT)
      (not
            (exists
                  (?OTHERINT)
                  (and
                        (instance ?OTHERINT Integer)
                        (greaterThanOrEqualTo ?OTHERINT ?NUMBER)
                        (lessThan ?OTHERINT ?INT)))))

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 "das kleinere von number1 und number2" ist gleich number , dann

number ist gleich number1 und number1 ist kleinerAls number2
number ist gleich number2 und number2 ist kleinerAls number1
number ist gleich number1 und number ist gleich number2

(=>
      (equal
            (MinFn ?NUMBER1 ?NUMBER2)
            ?NUMBER)
      (or
            (and
                  (equal ?NUMBER ?NUMBER1)
                  (lessThan ?NUMBER1 ?NUMBER2))
            (and
                  (equal ?NUMBER ?NUMBER2)
                  (lessThan ?NUMBER2 ?NUMBER1))
            (and
                  (equal ?NUMBER ?NUMBER1)
                  (equal ?NUMBER ?NUMBER2))))

wenn "number1 gerundet" ist gleich number2 ,
dann
- wenn "(number1-"die grösste Ganzzahl kleiner als oder Gleichgestelltes zu number1")" ist kleinerAls , dann number2 ist gleich "die grösste Ganzzahl kleiner als oder Gleichgestelltes zu number1"
- wenn "(number1-"die grösste Ganzzahl kleiner als oder Gleichgestelltes zu number1")" ist grösserAlsOderGleich , dann number2 ist gleich "die oberstegrenze von number1"

(=>
      (equal
            (RoundFn ?NUMBER1)
            ?NUMBER2)
      (or
            (=>
                  (lessThan
                        (SubtractionFn
                              ?NUMBER1
                              (FloorFn ?NUMBER1))
                        0.5)
                  (equal
                        ?NUMBER2
                        (FloorFn ?NUMBER1)))
            (=>
                  (greaterThanOrEqualTo
                        (SubtractionFn
                              ?NUMBER1
                              (FloorFn ?NUMBER1))
                        0.5)
                  (equal
                        ?NUMBER2
                        (CeilingFn ?NUMBER1)))))

Wenn int ist ein fall von Ganzzahl , dann int ist kleinerAls "(int+1)" .

(=>
      (instance ?INT Integer)
      (lessThan
            ?INT
            (SuccessorFn ?INT)))

Wenn int1 ist ein fall von Ganzzahl und int2 ist ein fall von Ganzzahl , dann int1 ist kleinerAls int2 nicht oder int2 ist kleinerAls "(int1+1)" nicht.

(=>
      (and
            (instance ?INT1 Integer)
            (instance ?INT2 Integer))
      (not
            (and
                  (lessThan ?INT1 ?INT2)
                  (lessThan
                        ?INT2
                        (SuccessorFn ?INT1)))))

Wenn int1 ist ein fall von Ganzzahl und int2 ist ein fall von Ganzzahl , dann int2 ist kleinerAls int1 nicht oder "(int1+2)" ist kleinerAls int2 nicht.

(=>
      (and
            (instance ?INT1 Integer)
            (instance ?INT2 Integer))
      (not
            (and
                  (lessThan ?INT2 ?INT1)
                  (lessThan
                        (PredecessorFn ?INT1)
                        ?INT2))))

Es gibt kein die menge von Pfaden die graph in zwei verschiedene Graphen schnitten path1,die menge von minimalen Pfaden die graph in zwei verschiedene Graphen schnitten path2 der die länge von path1 ist number1 und die länge von path2 ist number2 und number1 ist kleinerAls number2 .

(not
      (exists
            (?PATH1 ?PATH2)
            (and
                  (instance
                        ?PATH1
                        (CutSetFn ?GRAPH))
                  (instance
                        ?PATH2
                        (MinimalCutSetFn ?GRAPH))
                  (pathLength ?PATH1 ?NUMBER1)
                  (pathLength ?PATH2 ?NUMBER2)
                  (lessThan ?NUMBER1 ?NUMBER2))))

Wenn hour ist ein fall von "die stunde number" , dann number ist kleinerAls .

(=>
      (instance
            ?HOUR
            (HourFn ?NUMBER ?DAY))
      (lessThan ?NUMBER 24))

Wenn minute ist ein fall von "die minute number" , dann number ist kleinerAls .

(=>
      (instance
            ?MINUTE
            (MinuteFn ?NUMBER ?HOUR))
      (lessThan ?NUMBER 60))

Wenn second ist ein fall von "die sekund number" , dann number ist kleinerAls .

(=>
      (instance
            ?SECOND
            (SecondFn ?NUMBER ?MINUTE))
      (lessThan ?NUMBER 60))

Wenn decrease ist ein fall von Abnehmen und obj ist ein patient von decrease , dann es gibt ein unit,quant1,quant2 der ""obj unit(s)" ist gleich quant1 " hält während "direkt vor "die zeit des Bestehens von decrease"" und ""obj unit(s)" ist gleich quant2 " hält während "sofort nach "die zeit des Bestehens von decrease"" und quant2 ist kleinerAls quant1 .

(=>
      (and
            (instance ?DECREASE Decreasing)
            (patient ?DECREASE ?OBJ))
      (exists
            (?UNIT ?QUANT1 ?QUANT2)
            (and
                  (holdsDuring
                        (ImmediatePastFn
                              (WhenFn ?DECREASE))
                        (equal
                              (MeasureFn ?OBJ ?UNIT)
                              ?QUANT1))
                  (holdsDuring
                        (ImmediateFutureFn
                              (WhenFn ?DECREASE))
                        (equal
                              (MeasureFn ?OBJ ?UNIT)
                              ?QUANT2))
                  (lessThan ?QUANT2 ?QUANT1))))

Wenn cool ist ein fall von Abkühlen und obj ist ein patient von cool , dann es gibt ein Temperaturmass unit,quant1,quant2 der ""obj unit(s)" ist gleich quant1 " hält während "direkt vor "die zeit des Bestehens von cool"" und ""obj unit(s)" ist gleich quant2 " hält während "sofort nach "die zeit des Bestehens von cool"" und quant2 ist kleinerAls quant1 .

(=>
      (and
            (instance ?COOL Cooling)
            (patient ?COOL ?OBJ))
      (exists
            (?UNIT ?QUANT1 ?QUANT2)
            (and
                  (instance ?UNIT TemperatureMeasure)
                  (holdsDuring
                        (ImmediatePastFn
                              (WhenFn ?COOL))
                        (equal
                              (MeasureFn ?OBJ ?UNIT)
                              ?QUANT1))
                  (holdsDuring
                        (ImmediateFutureFn
                              (WhenFn ?COOL))
                        (equal
                              (MeasureFn ?OBJ ?UNIT)
                              ?QUANT2))
                  (lessThan ?QUANT2 ?QUANT1))))

wenn
- path1 ist der pfad entlang dem process geschieht
- process beginnet an source
- process endet an dest
- die länge von path1 ist measure1
- es gibt kein path2,measure2 der path2 ist der pfad entlang dem process geschieht und process beginnet an origin und process endet an dest und die länge von path2 ist measure2 und measure2 ist kleinerAls measure1
,
dann für jeden obj gilt: wenn obj ist ein teil von path1 , dann obj ist zwischen source und dest

(=>
      (and
            (path ?PROCESS ?PATH1)
            (origin ?PROCESS ?SOURCE)
            (destination ?PROCESS ?DEST)
            (length ?PATH1 ?MEASURE1)
            (not
                  (exists
                        (?PATH2 ?MEASURE2)
                        (and
                              (path ?PROCESS ?PATH2)
                              (origin ?PROCESS ?ORIGIN)
                              (destination ?PROCESS ?DEST)
                              (length ?PATH2 ?MEASURE2)
                              (lessThan ?MEASURE2 ?MEASURE1)))))
      (forall
            (?OBJ)
            (=>
                  (part ?OBJ ?PATH1)
                  (between ?SOURCE ?OBJ ?DEST))))