Browsing Interface
: Welcome guest :
log in
[
Home
|
Graph
| ]
KB:
SUMO
Language:
AlbanianLanguage
ArabicLanguage
BasqueLanguage
BulgarianLanguage
CatalanLanguage
ChineseLanguage
ChineseTraditionalLanguage
CroatianLanguage
DanishLanguage
EnglishLanguage
FarsiLanguage
FinnishLanguage
FrenchLanguage
GalicianLanguage
GreekLanguage
HebrewLanguage
IcelandicLanguage
IndonesianLanguage
ItalianLanguage
JapaneseLanguage
MalayLanguage
NorwegianBokmalLanguage
NorwegianNorskLanguage
PolishLanguage
PortugueseLanguage
SpanishLanguage
SwedishLanguage
TaiwanChineseLanguage
ThaiLanguage
de
Formal Language:
OWL
SUO-KIF
TPTP
traditionalLogic
KB Term:
Term intersection
English Word:
Any
Noun
Verb
Adjective
Adverb
EndFn
Sigma KEE - EndFn
EndFn
appearance as argument number 1
(
documentation
EndFn
ChineseLanguage
"这是一个
UnaryFunction
，它把一个
TimeInterval
和 这个时段结束的
TimePoint
联系起来。")
Merge.kif 8221-8222
(
documentation
EndFn
EnglishLanguage
"A
UnaryFunction
that maps a
TimeInterval
to the
TimePoint
at which the interval ends.")
Merge.kif 8219-8220
(
domain
EndFn
1
TimeInterval
)
Merge.kif 8217-8217
The number 1 argument of
end
is an
instance
of
time interval
(
instance
EndFn
TemporalRelation
)
Merge.kif 8214-8214
End
is an
instance
of
temporal relation
(
instance
EndFn
TotalValuedRelation
)
Merge.kif 8216-8216
End
is an
instance
of
total valued relation
(
instance
EndFn
UnaryFunction
)
Merge.kif 8215-8215
End
is an
instance
of
unary function
(
range
EndFn
TimePoint
)
Merge.kif 8218-8218
The
range
of
end
is an instance of
time point
appearance as argument number 2
(
format
ChineseLanguage
EndFn
"%1 的结束")
chinese_format.kif 451-451
(
format
EnglishLanguage
EndFn
"the end of %1")
english_format.kif 273-273
(
termFormat
ChineseLanguage
EndFn
"结束函数")
chinese_format.kif 452-452
"结束函数" is the
printable
form
of
end
in
ChineseLanguage
(
termFormat
EnglishLanguage
EndFn
"end")
domainEnglishFormat.kif 4095-4095
"end" is the
printable
form
of
end
in
english language
antecedent
(=>
(
and
(
equal
(
BeginFn
?INTERVAL1)
(
BeginFn
?INTERVAL2))
(
equal
(
EndFn
?INTERVAL1)
(
EndFn
?INTERVAL2)))
(
equal
?INTERVAL1 ?INTERVAL2))
Merge.kif 8459-8467
If the
beginning
of
a time interval
is
equal
to the
beginning
of
another time interval
and the
end
of
the time interval
is
equal
to the
end
of
the other time interval
,
then
the time interval
is
equal
to
the other time interval
(=>
(
and
(
equal
?PROCESS-START
(
BeginFn
(
WhenFn
?PROCESS)))
(
equal
?AGENT-END
(
EndFn
(
WhenFn
?AGENT)))
(
benefits
?PROCESS ?AGENT))
(
before
?PROCESS-START ?AGENT-END))
Mid-level-ontology.kif 20803-20808
If
a process
-START is
equal
to the
beginning
of the
time
of existence of
the process
and
an agent
-END is
equal
to the
end
of the
time
of existence of
the agent
and
the agent
is a beneficiary of
the process
,
then
the process
-START happens
before
the agent
-END
(=>
(
and
(
equal
?PROCESS-START
(
BeginFn
(
WhenFn
?PROCESS)))
(
equal
?AGENT-END
(
EndFn
(
WhenFn
?AGENT)))
(
suffers
?PROCESS ?AGENT))
(
before
?PROCESS-START ?AGENT-END))
Mid-level-ontology.kif 27764-27773
If
a process
-START is
equal
to the
beginning
of the
time
of existence of
the process
and
an agent
-END is
equal
to the
end
of the
time
of existence of
the agent
and
the agent
suffers
from
the process
,
then
the process
-START happens
before
the agent
-END
(=>
(
and
(
instance
?ACCESSING
AccessingWebPage
)
(
instance
?PAGE
WebPage
)
(
instance
?TRANSFER
DataTransfer
)
(
instance
?SERVER
Server
)
(
instance
?REQUESTING
Requesting
)
(
instance
?BROWSER
WebBrowser
)
(
instance
?INTERVAL
TimeInterval
)
(
patient
?ACCESSING ?PAGE)
(
agent
?REQUESTING ?BROWSER)
(
destination
?REQUESTING ?SERVER)
(
patient
?REQUESTING ?PAGE)
(
origin
?TRANSFER ?SERVER)
(
destination
?TRANSFER ?BROWSER)
(
patient
?TRANSFER ?PAGE)
(
subProcess
?TRANSFER ?ACCESSING)
(
subProcess
?REQUESTING ?ACCESSING)
(
equal
(
EndFn
(
WhenFn
?REQUESTING))
(
BeginFn
?INTERVAL))
(
equal
(
EndFn
(
WhenFn
?TRANSFER))
(
EndFn
?INTERVAL)))
(
equal
(
SiteSpeedFn
?ACCESSING) ?INTERVAL))
UXExperimentalTerms.kif 3954-3979
If
an AccessingWebPage
is an
instance
of
AccessingWebPage
and
an entity
is an
instance
of
WebPage
and
a process
is an
instance
of
data transfer
and
an object
is an
instance
of
server
and
another process
is an
instance
of
requesting
and
an agent
is an
instance
of
web browser
and
a time interval
is an
instance
of
time interval
and
the entity
is a
patient
of
the AccessingWebPage
and
the agent
is an
agent
of
the other process
and
the other process
end
s up at
the object
and
the entity
is a
patient
of
the other process
and
the process
originate
s at
the object
and
the process
end
s up at
the agent
and
the entity
is a
patient
of
the process
and
the process
is a
subprocess
of
the AccessingWebPage
and
the other process
is a
subprocess
of
the AccessingWebPage
and the
end
of the
time
of existence of
the other process
is
equal
to the
beginning
of
the time interval
and the
end
of the
time
of existence of
the process
is
equal
to the
end
of
the time interval
,
then the time to
access
in
the AccessingWebPage
is
equal
to
the time interval
(=>
(
and
(
instance
?CD
CertificateOfDeposit
)
(
maturityDate
?CD ?MaturityDate)
(
instance
?Withdrawal
Withdrawal
)
(
origin
?Withdrawal
(
CurrencyFn
?CD))
(
date
?Withdrawal ?DateOfWithdrawal)
(
before
(
EndFn
?DateOfWithdrawal)
(
BeginFn
?MaturityDate)))
(
exists
(?Penalty)
(
and
(
instance
?Penalty
Penalty
)
(
destination
?Penalty
(
CurrencyFn
?CD))
(
causes
?Withdrawal ?Penalty))))
FinancialOntology.kif 1032-1044
If
a financial account
is an
instance
of
certificate of deposit
and
a day
is a
maturity
date of
the financial account
and
a process
is an
instance
of
withdrawal
and
the process
originate
s at the
currency
of
the financial account
and
date
of
the process
is
another day
and the
end
of
the other day
happens
before
the
beginning
of
the day
,
then there exists
another process
such that
the other process
is an
instance
of
penalty
and
the other process
end
s up at the
currency
of
the financial account
and
the process
cause
s
the other process
(=>
(
and
(
instance
?CHANGE
ChangeOfPossession
)
(
patient
?CHANGE ?OBJ)
(
holdsDuring
(
BeginFn
(
WhenFn
?CHANGE))
(
possesses
?AGENT1 ?OBJ))
(
holdsDuring
(
EndFn
(
WhenFn
?CHANGE))
(
possesses
?AGENT2 ?OBJ)))
(
not
(
equal
?AGENT1 ?AGENT2)))
Merge.kif 11600-11607
If
a process
is an
instance
of
change of possession
and
an entity
is a
patient
of
the process
and
another entity
possess
es
the entity
holds
during
the
beginning
of the
time
of existence of
the process
and
a third entity
possess
es
the entity
holds
during
the
end
of the
time
of existence of
the process
,
then
the other entity
is not
equal
to
the third entity
(=>
(
and
(
instance
?EXPORT
Exporting
)
(
patient
?EXPORT ?ITEM)
(
instance
?AREA1
GeopoliticalArea
)
(
instance
?AREA2
GeopoliticalArea
)
(
holdsDuring
(
BeginFn
(
WhenFn
?EXPORT))
(
located
?ITEM ?AREA1))
(
holdsDuring
(
EndFn
(
WhenFn
?EXPORT))
(
located
?ITEM ?AREA2)))
(
not
(
located
?AREA2 ?AREA1)))
Economy.kif 2459-2469
If
a process
is an
instance
of
exporting
and
an entity
is a
patient
of
the process
and
an object
is an
instance
of
geopolitical area
and
a physical
is an
instance
of
geopolitical area
and
the entity
is
located
at
the object
holds
during
the
beginning
of the
time
of existence of
the process
and
the entity
is
located
at
the physical
holds
during
the
end
of the
time
of existence of
the process
,
then
the physical
is not
located
at
the object
(=>
(
and
(
instance
?PROCESS ?PROCESS_CLASS)
(
subclass
?PROCESS_CLASS
Process
)
(
instance
?ACCESSING
AccessingWebPage
)
(
instance
?AGENT
Agent
)
(
agent
?PROCESS ?AGENT)
(
agent
?ACCESSING ?AGENT)
(
during
?PROCESS ?ACCESSING)
(
instance
?TIMETOFIRST
TimeInterval
)
(
not
(
exists
(?PROCESS2)
(
and
(
instance
?PROCESS2 ?PROCESS_CLASS)
(
agent
?PROCESS2 ?AGENT)
(
during
?PROCESS2 ?ACCESSING)
(
before
(
BeginFn
(
WhenFn
?PROCESS2))
(
BeginFn
(
WhenFn
?PROCESS))))))
(
equal
(
BeginFn
(
WhenFn
?ACCESSING))
(
BeginFn
(
WhenFn
?TIMETOFIRST)))
(
equal
(
BeginFn
(
WhenFn
?PROCESS))
(
EndFn
(
WhenFn
?TIMETOFIRST))))
(
equal
(
TTFxFn
?PROCESS_CLASS ?ACCESSING) ?TIMETOFIRST))
UXExperimentalTerms.kif 1703-1725
If
a time interval
is an
instance
of
the time interval
_CLASS and
the time interval
_CLASS is a
subclass
of
process
and
an AccessingWebPage
is an
instance
of
AccessingWebPage
and
an agent
is an
instance
of
agent
and
the agent
is an
agent
of
the time interval
and
the agent
is an
agent
of
the AccessingWebPage
and
the time interval
takes place
during
the AccessingWebPage
and
a physical
is an
instance
of
time interval
and there doesn't exist
the time interval
2 such that
the time interval
2 is an
instance
of
the time interval
_CLASS and
the agent
is an
agent
of
the time interval
2 and
the time interval
2 takes place
during
the AccessingWebPage
and the
beginning
of the
time
of existence of
the time interval
2 happens
before
the
beginning
of the
time
of existence of
the time interval
and the
beginning
of the
time
of existence of
the AccessingWebPage
is
equal
to the
beginning
of the
time
of existence of
the physical
and the
beginning
of the
time
of existence of
the time interval
is
equal
to the
end
of the
time
of existence of
the physical
,
then the
time
of
the AccessingWebPage
in the class
the time interval
_CLASS is
equal
to
the physical
(=>
(
and
(
property
?Option
Option
)
(
optionHolder
?Option ?Agent)
(
strikePrice
?Option ?Price)
(
agreementExpirationDate
?Option ?ExpDate)
(
price
?Stocks ?Price ?Time)
(
instance
?Time
TimeInterval
)
(
before
(
EndFn
?Time)
(
BeginFn
?ExpDate))
(
underlier
?Option ?Stocks))
(
holdsRight
(
KappaFn
?Sell
(
and
(
instance
?Sell
Selling
)
(
patient
?Sell ?Stocks)
(
time
?Sell ?Time)
(
measure
?Stocks
(
MeasureFn
100
ShareUnit
))
(
agent
?Sell ?Agent))) ?Agent))
FinancialOntology.kif 2590-2606
If
an agreement
has an
attribute
option
and
a cognitive agent
holds
the agreement
and
a currency measure
is a
strike
price of
the agreement
and
the agreement
has
expiration
a time interval
and
a financial instrument
price
the currency measure
for
an agent
and
the agent
is an
instance
of
time interval
and the
end
of
the agent
happens
before
the
beginning
of
the time interval
and
the financial instrument
is an
underlier
of
the agreement
,
then
the cognitive agent
has the
right
to perform the
class
described by
a symbolic string
(=>
(
and
(
property
?Option
Option
)
(
optionHolder
?Option ?Agent)
(
strikePrice
?Option ?Price)
(
agreementExpirationDate
?Option ?ExpDate)
(
underlier
?Option ?Stocks)
(
price
?Stocks ?Price ?Time)
(
instance
?Time
TimeInterval
)
(
before
(
EndFn
?Time)
(
BeginFn
?ExpDate)))
(
holdsRight
(
KappaFn
?Buy
(
and
(
instance
?Buy
Buying
)
(
patient
?Buy ?Stocks)
(
time
?Buy ?Time)
(
measure
?Stocks
(
MeasureFn
100
ShareUnit
))
(
agent
?Buy ?Agent))) ?Agent))
FinancialOntology.kif 2546-2562
If
an agreement
has an
attribute
option
and
a cognitive agent
holds
the agreement
and
a currency measure
is a
strike
price of
the agreement
and
the agreement
has
expiration
a time interval
and
a financial instrument
is an
underlier
of
the agreement
and
the financial instrument
price
the currency measure
for
an agent
and
the agent
is an
instance
of
time interval
and the
end
of
the agent
happens
before
the
beginning
of
the time interval
,
then
the cognitive agent
has the
right
to perform the
class
described by
a symbolic string
(=>
(
and
(
property
?Option
Option
)
(
optionSeller
?Option ?Agent)
(
strikePrice
?Option ?Price)
(
agreementExpirationDate
?Option ?ExpDate)
(
price
?Stocks ?Price ?Time)
(
instance
?Time
TimeInterval
)
(
before
(
EndFn
?Time)
(
BeginFn
?ExpDate))
(
underlier
?Option ?Stocks))
(
holdsObligation
(
KappaFn
?Buy
(
and
(
instance
?Buy
Buying
)
(
patient
?Buy ?Stocks)
(
time
?Buy ?Time)
(
measure
?Stocks
(
MeasureFn
100
ShareUnit
))
(
agent
?Buy ?Agent))) ?Agent))
FinancialOntology.kif 2608-2624
If
an agreement
has an
attribute
option
and
a cognitive agent
sells
the agreement
and
a currency measure
is a
strike
price of
the agreement
and
the agreement
has
expiration
a time interval
and
a financial instrument
price
the currency measure
for
an agent
and
the agent
is an
instance
of
time interval
and the
end
of
the agent
happens
before
the
beginning
of
the time interval
and
the financial instrument
is an
underlier
of
the agreement
,
then
the cognitive agent
is
obliged
to perform tasks of type the
class
described by
a symbolic string
(=>
(
and
(
property
?Option
Option
)
(
optionSeller
?Option ?Seller)
(
strikePrice
?Option ?Price)
(
agreementExpirationDate
?Option ?ExpDate)
(
underlier
?Option ?Stocks)
(
price
?Stocks ?Price ?Time)
(
instance
?Time
TimeInterval
)
(
before
(
EndFn
?Time)
(
BeginFn
?ExpDate)))
(
holdsObligation
(
KappaFn
?Sell
(
and
(
instance
?Sell
Selling
)
(
patient
?Sell ?Stocks)
(
time
?Sell ?Time)
(
measure
?Stocks
(
MeasureFn
100
ShareUnit
))
(
agent
?Sell ?Agent))) ?Seller))
FinancialOntology.kif 2564-2580
If
an agreement
has an
attribute
option
and
a cognitive agent
sells
the agreement
and
a currency measure
is a
strike
price of
the agreement
and
the agreement
has
expiration
a time interval
and
a financial instrument
is an
underlier
of
the agreement
and
the financial instrument
price
the currency measure
for
an agent
and
the agent
is an
instance
of
time interval
and the
end
of
the agent
happens
before
the
beginning
of
the time interval
,
then
the cognitive agent
is
obliged
to perform tasks of type the
class
described by
a symbolic string
(=>
(
and
(
resource
?PROC ?OBJ)
(
holdsDuring
(
BeginFn
(
WhenFn
?PROC))
(
measure
?OBJ ?QUANT1))
(
holdsDuring
(
EndFn
(
WhenFn
?PROC))
(
measure
?OBJ ?QUANT2)))
(
greaterThan
?QUANT1 ?QUANT2))
Merge.kif 8233-8238
If
an object
is a
resource
for
a process
and the
measure
of
the object
is
a quantity
holds
during
the
beginning
of the
time
of existence of
the process
and the
measure
of
the object
is
another quantity
holds
during
the
end
of the
time
of existence of
the process
,
then
the quantity
is
greater
than
the other quantity
(=>
(
and
(
transactionAmount
?Payment ?Amount)
(
date
?Payment ?Date)
(
instance
?Account
FinancialAccount
)
(
destination
?Payment
(
CurrencyFn
?Account))
(
amountDue
?Account ?AmountDue ?DueDate)
(
before
(
EndFn
?Date)
(
BeginFn
?DueDate)))
(
instance
?Payment
Prepayment
))
FinancialOntology.kif 779-787
If
a currency measure
is a
transaction
amount of
a financial transaction
and
date
of
the financial transaction
is
a day
and
a financial account
is an
instance
of
financial account
and
the financial transaction
end
s up at the
currency
of
the financial account
and
the financial account
amount
due
the currency measure
Due for
a time interval
and the
end
of
the day
happens
before
the
beginning
of
the time interval
,
then
the financial transaction
is an
instance
of
prepayment
(=>
(
equal
(
EndFn
?INTERVAL) ?POINT)
(
forall
(?OTHERPOINT)
(=>
(
and
(
temporalPart
?OTHERPOINT ?INTERVAL)
(
not
(
equal
?OTHERPOINT ?POINT)))
(
before
?OTHERPOINT ?POINT))))
Merge.kif 8224-8231
If the
end
of
a time interval
is
equal
to
a time point
,
then for all
another time point
if
the other time point
is a
part
of
the time interval
and
the other time point
is not
equal
to
the time point
,
then
the other time point
happens
before
the time point
(=>
(
exists
(?Time1 ?Time2)
(
and
(
dependencyDelay
?Program1 ?Delay)
(
dependencyType
?Program1
ShutdownBlock
)
(
hasDependency
?Program1 ?Program2)
(
instance
?Process1
ComputerProcess
)
(
programRunning
?Process1 ?Program1)
(
instance
?Process2
ComputerProcess
)
(
programRunning
?Process2 ?Program2)
(
equal
(
WhenFn
?Process2) ?Time2)
(
finishes
?Time ?Time1)
(
equal
(
WhenFn
?Process2) ?Time2)
(
equal
(
BeginFn
?Time)
(
EndFn
?Time2))))
(
duration
?Time ?Delay))
QoSontology.kif 1265-1279
If there exist
a time interval
and
another time interval
such that
a time duration
is a
dependency
delay of
a computer program
and
shutdown block
is a
dependency
type of
the computer program
and
another computer program
is a
has
dependency of
the computer program
and
a computer process
is an
instance
of
computer process
and
the computer program
is a
program
running of
the computer process
and
another computer process
is an
instance
of
computer process
and
the other computer program
is a
program
running of
the other computer process
and the
time
of existence of
the other computer process
is
equal
to
the other time interval
and
a third time interval
finish
es
the time interval
and the
time
of existence of
the other computer process
is
equal
to
the other time interval
and the
beginning
of
the third time interval
is
equal
to the
end
of
the other time interval
,
then
duration
of
the third time interval
is
the time duration
(=>
(
exists
(?Time1 ?Time2)
(
and
(
dependencyDelay
?Program1 ?Delay)
(
dependencyType
?Program1
StartupBlock
)
(
hasDependency
?Program1 ?Program2)
(
instance
?Process1
ComputerProcess
)
(
programRunning
?Process1 ?Program1)
(
instance
?Process2
ComputerProcess
)
(
programRunning
?Process2 ?Program2)
(
equal
(
WhenFn
?Process2) ?Time2)
(
starts
?Time2 ?Time)
(
equal
(
WhenFn
?Process1) ?Time1)
(
equal
(
EndFn
?Time)
(
BeginFn
?Time1))))
(
duration
?Time ?Delay))
QoSontology.kif 1249-1263
If there exist
a time interval
and
another time interval
such that
a time duration
is a
dependency
delay of
a computer program
and
startup block
is a
dependency
type of
the computer program
and
another computer program
is a
has
dependency of
the computer program
and
a computer process
is an
instance
of
computer process
and
the computer program
is a
program
running of
the computer process
and
another computer process
is an
instance
of
computer process
and
the other computer program
is a
program
running of
the other computer process
and the
time
of existence of
the other computer process
is
equal
to
the other time interval
and
the other time interval
start
s
a third time interval
and the
time
of existence of
the computer process
is
equal
to
the time interval
and the
end
of
the third time interval
is
equal
to the
beginning
of
the time interval
,
then
duration
of
the third time interval
is
the time duration
consequent
(<=>
(
and
(
instance
?COMBINE
Combining
)
(
resource
?COMBINE ?OBJ1)
(
result
?COMBINE ?OBJ2))
(
and
(
holdsDuring
(
BeginFn
(
WhenFn
?COMBINE))
(
not
(
part
?OBJ1 ?OBJ2)))
(
holdsDuring
(
EndFn
(
WhenFn
?COMBINE))
(
part
?OBJ1 ?OBJ2))))
Merge.kif 12376-12383
A process
is an
instance
of
combining
and
an object
is a
resource
for
the process
and
an entity
is a
result
of
the process
if and only if
the object
is not a
part
of
the entity
holds
during
the
beginning
of the
time
of existence of
the process
and
the object
is a
part
of
the entity
holds
during
the
end
of the
time
of existence of
the process
(<=>
(
and
(
time
?PHYS ?TIME)
(
instance
?TIME
TimePoint
))
(
temporallyBetweenOrEqual
(
BeginFn
(
WhenFn
?PHYS)) ?TIME
(
EndFn
(
WhenFn
?PHYS))))
Merge.kif 8386-8390
A physical
exists
during
a time point
and
the time point
is an
instance
of
time point
if and only if
the time point
is
between
or at the
beginning
of the
time
of existence of
the physical
and the
end
of the
time
of existence of
the physical
(<=>
(
earlier
?INTERVAL1 ?INTERVAL2)
(
before
(
EndFn
?INTERVAL1)
(
BeginFn
?INTERVAL2)))
Merge.kif 8482-8484
A time interval
happens
earlier
than
another time interval
if and only if the
end
of
the time interval
happens
before
the
beginning
of
the other time interval
(<=>
(
finishes
?INTERVAL1 ?INTERVAL2)
(
and
(
before
(
BeginFn
?INTERVAL2)
(
BeginFn
?INTERVAL1))
(
equal
(
EndFn
?INTERVAL2)
(
EndFn
?INTERVAL1))))
Merge.kif 8278-8286
A time interval
finish
es
another time interval
if and only if the
beginning
of
the other time interval
happens
before
the
beginning
of
the time interval
and the
end
of
the other time interval
is
equal
to the
end
of
the time interval
(<=>
(
instance
?PROCESS
Creation
)
(
exists
(?PATIENT)
(
and
(
patient
?PROCESS ?PATIENT)
(
time
?PATIENT
(
EndFn
(
WhenFn
?PROCESS)))
(
not
(
time
?PATIENT
(
BeginFn
(
WhenFn
?PROCESS)))))))
Merge.kif 12727-12734
A process
is an
instance
of
creation
if and only if there exists
a physical
such that
the physical
is a
patient
of
the process
and
the physical
exists
during
the
end
of the
time
of existence of
the process
and
the physical
doesn't exist
during
the
beginning
of the
time
of existence of
the process
(<=>
(
instance
?PROCESS
Destruction
)
(
exists
(?PATIENT)
(
and
(
patient
?PROCESS ?PATIENT)
(
time
?PATIENT
(
BeginFn
(
WhenFn
?PROCESS)))
(
not
(
time
?PATIENT
(
EndFn
(
WhenFn
?PROCESS)))))))
Merge.kif 12220-12227
A process
is an
instance
of
destruction
if and only if there exists
a physical
such that
the physical
is a
patient
of
the process
and
the physical
exists
during
the
beginning
of the
time
of existence of
the process
and
the physical
doesn't exist
during
the
end
of the
time
of existence of
the process
(<=>
(
meetsTemporally
?INTERVAL1 ?INTERVAL2)
(
equal
(
EndFn
?INTERVAL1)
(
BeginFn
?INTERVAL2)))
Merge.kif 8453-8457
A time interval
meet
s
another time interval
if and only if the
end
of
the time interval
is
equal
to the
beginning
of
the other time interval
(<=>
(
starts
?INTERVAL1 ?INTERVAL2)
(
and
(
equal
(
BeginFn
?INTERVAL1)
(
BeginFn
?INTERVAL2))
(
before
(
EndFn
?INTERVAL1)
(
EndFn
?INTERVAL2))))
Merge.kif 8254-8262
A time interval
start
s
another time interval
if and only if the
beginning
of
the time interval
is
equal
to the
beginning
of
the other time interval
and the
end
of
the time interval
happens
before
the
end
of
the other time interval
(=>
(
and
(
amountDue
?Account ?Amount ?DueDate)
(
accountHolder
?Account ?Agent))
(
holdsObligation
(
KappaFn
?Payment
(
and
(
instance
?Payment
Payment
)
(
transactionAmount
?Payment ?Amount)
(
or
(
destination
?Payment
(
CurrencyFn
?Account))
(
origin
?Payment
(
CurrencyFn
?Account)))
(
date
?Payment ?Date)
(
beforeOrEqual
(
EndFn
?Date)
(
BeginFn
?DueDate)))) ?Agent))
FinancialOntology.kif 615-627
If
a financial account
amount
due
a currency measure
for
a time position
and
a cognitive agent
holds
account
the financial account
,
then
the cognitive agent
is
obliged
to perform tasks of type the
class
described by
a symbolic string
(=>
(
and
(
birthdate
JesusOfNazareth
?DAY)
(
instance
?Y1
(
YearFn
-6))
(
instance
?Y2
(
YearFn
4)))
(
temporalPart
?DAY
(
TimeIntervalFn
(
BeginFn
?Y1)
(
EndFn
?Y2))))
Media.kif 1938-1943
If
a day
is a
birthdate
of
JesusOfNazareth
and
a time interval
is an
instance
of the
year
-6 and
another time interval
is an
instance
of the
year
4,
then
the day
is a
part
of
interval
between the
beginning
of
the time interval
and the
end
of
the other time interval
(=>
(
and
(
deathdate
JesusOfNazareth
?DAY)
(
instance
?Y1
(
YearFn
29))
(
instance
?Y2
(
YearFn
36)))
(
temporalPart
?DAY
(
TimeIntervalFn
(
BeginFn
?Y1)
(
EndFn
?Y2))))
Media.kif 1945-1950
If
a day
is a
deathdate
of
JesusOfNazareth
and
a time interval
is an
instance
of the
year
29 and
another time interval
is an
instance
of the
year
36,
then
the day
is a
part
of
interval
between the
beginning
of
the time interval
and the
end
of
the other time interval
(=>
(
and
(
equal
(
EditionFn
?TEXT ?INT1) ?EDITION1)
(
equal
(
EditionFn
?TEXT ?INT2) ?EDITION2)
(
greaterThan
?INT2 ?INT1)
(
instance
?PUB1
Publication
)
(
instance
?PUB2
Publication
)
(
instance
?CBO1 ?EDITION1)
(
instance
?CBO2 ?EDITION2)
(
patient
?PUB1 ?CBO1)
(
patient
?PUB2 ?CBO2)
(
date
?PUB1 ?DATE1)
(
date
?PUB2 ?DATE2))
(
before
(
EndFn
?DATE1)
(
EndFn
?DATE2)))
Merge.kif 15632-15649
If
edition
a positive integer
of
a kind of content bearing object
is
equal
to
another kind of content bearing object
and
edition
another positive integer
of
a kind of content bearing object
is
equal
to
a third kind of content bearing object
and
the other positive integer
is
greater
than
the positive integer
and
a process
is an
instance
of
publication
and
another process
is an
instance
of
publication
and
an entity
is an
instance
of
another kind of content bearing object
and
another entity
is an
instance
of
a third kind of content bearing object
and
the entity
is a
patient
of
the process
and
the other entity
is a
patient
of
the other process
and
date
of
the process
is
a day
and
date
of
the other process
is
another day
,
then the
end
of
the day
happens
before
the
end
of
the other day
(=>
(
and
(
instance
?A
Aborting
)
(
patient
?A ?W)
(
instance
?W
Woman
))
(
and
(
holdsDuring
(
BeginFn
(
WhenFn
?A))
(
attribute
?W
Pregnant
))
(
holdsDuring
(
EndFn
(
WhenFn
?A))
(
not
(
attribute
?W
Pregnant
)))))
Mid-level-ontology.kif 19121-19132
If
a process
is an
instance
of
aborting
and
an entity
is a
patient
of
the process
and
the entity
is an
instance
of
woman
,
then
pregnant
is an
attribute
of
the entity
holds
during
the
beginning
of the
time
of existence of
the process
and
pregnant
is not an
attribute
of
the entity
holds
during
the
end
of the
time
of existence of
the process
(=>
(
and
(
instance
?ACCELERATE
Accelerating
)
(
agent
?ACCELERATE ?AGENT))
(
exists
(?LENGTH1 ?LENGTH2 ?TIME1 ?TIME2)
(
and
(
holdsDuring
(
BeginFn
(
WhenFn
?ACCELERATE))
(
measure
?AGENT
(
SpeedFn
?LENGTH1 ?TIME1)))
(
holdsDuring
(
EndFn
(
WhenFn
?ACCELERATE))
(
measure
?AGENT
(
SpeedFn
?LENGTH2 ?TIME2)))
(
or
(
greaterThan
?LENGTH2 ?LENGTH1)
(
greaterThan
?TIME2 ?TIME1)))))
Mid-level-ontology.kif 14727-14737
If
a process
is an
instance
of
accelerating
and
an agent
is an
agent
of
the process
,
then there exist
a quantity
,
another quantity
,, ,
a third quantity
and
a fourth quantity
such that the
measure
of
the agent
is
the quantity
per
the third quantity
holds
during
the
beginning
of the
time
of existence of
the process
and the
measure
of
the agent
is
the other quantity
per
the fourth quantity
holds
during
the
end
of the
time
of existence of
the process
and
the other quantity
is
greater
than
the quantity
or
the fourth quantity
is
greater
than
the third quantity
(=>
(
and
(
instance
?ACT
ActivatingUIElement
)
(
patient
?ACT ?GUIE)
(
instance
?GUIE
GUIElement
))
(
and
(
holdsDuring
(
EndFn
?SELECT)
(
hasGUEState
?GUIE
GUE_ActiveState
))
(
holdsDuring
(
StartFn
?SELECT)
(
not
(
hasGUEState
?GUIE
GUE_ActiveState
)))))
ComputerInput.kif 1813-1822
If
a process
is an
instance
of
ActivatingUIElement
and
an entity
is a
patient
of
the process
and
the entity
is an
instance
of
GUIElement
,
then
the entity
has
state
GUE_ActiveState
holds
during
the
end
of
a time interval
and not
the entity
has
state
GUE_ActiveState
holds
during
the
start
of
the time interval
(=>
(
and
(
instance
?ACT
BringingGEToFront
)
(
patient
?ACT ?WINDOW)
(
instance
?WINDOW
InterfaceWindow
)
(
holdsDuring
(
BeginFn
?ACT)
(
hasGUEState
?WINDOW ?STATE))
(
contraryAttribute
?STATE
GUE_UncoveredState
))
(
holdsDuring
(
EndFn
?ACT)
(
not
(
hasGUEState
?WINDOW ?STATE))))
ComputerInput.kif 1867-1878
If
a time interval
is an
instance
of
BringingGEToFront
and
an entity
is a
patient
of
the time interval
and
the entity
is an
instance
of
InterfaceWindow
and
the entity
has
state
an attribute
holds
during
the
beginning
of
the time interval
and
the attribute
is the
opposite
of
GUE_UncoveredState
,
then not
the entity
has
state
the attribute
holds
during
the
end
of
the time interval
(=>
(
and
(
instance
?ACT
BringingGEToFront
)
(
patient
?ACT ?WINDOW)
(
instance
?WINDOW
InterfaceWindow
))
(
holdsDuring
(
EndFn
?ACT)
(
hasGUEState
?WINDOW
GUE_UncoveredState
)))
ComputerInput.kif 1882-1889
If
a time interval
is an
instance
of
BringingGEToFront
and
an entity
is a
patient
of
the time interval
and
the entity
is an
instance
of
InterfaceWindow
,
then
the entity
has
state
GUE_UncoveredState
holds
during
the
end
of
the time interval
(=>
(
and
(
instance
?ALT
ShapeChange
)
(
patient
?ALT ?OBJ))
(
exists
(?PROPERTY)
(
and
(
instance
?PROPERTY
ShapeAttribute
)
(
or
(
and
(
holdsDuring
(
BeginFn
(
WhenFn
?ALT))
(
attribute
?OBJ ?PROPERTY))
(
holdsDuring
(
EndFn
(
WhenFn
?ALT))
(
not
(
attribute
?OBJ ?PROPERTY))))
(
and
(
holdsDuring
(
BeginFn
(
WhenFn
?ALT))
(
not
(
attribute
?OBJ ?PROPERTY)))
(
holdsDuring
(
EndFn
(
WhenFn
?ALT))
(
attribute
?OBJ ?PROPERTY)))))))
Merge.kif 12571-12584
If
a process
is an
instance
of
shape change
and
an entity
is a
patient
of
the process
,
then there exists
another entity
such that
the other entity
is an
instance
of
shape attribute
and
the other entity
is an
attribute
of
the entity
holds
during
the
beginning
of the
time
of existence of
the process
and
the other entity
is not an
attribute
of
the entity
holds
during
the
end
of the
time
of existence of
the process
or
the other entity
is not an
attribute
of
the entity
holds
during
the
beginning
of the
time
of existence of
the process
and
the other entity
is an
attribute
of
the entity
holds
during
the
end
of the
time
of existence of
the process
(=>
(
and
(
instance
?ALT
SurfaceChange
)
(
patient
?ALT ?OBJ))
(
exists
(?PART ?PROPERTY)
(
and
(
superficialPart
?PART ?OBJ)
(
or
(
and
(
holdsDuring
(
BeginFn
(
WhenFn
?ALT))
(
attribute
?PART ?PROPERTY))
(
holdsDuring
(
EndFn
(
WhenFn
?ALT))
(
not
(
attribute
?PART ?PROPERTY))))
(
and
(
holdsDuring
(
BeginFn
(
WhenFn
?ALT))
(
not
(
attribute
?PART ?PROPERTY)))
(
holdsDuring
(
EndFn
(
WhenFn
?ALT))
(
attribute
?PART ?PROPERTY)))))))
Merge.kif 12528-12541
If
a process
is an
instance
of
surface change
and
an object
is a
patient
of
the process
,
then there exist
another object
and
an entity
such that
the other object
is a
superficial
part of
the object
and
the entity
is an
attribute
of
the other object
holds
during
the
beginning
of the
time
of existence of
the process
and
the entity
is not an
attribute
of
the other object
holds
during
the
end
of the
time
of existence of
the process
or
the entity
is not an
attribute
of
the other object
holds
during
the
beginning
of the
time
of existence of
the process
and
the entity
is an
attribute
of
the other object
holds
during
the
end
of the
time
of existence of
the process
(=>
(
and
(
instance
?ATC
AddToCart
)
(
instance
?OBJ
Object
)
(
patient
?ATC ?OBJ)
(
agent
?ATC ?USER))
(
exists
(?COLL ?SITE ?AFTER)
(
and
(
instance
?COLL
Collection
)
(
instance
?SITE
Website
)
(
instance
?INTERVAL
TimeInterval
)
(
webcart
?USER ?COLL ?SITE)
(
equal
(
BeginFn
?INTERVAL)
(
EndFn
?ATC))
(
holdsDuring
?AFTER
(
member
?OBJ ?COLL)))))
UXExperimentalTerms.kif 1523-1539
If
a time interval
is an
instance
of
add to cart
and
an entity
is an
instance
of
object
and
the entity
is a
patient
of
the time interval
and
an agent
is an
agent
of
the time interval
,
then there exist
a collection
,
a WebSite
and
a time position
such that
the collection
is an
instance
of
collection
and
the WebSite
is an
instance
of
Website
and
another time interval
is an
instance
of
time interval
and user
the agent
at
the WebSite
has
cart
the collection
and the
beginning
of
the other time interval
is
equal
to the
end
of
the time interval
and
the entity
is a
member
of
the collection
holds
during
the time position
(=>
(
and
(
instance
?ATTACH
Attaching
)
(
patient
?ATTACH ?OBJ1)
(
patient
?ATTACH ?OBJ2))
(
and
(
holdsDuring
(
BeginFn
(
WhenFn
?ATTACH))
(
not
(
connected
?OBJ1 ?OBJ2)))
(
holdsDuring
(
EndFn
(
WhenFn
?ATTACH))
(
connected
?OBJ1 ?OBJ2))))
Merge.kif 12300-12307
If
a process
is an
instance
of
attaching
and
an entity
is a
patient
of
the process
and
another entity
is a
patient
of
the process
,
then
the entity
is not
connected
to
the other entity
holds
during
the
beginning
of the
time
of existence of
the process
and
the entity
is
connected
to
the other entity
holds
during
the
end
of the
time
of existence of
the process
(=>
(
and
(
instance
?B
BecomingDrunk
)
(
experiencer
?B ?A))
(
and
(
holdsDuring
(
BeginFn
(
WhenFn
?B))
(
attribute
?A
Sober
))
(
holdsDuring
(
EndFn
(
WhenFn
?B))
(
attribute
?A
Drunk
))))
Mid-level-ontology.kif 13988-13998
If
a process
is an
instance
of
becoming drunk
and
an agent
experience
s
the process
,
then
sober
is an
attribute
of
the agent
holds
during
the
beginning
of the
time
of existence of
the process
and
drunk
is an
attribute
of
the agent
holds
during
the
end
of the
time
of existence of
the process
(=>
(
and
(
instance
?B
Boarding
)
(
agent
?B ?AGENT)
(
patient
?B ?V))
(
and
(
holdsDuring
(
BeginFn
(
WhenFn
?B))
(
not
(
onboard
?A ?V)))
(
holdsDuring
(
EndFn
(
WhenFn
?B))
(
onboard
?A ?V))))
Mid-level-ontology.kif 14945-14956
If
a process
is an
instance
of
boarding
and
an agent
is an
agent
of
the process
and
an entity
is a
patient
of
the process
,
then not
another entity
is
onboard
the entity
holds
during
the
beginning
of the
time
of existence of
the process
and
the other entity
is
onboard
the entity
holds
during
the
end
of the
time
of existence of
the process
(=>
(
and
(
instance
?B
Deboarding
)
(
agent
?B ?A)
(
patient
?B ?V))
(
and
(
holdsDuring
(
BeginFn
(
WhenFn
?B))
(
onboard
?A ?V))
(
holdsDuring
(
EndFn
(
WhenFn
?B))
(
not
(
onboard
?A ?V)))))
Mid-level-ontology.kif 14986-14998
If
a process
is an
instance
of
deboarding
and
an agent
is an
agent
of
the process
and
an entity
is a
patient
of
the process
,
then
the agent
is
onboard
the entity
holds
during
the
beginning
of the
time
of existence of
the process
and not
the agent
is
onboard
the entity
holds
during
the
end
of the
time
of existence of
the process
(=>
(
and
(
instance
?B
SoberingUp
)
(
experiencer
?B ?A))
(
and
(
holdsDuring
(
BeginFn
(
WhenFn
?B))
(
attribute
?A
Drunk
))
(
holdsDuring
(
EndFn
(
WhenFn
?B))
(
attribute
?A
Sober
))))
Mid-level-ontology.kif 14008-14018
If
a process
is an
instance
of
sobering up
and
an agent
experience
s
the process
,
then
drunk
is an
attribute
of
the agent
holds
during
the
beginning
of the
time
of existence of
the process
and
sober
is an
attribute
of
the agent
holds
during
the
end
of the
time
of existence of
the process
Display limited to 25 items.
Show next 25
Display limited to 25 items.
Show next 25
statement
(
equal
(
EndFn
CommonEra
)
PositiveInfinity
)
Mid-level-ontology.kif 7597-7597
The
end
of
common era
is
equal
to
positive infinity
Show simplified definition (without tree view)
Show simplified definition (with tree view)
Show without tree
Sigma web home
Suggested Upper Merged Ontology (SUMO) web home
Sigma version 2.99c (>= 2017/11/20) is
open source software
produced by
Articulate Software
and its partners
