less than (lessThan)

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

Ontology

SUMO / BASE-ONTOLOGY

Class(es)

varga

inheritable relation

dvi-lakshana
is instance of

sakarmaka sambandha
is instance of

anaatmavaachaka sambandha
is instance of

varga

inheritable relation

matraaon kaa sanbandha vistaara
is instance of

less than

Coordinate term(s)

addition fn back fn division fn exponentiation fn front fn max fn min fn multiplication fn reciprocal fn remainder fn round fn subtraction fn arc weight attribute authors before before or equal causes causes subclass citizen closed on 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 finishes frequency graph part greater than greater than or equal to has purpose has skill holds during holds obligation holds right hole identity element in list in scope of interest increases likelihood independent probability inhabits inhibits initial list instance interior part inverse irreflexive on larger less than or equal to manner material measure meets spatially meets temporally modal attribute overlaps partially overlaps temporally parent partial ordering on partly located path length possesses precondition prevents proper part property publishes range range subclass 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 temporal part time total ordering on trichotomizing on uses valence version

Type restrictions

lessThan(parimaaNa, parimaaNa)

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)

less than is trichotomizing on vaastavika anka.

(trichotomizingOn lessThan RealNumber)

greater than is an inverse of less than.

(inverse greaterThan lessThan)

number1 is less than or equal to number2 agar hai number1 is equal to number2 yaa number1 is less than number2.

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

number is an instance of Qnaatmaka vaastavika anka agar hai number is less than aur number is an instance of vaastavika anka.

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

rel is an instance of pUrNa mUlyaadeya sambandha agar hai yah kuch valence nahin, ki rel is an instance of sambandha aur rel ke valence konaanke bahanen hai aur

agar sab-kuch number,element,class ke lie hai, ki: agar number is less than valence aur the number number argument of rel is an instance of class aur element is equal to "numberth element of "()"", to element is an instance of class,
to yah kuch item nahin, ki 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))))))

Agar formula1 decreases likelihood of formula2 aur "the probability of formula2" is equal to number1 aur basharte ki formula2 ho rahaa hai, formula1 kii sambhaavaanaa number2 ho., to number2 is less than number1.

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

agar list is an instance of sUchI,
to yah kuch number1 nahin, ki yah kuch item1 nahin, ki "number1th element of list" is not equal to item1 aur sab-kuch number2 ke lie hai, ki: agar number2 is an instance of dhanaatmaka pUrNaanka aur number2 is less than number1, to yah kuch item2 nahin, ki "number2th element of list" is equal to 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))))))))

Agar "the ceiling of number" is equal to int, to yah kuch pUrNaanka otherint nahin, ki otherint is greater than or equal to number aur otherint is less than int.

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

agar "the least common multiple of " is equal to number,
to yah kuch less nahin, ki less is less than number aur sab-kuch element ke lie hai, ki: agar element is a member of "()", to "less mod element" is equal to

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

Agar "the smaller of number1 and number2" is equal to number, to

number is equal to number1 aur number1 is less than number2
number is equal to number2 aur number2 is less than number1
number is equal to number1 aur number is equal to 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))))

agar "number1 rounded" is equal to number2,
to
- agar "(number1-"the largest integer less than or equal to number1")" is less than , to number2 is equal to "the largest integer less than or equal to number1"
- agar "(number1-"the largest integer less than or equal to number1")" is greater than or equal to , to number2 is equal to "the ceiling of 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)))))

Agar int is an instance of pUrNaanka, to int is less than "(int+1)".

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

Agar int1 is an instance of pUrNaanka aur int2 is an instance of pUrNaanka, to int1 is not less than int2 yaa int2 is not less than "(int1+1)".

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

Agar int1 is an instance of pUrNaanka aur int2 is an instance of pUrNaanka, to int2 is not less than int1 yaa "(int1+2)" is not less than int2.

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

Yah kuch the set of paths that partition graph into two separate graphs path1,the set of minimal paths that partition graph into two separate graphs path2 nahin, ki the length of path1 is number1 aur the length of path2 is number2 aur number1 is less than number2.

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

Agar hour is an instance of "the hour number", to number is less than .

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

Agar minute is an instance of "the minute number", to number is less than .

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

Agar second is an instance of "the second number", to number is less than .

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

Agar decrease is an instance of hraasa aur obj is a patient of decrease, to yah kuch unit,quant1,quant2 nahin, ki "obj unit(s)" is equal to quant1 immediately before "the time of existence of decrease" aur "obj unit(s)" is equal to quant2 immediately after "the time of existence of decrease" aur quant2 is less than 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))))

Agar cool is an instance of shiitalataa aur obj is a patient of cool, to yah kuch taapa maapa unit,quant1,quant2 nahin, ki "obj unit(s)" is equal to quant1 immediately before "the time of existence of cool" aur "obj unit(s)" is equal to quant2 immediately after "the time of existence of cool" aur quant2 is less than 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))))

agar
- path1 is path along with process occurs
- process origins at source
- process ends at dest
- the length of path1 is measure1
- yah kuch path2,measure2 nahin, ki path2 is path along with process occurs aur process origins at origin aur process ends at dest aur the length of path2 is measure2 aur measure2 is less than measure1
,
to sab-kuch obj ke lie hai, ki: agar obj is a part of path1, to source aur dest ke biich main obj hai

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