Wählen Sie Sprache: english | cesky | deutsch | italiano | simplified chinese | traditional chinese | hindi Concept: English word: Home

# MassFn (MeasureFn)

This BinaryFunction maps a RealNumber and a UnitOfMeasure to that Number of units. It is used for expressing ConstantQuantities. For example, the concept of three meters is represented as (MeasureFn 3 Meter).

## Ontology

SUMO / UNITS-OF-MEASURE

## Class(es)

 Kategorie

inheritable relation

zweistellige Funktion

MassFn

## Coordinate term(s)

AdditionFn  TagFn  DichteFn  DivisionFn  AusgabeFn  ExponentiationFn  GraphPfadFn  StundeFn  DurchschnittFn  AbstandFn  KappaFn  ListeVerkettenFn  ListeOrdnungFn  LogarithmusFn  MaximumFn  MaximalerBelasteterPfadFn  MereologischeDifferenzFn  MereologischesProduktFn  MereologischeSummeFn  MinumumFn  MinimalerBelasteterPfadFn  MinuteFn  MonatFn  MultiplikationFn  PeriodikumAusgabeFn  RückläufigeZeitAbstandFn  RelativeErgänzungFn  RelativeZeitFn  RestFn  SekundFn  ReiheBandeFn  GeschwindigkeitFn  SubtraktionFn  ZeitlicheAufbauFn  ZeitabstandFn  VereinigungFn  WoFn

## Type restrictions

konstante Quantität MeasureFn(reelle Zahl, Masseinheit)

## Axioms (71)

Wenn "number unit(s)" ist gleich quant und unit ist eine teilkategorie von quanttype, dann quant ist ein fall von quanttype .
```(=>
(and
(equal
(MeasureFn ?NUMBER ?UNIT)
?QUANT)
(subclass ?UNIT ?QUANTTYPE))
(instance ?QUANT ?QUANTTYPE))```

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

Wenn unit ist ein fall von Masseinheit , dann "1 tausend unit" ist gleich " unit(s)" .
```(=>
(instance ?UNIT UnitOfMeasure)
(equal
(KiloFn ?UNIT)
(MeasureFn 1000 ?UNIT)))```

Wenn unit ist ein fall von Masseinheit , dann "1 million unit" ist gleich " unit(s)" .
```(=>
(instance ?UNIT UnitOfMeasure)
(equal
(MegaFn ?UNIT)
(MeasureFn 1000000 ?UNIT)))```

Wenn unit ist ein fall von Masseinheit , dann "1 milliarde unit" ist gleich " unit(s)" .
```(=>
(instance ?UNIT UnitOfMeasure)
(equal
(GigaFn ?UNIT)
(MeasureFn 1000000000 ?UNIT)))```

Wenn unit ist ein fall von Masseinheit , dann "1 trillion unit" ist gleich " unit(s)" .
```(=>
(instance ?UNIT UnitOfMeasure)
(equal
(TeraFn ?UNIT)
(MeasureFn 1000000000000 ?UNIT)))```

Wenn unit ist ein fall von Masseinheit , dann "ein tausendstes einer unit" ist gleich " unit(s)" .
```(=>
(instance ?UNIT UnitOfMeasure)
(equal
(MilliFn ?UNIT)
(MeasureFn 0.001 ?UNIT)))```

Wenn unit ist ein fall von Masseinheit , dann "ein millionstel einer unit" ist gleich " unit(s)" .
```(=>
(instance ?UNIT UnitOfMeasure)
(equal
(MicroFn ?UNIT)
(MeasureFn 0.000001 ?UNIT)))```

Wenn unit ist ein fall von Masseinheit , dann "ein milliardstel einer unit" ist gleich " unit(s)" .
```(=>
(instance ?UNIT UnitOfMeasure)
(equal
(NanoFn ?UNIT)
(MeasureFn 0.000000001 ?UNIT)))```

