Browsing Interface
: Welcome guest :
log in
[
Home
| 
Graph
|  ]
KB:
SUMO
Language:
BeaufortNumber0
BeaufortNumber1
BeaufortNumber10
BeaufortNumber11
BeaufortNumber12
BeaufortNumber2
BeaufortNumber3
BeaufortNumber4
BeaufortNumber5
BeaufortNumber6
BeaufortNumber7
BeaufortNumber8
BeaufortNumber9
BeaufortNumberAttribute
ChineseLanguage
ChineseLanguge
ChineseTraditionalLanguage
ChinesehLanguage
Chineselanguage
EnglishLanguage
Englishlanguage
FrenchLanguage
GermanLanguage
JapaneseLanguage
SpanishLanguage
SpeedScaleAttribute
SwedishLanguage
speedScaleAttributeMinMax
windDrivenMotion
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
联系起来。")
chinese_format.kif 2699-2700
(
documentation
EndFn
EnglishLanguage
"A
UnaryFunction
that maps a
TimeInterval
to the
TimePoint
at which the interval ends.")
Merge.kif 7624-7625
(
domain
EndFn
1
TimeInterval
)
Merge.kif 7621-7621
The number 1 argument of
end
is an
instance
of
time interval
(
instance
EndFn
TemporalRelation
)
Merge.kif 7618-7618
End
is an
instance
of
temporal relation
(
instance
EndFn
TotalValuedRelation
)
Merge.kif 7620-7620
End
is an
instance
of
total valued relation
(
instance
EndFn
UnaryFunction
)
Merge.kif 7619-7619
End
is an
instance
of
unary function
(
range
EndFn
TimePoint
)
Merge.kif 7622-7622
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 460-460
(
termFormat
ChineseLanguage
EndFn
"结束")
domainEnglishFormat.kif 22042-22042
(
termFormat
ChineseLanguage
EndFn
"结束函数")
chinese_format.kif 452-452
(
termFormat
ChineseTraditionalLanguage
EndFn
"結束")
domainEnglishFormat.kif 22041-22041
(
termFormat
EnglishLanguage
EndFn
"end")
domainEnglishFormat.kif 22040-22040
antecedent
(=>
(
and
(
equal
(
BeginFn
?INTERVAL1)
(
BeginFn
?INTERVAL2))
(
equal
(
EndFn
?INTERVAL1)
(
EndFn
?INTERVAL2)))
(
equal
?INTERVAL1 ?INTERVAL2))
Merge.kif 7849-7857
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
?PROCESSSTART
(
BeginFn
(
WhenFn
?PROCESS)))
(
equal
?AGENTEND
(
EndFn
(
WhenFn
?AGENT)))
(
benefits
?PROCESS ?AGENT))
(
before
?PROCESSSTART ?AGENTEND))
Mid-level-ontology.kif 20847-20852
If
a time point
is
equal
to the
beginning
of the
time
of existence of
a process
and
another time point
is
equal
to the
end
of the
time
of existence of
an agent
and
the agent
is a beneficiary of
the process
,
then
the time point
happens
before
the other time point
(=>
(
and
(
equal
?PROCESSSTART
(
BeginFn
(
WhenFn
?PROCESS)))
(
equal
?AGENTEND
(
EndFn
(
WhenFn
?AGENT)))
(
suffers
?PROCESS ?AGENT))
(
before
?PROCESSSTART ?AGENTEND))
Mid-level-ontology.kif 27803-27812
If
a time point
is
equal
to the
beginning
of the
time
of existence of
a process
and
another time point
is
equal
to the
end
of the
time
of existence of
an agent
and
the agent
suffers
from
the process
,
then
the time point
happens
before
the other time point
(=>
(
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 3963-3988
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 1031-1043
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 10899-10906
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 1702-1724
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 2591-2607
If
an agreement
the
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
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 2545-2561
If
an agreement
the
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
is
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 2609-2625
If
an agreement
the
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
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 2563-2581
If
an agreement
the
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
is
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 7636-7641
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 ?Amount ?DueDate)
(
before
(
EndFn
?Date)
(
BeginFn
?DueDate)))
(
instance
?Payment
Prepayment
))
FinancialOntology.kif 778-786
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
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 7627-7634
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 1275-1289
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
has a
dependency
on
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 1259-1273
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
has a
dependency
on
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 11582-11589
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 7779-7783
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 7871-7873
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 7677-7685
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 11899-11906
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 11447-11454
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 7843-7847
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 7655-7663
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 614-626
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 14393-14410
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 19164-19175
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 14755-14765
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 2283-2292
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 2347-2358
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 2362-2369
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 11761-11774
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 11721-11734
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 1522-1538
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 11517-11524
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 14016-14026
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 ?A)
(
patient
?B ?V))
(
and
(
holdsDuring
(
BeginFn
(
WhenFn
?B))
(
not
(
onboard
?A ?V)))
(
holdsDuring
(
EndFn
(
WhenFn
?B))
(
onboard
?A ?V))))
Mid-level-ontology.kif 14973-14984
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
the agent
is
onboard
the entity
holds
during
the
beginning
of the
time
of existence of
the process
and
the agent
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 15014-15026
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 14036-14046
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 7580-7580
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 3.0 is
open source software
produced by
Articulate Software
and its partners