Wenn unit ist ein fall von Masseinheit , dann "ein trillionstel einer unit" ist gleich " unit(s)" .
```(=>
(instance ?UNIT UnitOfMeasure)
(equal
(PicoFn ?UNIT)
(MeasureFn 0.000000000001 ?UNIT)))```

Wenn number ist ein fall von reelle Zahl und unit ist ein fall von Masseinheit , dann "die grösse von "number unit(s)"" ist gleich number .
```(=>
(and
(instance ?NUMBER RealNumber)
(instance ?UNIT UnitOfMeasure))
(equal
(MagnitudeFn
(MeasureFn ?NUMBER ?UNIT))
?NUMBER))```

Wenn number ist ein fall von reelle Zahl , dann "number centimeter(s)" ist gleich ""number*" meter(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Centimeter)
(MeasureFn
(MultiplicationFn ?NUMBER 0.01)
Meter)))```

Wenn number ist ein fall von reelle Zahl , dann "number celsius degree(s)" ist gleich ""(number-)" kelvin degree(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER CelsiusDegree)
(MeasureFn
(SubtractionFn ?NUMBER 273.15)
KelvinDegree)))```

Wenn number ist ein fall von reelle Zahl , dann "number celsius degree(s)" ist gleich """(number-)"/" fahrenheit degree(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER CelsiusDegree)
(MeasureFn
(DivisionFn
(SubtractionFn ?NUMBER 32)
1.8)
FahrenheitDegree)))```

Wenn number ist ein fall von reelle Zahl , dann "number day duration(s)" ist gleich ""number*" hour duration(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER DayDuration)
(MeasureFn
(MultiplicationFn ?NUMBER 24)
HourDuration)))```

Wenn number ist ein fall von reelle Zahl , dann "number hour duration(s)" ist gleich ""number*" minute duration(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER HourDuration)
(MeasureFn
(MultiplicationFn ?NUMBER 60)
MinuteDuration)))```

Wenn number ist ein fall von reelle Zahl , dann "number minute duration(s)" ist gleich ""number*" second duration(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER MinuteDuration)
(MeasureFn
(MultiplicationFn ?NUMBER 60)
SecondDuration)))```

Wenn number ist ein fall von reelle Zahl , dann "number week duration(s)" ist gleich ""number*" day duration(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER WeekDuration)
(MeasureFn
(MultiplicationFn ?NUMBER 7)
DayDuration)))```

Wenn number ist ein fall von reelle Zahl , dann "number year duration(s)" ist gleich ""number*" day duration(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER YearDuration)
(MeasureFn
(MultiplicationFn ?NUMBER 365)
DayDuration)))```

Wenn number ist ein fall von reelle Zahl , dann "number amu(s)" ist gleich ""number**" gram(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Amu)
(MeasureFn
(MultiplicationFn ?NUMBER 1.6605402 E-24)
Gram)))```

Wenn number ist ein fall von reelle Zahl , dann "number electron volt(s)" ist gleich ""number**" joule(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER ElectronVolt)
(MeasureFn
(MultiplicationFn ?NUMBER 1.60217733 E-19)
Joule)))```

Wenn number ist ein fall von reelle Zahl , dann "number angstrom(s)" ist gleich ""number**" meter(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Angstrom)
(MeasureFn
(MultiplicationFn ?NUMBER 1.0 E-10)
Meter)))```

Wenn number ist ein fall von reelle Zahl , dann "number foot(s)" ist gleich ""number*" meter(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Foot)
(MeasureFn
(MultiplicationFn ?NUMBER 0.3048)
Meter)))```

Wenn number ist ein fall von reelle Zahl , dann "number inch(s)" ist gleich ""number*" meter(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Inch)
(MeasureFn
(MultiplicationFn ?NUMBER 0.0254)
Meter)))```

Wenn number ist ein fall von reelle Zahl , dann "number mile(s)" ist gleich ""number*" meter(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Mile)
(MeasureFn
(MultiplicationFn ?NUMBER 1609.344)
Meter)))```

Wenn number ist ein fall von reelle Zahl , dann "number united states gallon(s)" ist gleich ""number*" liter(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER UnitedStatesGallon)
(MeasureFn
(MultiplicationFn ?NUMBER 3.785411784)
Liter)))```

Wenn number ist ein fall von reelle Zahl , dann "number quart(s)" ist gleich ""number/" united states gallon(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Quart)
(MeasureFn
(DivisionFn ?NUMBER 4)
UnitedStatesGallon)))```

Wenn number ist ein fall von reelle Zahl , dann "number pint(s)" ist gleich ""number/" quart(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Pint)
(MeasureFn
(DivisionFn ?NUMBER 2)
Quart)))```

Wenn number ist ein fall von reelle Zahl , dann "number cup(s)" ist gleich ""number/" pint(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Cup)
(MeasureFn
(DivisionFn ?NUMBER 2)
Pint)))```

Wenn number ist ein fall von reelle Zahl , dann "number ounce(s)" ist gleich ""number/" cup(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Ounce)
(MeasureFn
(DivisionFn ?NUMBER 8)
Cup)))```

Wenn number ist ein fall von reelle Zahl , dann "number united kingdom gallon(s)" ist gleich ""number*" liter(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER UnitedKingdomGallon)
(MeasureFn
(MultiplicationFn ?NUMBER 4.54609)
Liter)))```

Wenn number ist ein fall von reelle Zahl , dann "number pound mass(s)" ist gleich ""number*" gram(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER PoundMass)
(MeasureFn
(MultiplicationFn ?NUMBER 453.59237)
Gram)))```

Wenn number ist ein fall von reelle Zahl , dann "number slug(s)" ist gleich ""number*" gram(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Slug)
(MeasureFn
(MultiplicationFn ?NUMBER 14593.90)
Gram)))```

Wenn number ist ein fall von reelle Zahl , dann "number rankine degree(s)" ist gleich ""number*" kelvin degree(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER RankineDegree)
(MeasureFn
(MultiplicationFn ?NUMBER 1.8)
KelvinDegree)))```

Wenn number ist ein fall von reelle Zahl , dann "number pound force(s)" ist gleich ""number*" newton(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER PoundForce)
(MeasureFn
(MultiplicationFn ?NUMBER 4.448222)
Newton)))```

Wenn number ist ein fall von reelle Zahl , dann "number calorie(s)" ist gleich ""number*" joule(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Calorie)
(MeasureFn
(MultiplicationFn ?NUMBER 4.1868)
Joule)))```

Wenn number ist ein fall von reelle Zahl , dann "number british thermal unit(s)" ist gleich ""number*" joule(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER BritishThermalUnit)
(MeasureFn
(MultiplicationFn ?NUMBER 1055.05585262)
Joule)))```

Wenn number ist ein fall von reelle Zahl , dann "number angular degree(s)" ist gleich ""number*"Pi/"" radian(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER AngularDegree)
(MeasureFn
(MultiplicationFn
?NUMBER
(DivisionFn Pi 180))

Wenn number ist ein fall von reelle Zahl , dann "number united states cent(s)" ist gleich ""number*" united states dollar(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER UnitedStatesCent)
(MeasureFn
(MultiplicationFn ?NUMBER 0.01)
UnitedStatesDollar)))```

Wenn number ist ein fall von reelle Zahl , dann "number euro cent(s)" ist gleich ""number*" euro dollar(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER EuroCent)
(MeasureFn
(MultiplicationFn ?NUMBER 0.01)
EuroDollar)))```

Wenn number ist ein fall von reelle Zahl , dann "number byte(s)" ist gleich ""number*" bit(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Byte)
(MeasureFn
(MultiplicationFn ?NUMBER 8)
Bit)))```

Wenn number ist ein fall von reelle Zahl , dann "number kilo byte(s)" ist gleich ""number*" byte(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER KiloByte)
(MeasureFn
(MultiplicationFn ?NUMBER 1024)
Byte)))```

Wenn number ist ein fall von reelle Zahl , dann "number mega byte(s)" ist gleich ""number*" kilo byte(s)" .
```(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER MegaByte)
(MeasureFn
(MultiplicationFn ?NUMBER 1024)
KiloByte)))```

```(=>
(larger ?OBJ1 ?OBJ2)
(forall
(?QUANT1 ?QUANT2)
(=>
(and
(measure
?OBJ1
(MeasureFn ?QUANT1 LengthMeasure))
(measure
?OBJ2
(MeasureFn ?QUANT2 LengthMeasure)))
(greaterThan ?QUANT1 ?QUANT2))))```

Wenn year ist ein fall von Jahr , dann dauer von year ist " year duration(s)" .
```(=>
(instance ?YEAR Year)
(duration
?YEAR
(MeasureFn 1 YearDuration)))```

Wenn leap ist ein fall von Schaltjahr und leap ist gleich "number Jahr(s)" , dann
• "number betrag " ist gleich und "number betrag " ist gleich nicht
• oder
• "number betrag " ist gleich
• .
```(=>
(and
(instance ?LEAP LeapYear)
(equal
?LEAP
(MeasureFn ?NUMBER Year)))
(or
(and
(equal
(RemainderFn ?NUMBER 4)
0)
(not
(equal
(RemainderFn ?NUMBER 100)
0)))
(equal
(RemainderFn ?NUMBER 400)
0)))```

Wenn month ist ein fall von Januar , dann dauer von month ist " day duration(s)" .
```(=>
(instance ?MONTH January)
(duration
?MONTH
(MeasureFn 31 DayDuration)))```

Wenn "der monat Februar" ist gleich month und year ist ein fall von Schaltjahr nicht, dann dauer von month ist " day duration(s)" .
```(=>
(and
(equal
(MonthFn February ?YEAR)
?MONTH)
(not
(instance ?YEAR LeapYear)))
(duration
?MONTH
(MeasureFn 28 DayDuration)))```

Wenn "der monat Februar" ist gleich month und year ist ein fall von Schaltjahr , dann dauer von month ist " day duration(s)" .
```(=>
(and
(equal
(MonthFn February ?YEAR)
?MONTH)
(instance ?YEAR LeapYear))
(duration
?MONTH
(MeasureFn 29 DayDuration)))```

Wenn month ist ein fall von März , dann dauer von month ist " day duration(s)" .
```(=>
(instance ?MONTH March)
(duration
?MONTH
(MeasureFn 31 DayDuration)))```

Wenn month ist ein fall von April , dann dauer von month ist " day duration(s)" .
```(=>
(instance ?MONTH April)
(duration
?MONTH
(MeasureFn 30 DayDuration)))```

Wenn month ist ein fall von Mai , dann dauer von month ist " day duration(s)" .
```(=>
(instance ?MONTH May)
(duration
?MONTH
(MeasureFn 31 DayDuration)))```

Wenn month ist ein fall von Juni , dann dauer von month ist " day duration(s)" .
```(=>
(instance ?MONTH June)
(duration
?MONTH
(MeasureFn 30 DayDuration)))```

Wenn month ist ein fall von Juli , dann dauer von month ist " day duration(s)" .
```(=>
(instance ?MONTH July)
(duration
?MONTH
(MeasureFn 31 DayDuration)))```

Wenn month ist ein fall von August , dann dauer von month ist " day duration(s)" .
```(=>
(instance ?MONTH August)
(duration
?MONTH
(MeasureFn 31 DayDuration)))```

Wenn month ist ein fall von September , dann dauer von month ist " day duration(s)" .
```(=>
(instance ?MONTH September)
(duration
?MONTH
(MeasureFn 30 DayDuration)))```

Wenn month ist ein fall von Oktober , dann dauer von month ist " day duration(s)" .
```(=>
(instance ?MONTH October)
(duration
?MONTH
(MeasureFn 31 DayDuration)))```

Wenn month ist ein fall von November , dann dauer von month ist " day duration(s)" .
```(=>
(instance ?MONTH November)
(duration
?MONTH
(MeasureFn 30 DayDuration)))```

Wenn month ist ein fall von Dezember , dann dauer von month ist " day duration(s)" .
```(=>
(instance ?MONTH December)
(duration
?MONTH
(MeasureFn 31 DayDuration)))```

Wenn day ist ein fall von Tag , dann dauer von day ist " day duration(s)" .
```(=>
(instance ?DAY Day)
(duration
?DAY
(MeasureFn 1 DayDuration)))```

Wenn week ist ein fall von Woche , dann dauer von week ist " week duration(s)" .
```(=>
(instance ?WEEK Week)
(duration
?WEEK
(MeasureFn 1 WeekDuration)))```

Wenn hour ist ein fall von Stunde , dann dauer von hour ist " hour duration(s)" .
```(=>
(instance ?HOUR Hour)
(duration
?HOUR
(MeasureFn 1 HourDuration)))```

Wenn minute ist ein fall von Minute , dann dauer von minute ist " minute duration(s)" .
```(=>
(instance ?MINUTE Minute)
(duration
?MINUTE
(MeasureFn 1 MinuteDuration)))```

Wenn second ist ein fall von Sekunde , dann dauer von second ist " second duration(s)" .
```(=>
(instance ?SECOND Second)
(duration
?SECOND
(MeasureFn 1 SecondDuration)))```

Wenn month ist ein fall von Monat und dauer von month ist "number day duration(s)" , dann "die Zahl Fällen in "Aufspaltung von month auf ? Tags"" ist gleich number .
```(=>
(and
(instance ?MONTH Month)
(duration
?MONTH
(MeasureFn ?NUMBER DayDuration)))
(equal
(CardinalityFn
(TemporalCompositionFn ?MONTH Day))
?NUMBER))```

Wenn increase ist ein fall von Zunehmen und obj ist ein patient von increase , 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 increase"" und ""obj unit(s)" ist gleich quant2 " hält während "sofort nach "die zeit des Bestehens von increase"" und quant2 ist grösserAls quant1 .
```(=>
(and
(instance ?INCREASE Increasing)
(patient ?INCREASE ?OBJ))
(exists
(?UNIT ?QUANT1 ?QUANT2)
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?INCREASE))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT1))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?INCREASE))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT2))
(greaterThan ?QUANT2 ?QUANT1))))```

Wenn heat ist ein fall von Erhitzen und obj ist ein patient von heat , 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 heat"" und ""obj unit(s)" ist gleich quant2 " hält während "sofort nach "die zeit des Bestehens von heat"" und quant2 ist grösserAls quant1 .
```(=>
(and
(instance ?HEAT Heating)
(patient ?HEAT ?OBJ))
(exists
(?UNIT ?QUANT1 ?QUANT2)
(and
(instance ?UNIT TemperatureMeasure)
(holdsDuring
(ImmediatePastFn
(WhenFn ?HEAT))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT1))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?HEAT))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT2))
(greaterThan ?QUANT2 ?QUANT1))))```

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 meas ist ein fall von Messen und meas ist der agent von agent und obj ist ein patient von meas , dann es gibt ein quant,unit der "agent kennt "das mass von obj ist "quant unit(s)" " " hält während "sofort nach "die zeit des Bestehens von meas"" .
```(=>
(and
(instance ?MEAS Measuring)
(agent ?MEAS ?AGENT)
(patient ?MEAS ?OBJ))
(exists
(?QUANT ?UNIT)
(holdsDuring
(ImmediateFutureFn
(WhenFn ?MEAS))
(knows
?AGENT
(measure
?OBJ
(MeasureFn ?QUANT ?UNIT))))))```