meets temporally (meetsTemporally)

(meetsTemporally interval1 interval2) means that the terminal point of the TimeInterval interval1 is the initial point of the TimeInterval interval2.

Ontologie

SUMO / TEMPORAL-CONCEPTS

Class(es)

třída

inheritable relation

binární predikát
is instance of

třída

inheritable relation

časová relace
is instance of

nesymetrická relace
is instance of

netranzitivní relace
is instance of

meets temporally

Související termín(y)

back fn begin fn cardinality fn day fn end fn front fn future fn hour fn immediate future fn immediate past fn minute fn month fn past fn principal host fn probability fn recurrent time interval fn relative time fn second fn skin fn temporal composition fn time interval fn when fn year fn arc weight attribute authors before before or equal causes causes subclass citizen closed on completely fills connected contains information cooccur copy crosses date decreases likelihood developmental form disjoint distributes documentation duration earlier editor element employs equal equivalence relation on exploits expressed in language faces family relation fills finishes frequency graph part greater than greater than or equal to has purpose has skill holds during holds obligation holds right hole identity element immediate instance immediate subclass in list in scope of interest increases likelihood independent probability inhabits inhibits initial list instance inverse irreflexive on larger less than less than or equal to manner material measure member modal attribute overlaps temporally parent partial ordering on partially fills partly located path length penetrates possesses precondition prevents proper part properly fills property publishes range range subclass realization refers reflexive on related internal concept sibling smaller starts sub attribute sub collection sub graph sub list sub process sub proposition subclass subrelation subsumes content class subsumes content instance successor attribute successor attribute closure surface temporal part temporally between temporally between or equal time total ordering on trichotomizing on uses valence version

Typy argumentů

meetsTemporally(časový interval, časový interval)

Related WordNet synsets

See more related synsets on a separate page.

Axiomy (31)

interval1 meets interval2 tehdy a jen tehdy pokud "the end of interval1" se rovná "the beginning of interval2".

(<=>
      (meetsTemporally ?INTERVAL1 ?INTERVAL2)
      (equal
            (EndFn ?INTERVAL1)
            (BeginFn ?INTERVAL2)))

Jestliže thing je instancí třídy fyzický objekt, potom "před doba existence thing" meets "doba existence thing".

(=>
      (instance ?THING Physical)
      (meetsTemporally
            (PastFn
                  (WhenFn ?THING))
            (WhenFn ?THING)))

Jestliže thing je instancí třídy fyzický objekt, potom "doba existence thing" meets "po doba existence thing".

(=>
      (instance ?THING Physical)
      (meetsTemporally
            (WhenFn ?THING)
            (FutureFn
                  (WhenFn ?THING))))

Jestliže day1 je instancí třídy "number1 of month" a day2 je instancí třídy "number2 of month" a "(number2-number1)" se rovná , potom day1 meets day2.

(=>
      (and
            (instance
                  ?DAY1
                  (DayFn ?NUMBER1 ?MONTH))
            (instance
                  ?DAY2
                  (DayFn ?NUMBER2 ?MONTH))
            (equal
                  (SubtractionFn ?NUMBER2 ?NUMBER1)
                  1))
      (meetsTemporally ?DAY1 ?DAY2))

Jestliže hour1 je instancí třídy "number1 of day" a hour2 je instancí třídy "number2 of day" a "(number2-number1)" se rovná , potom hour1 meets hour2.

(=>
      (and
            (instance
                  ?HOUR1
                  (HourFn ?NUMBER1 ?DAY))
            (instance
                  ?HOUR2
                  (HourFn ?NUMBER2 ?DAY))
            (equal
                  (SubtractionFn ?NUMBER2 ?NUMBER1)
                  1))
      (meetsTemporally ?HOUR1 ?HOUR2))

Jestliže minute1 je instancí třídy "number1 of hour" a minute2 je instancí třídy "number2 of hour" a "(number2-number1)" se rovná , potom minute1 meets minute2.

(=>
      (and
            (instance
                  ?MINUTE1
                  (MinuteFn ?NUMBER1 ?HOUR))
            (instance
                  ?MINUTE2
                  (MinuteFn ?NUMBER2 ?HOUR))
            (equal
                  (SubtractionFn ?NUMBER2 ?NUMBER1)
                  1))
      (meetsTemporally ?MINUTE1 ?MINUTE2))

Jestliže second1 je instancí třídy "number1 of minute" a second2 je instancí třídy "number2 of minute" a "(number2-number1)" se rovná , potom second1 meets second2.

(=>
      (and
            (instance
                  ?SECOND1
                  (SecondFn ?NUMBER1 ?MINUTE))
            (instance
                  ?SECOND2
                  (SecondFn ?NUMBER2 ?MINUTE))
            (equal
                  (SubtractionFn ?NUMBER2 ?NUMBER1)
                  1))
      (meetsTemporally ?SECOND1 ?SECOND2))

Jestliže year1 je instancí třídy rok a year2 je instancí třídy rok a "(year2-year1)" se rovná , potom year1 meets year2.

(=>
      (and
            (instance ?YEAR1 Year)
            (instance ?YEAR2 Year)
            (equal
                  (SubtractionFn ?YEAR2 ?YEAR1)
                  1))
      (meetsTemporally ?YEAR1 ?YEAR2))

Jestliže month1 se rovná "leden of year" a month2 se rovná "únor of year", potom month1 meets month2.

(=>
      (and
            (equal
                  ?MONTH1
                  (MonthFn January ?YEAR))
            (equal
                  ?MONTH2
                  (MonthFn February ?YEAR)))
      (meetsTemporally ?MONTH1 ?MONTH2))

Jestliže month1 se rovná "únor of year" a month2 se rovná "březen of year", potom month1 meets month2.

(=>
      (and
            (equal
                  ?MONTH1
                  (MonthFn February ?YEAR))
            (equal
                  ?MONTH2
                  (MonthFn March ?YEAR)))
      (meetsTemporally ?MONTH1 ?MONTH2))

Jestliže month1 se rovná "březen of year" a month2 se rovná "duben of year", potom month1 meets month2.

(=>
      (and
            (equal
                  ?MONTH1
                  (MonthFn March ?YEAR))
            (equal
                  ?MONTH2
                  (MonthFn April ?YEAR)))
      (meetsTemporally ?MONTH1 ?MONTH2))

Jestliže month1 se rovná "duben of year" a month2 se rovná "květen of year", potom month1 meets month2.

(=>
      (and
            (equal
                  ?MONTH1
                  (MonthFn April ?YEAR))
            (equal
                  ?MONTH2
                  (MonthFn May ?YEAR)))
      (meetsTemporally ?MONTH1 ?MONTH2))

Jestliže month1 se rovná "květen of year" a month2 se rovná "červen of year", potom month1 meets month2.

(=>
      (and
            (equal
                  ?MONTH1
                  (MonthFn May ?YEAR))
            (equal
                  ?MONTH2
                  (MonthFn June ?YEAR)))
      (meetsTemporally ?MONTH1 ?MONTH2))

Jestliže month1 se rovná "červen of year" a month2 se rovná "červenec of year", potom month1 meets month2.

(=>
      (and
            (equal
                  ?MONTH1
                  (MonthFn June ?YEAR))
            (equal
                  ?MONTH2
                  (MonthFn July ?YEAR)))
      (meetsTemporally ?MONTH1 ?MONTH2))

Jestliže month1 se rovná "červenec of year" a month2 se rovná "srpen of year", potom month1 meets month2.

(=>
      (and
            (equal
                  ?MONTH1
                  (MonthFn July ?YEAR))
            (equal
                  ?MONTH2
                  (MonthFn August ?YEAR)))
      (meetsTemporally ?MONTH1 ?MONTH2))

Jestliže month1 se rovná "srpen of year" a month2 se rovná "září of year", potom month1 meets month2.

(=>
      (and
            (equal
                  ?MONTH1
                  (MonthFn August ?YEAR))
            (equal
                  ?MONTH2
                  (MonthFn September ?YEAR)))
      (meetsTemporally ?MONTH1 ?MONTH2))

Jestliže month1 se rovná "září of year" a month2 se rovná "říjen of year", potom month1 meets month2.

(=>
      (and
            (equal
                  ?MONTH1
                  (MonthFn September ?YEAR))
            (equal
                  ?MONTH2
                  (MonthFn October ?YEAR)))
      (meetsTemporally ?MONTH1 ?MONTH2))

Jestliže month1 se rovná "říjen of year" a month2 se rovná "listopad of year", potom month1 meets month2.

(=>
      (and
            (equal
                  ?MONTH1
                  (MonthFn October ?YEAR))
            (equal
                  ?MONTH2
                  (MonthFn November ?YEAR)))
      (meetsTemporally ?MONTH1 ?MONTH2))

Jestliže month1 se rovná "listopad of year" a month2 se rovná "prosinec of year", potom month1 meets month2.

(=>
      (and
            (equal
                  ?MONTH1
                  (MonthFn November ?YEAR))
            (equal
                  ?MONTH2
                  (MonthFn December ?YEAR)))
      (meetsTemporally ?MONTH1 ?MONTH2))

Jestliže month1 se rovná "prosinec of year1" a month2 se rovná "leden of year2" a year1 meets year2, potom month1 meets month2.

(=>
      (and
            (equal
                  ?MONTH1
                  (MonthFn December ?YEAR1))
            (equal
                  ?MONTH2
                  (MonthFn January ?YEAR2))
            (meetsTemporally ?YEAR1 ?YEAR2))
      (meetsTemporally ?MONTH1 ?MONTH2))

Jestliže day1 je instancí třídy pondělí a day2 je instancí třídy úterý a week je instancí třídy týren a day1 je a part of week a day2 je a part of week, potom day1 meets day2.

(=>
      (and
            (instance ?DAY1 Monday)
            (instance ?DAY2 Tuesday)
            (instance ?WEEK Week)
            (temporalPart ?DAY1 ?WEEK)
            (temporalPart ?DAY2 ?WEEK))
      (meetsTemporally ?DAY1 ?DAY2))

Jestliže day1 je instancí třídy úterý a day2 je instancí třídy středa a week je instancí třídy týren a day1 je a part of week a day2 je a part of week, potom day1 meets day2.

(=>
      (and
            (instance ?DAY1 Tuesday)
            (instance ?DAY2 Wednesday)
            (instance ?WEEK Week)
            (temporalPart ?DAY1 ?WEEK)
            (temporalPart ?DAY2 ?WEEK))
      (meetsTemporally ?DAY1 ?DAY2))

Jestliže day1 je instancí třídy středa a day2 je instancí třídy čtvrtek a week je instancí třídy týren a day1 je a part of week a day2 je a part of week, potom day1 meets day2.

(=>
      (and
            (instance ?DAY1 Wednesday)
            (instance ?DAY2 Thursday)
            (instance ?WEEK Week)
            (temporalPart ?DAY1 ?WEEK)
            (temporalPart ?DAY2 ?WEEK))
      (meetsTemporally ?DAY1 ?DAY2))

Jestliže day1 je instancí třídy čtvrtek a day2 je instancí třídy pátek a week je instancí třídy týren a day1 je a part of week a day2 je a part of week, potom day1 meets day2.

(=>
      (and
            (instance ?DAY1 Thursday)
            (instance ?DAY2 Friday)
            (instance ?WEEK Week)
            (temporalPart ?DAY1 ?WEEK)
            (temporalPart ?DAY2 ?WEEK))
      (meetsTemporally ?DAY1 ?DAY2))

Jestliže day1 je instancí třídy pátek a day2 je instancí třídy sobota a week je instancí třídy týren a day1 je a part of week a day2 je a part of week, potom day1 meets day2.

(=>
      (and
            (instance ?DAY1 Friday)
            (instance ?DAY2 Saturday)
            (instance ?WEEK Week)
            (temporalPart ?DAY1 ?WEEK)
            (temporalPart ?DAY2 ?WEEK))
      (meetsTemporally ?DAY1 ?DAY2))

Jestliže day1 je instancí třídy sobota a day2 je instancí třídy neděle a week je instancí třídy týren a day1 je a part of week a day2 je a part of week, potom day1 meets day2.

(=>
      (and
            (instance ?DAY1 Saturday)
            (instance ?DAY2 Sunday)
            (instance ?WEEK Week)
            (temporalPart ?DAY1 ?WEEK)
            (temporalPart ?DAY2 ?WEEK))
      (meetsTemporally ?DAY1 ?DAY2))

Jestliže day1 je instancí třídy neděle a day2 je instancí třídy pondělí a week1 je instancí třídy týren a week2 je instancí třídy týren a day1 je a part of week1 a day2 je a part of week2 a week1 meets week2, potom day1 meets day2.

(=>
      (and
            (instance ?DAY1 Sunday)
            (instance ?DAY2 Monday)
            (instance ?WEEK1 Week)
            (instance ?WEEK2 Week)
            (temporalPart ?DAY1 ?WEEK1)
            (temporalPart ?DAY2 ?WEEK2)
            (meetsTemporally ?WEEK1 ?WEEK2))
      (meetsTemporally ?DAY1 ?DAY2))

jestliže "decomposition of interval into ? interval-types" se rovná class,
potom pro všechny time1,time2 platí: jestliže time1 je instancí třídy class a time2 je instancí třídy class a time1 se nerovná time2, potom time1 meets time2 nebo time2 meets time1 nebo time1 happens earlier than time2 nebo time2 happens earlier than time1

(=>
      (equal
            (TemporalCompositionFn ?INTERVAL ?INTERVAL-TYPE)
            ?CLASS)
      (forall
            (?TIME1 ?TIME2)
            (=>
                  (and
                        (instance ?TIME1 ?CLASS)
                        (instance ?TIME2 ?CLASS)
                        (not
                              (equal ?TIME1 ?TIME2)))
                  (or
                        (meetsTemporally ?TIME1 ?TIME2)
                        (meetsTemporally ?TIME2 ?TIME1)
                        (earlier ?TIME1 ?TIME2)
                        (earlier ?TIME2 ?TIME1)))))

jestliže "decomposition of interval into ? interval-types" se rovná class,
potom pro všechny time1 platí: jestliže time1 je instancí třídy class a time1 doesn't finish interval, potom existuje class time2 tak, že time1 meets time2

(=>
      (equal
            (TemporalCompositionFn ?INTERVAL ?INTERVAL-TYPE)
            ?CLASS)
      (forall
            (?TIME1)
            (=>
                  (and
                        (instance ?TIME1 ?CLASS)
                        (not
                              (finishes ?TIME1 ?INTERVAL)))
                  (exists
                        (?TIME2)
                        (and
                              (instance ?TIME2 ?CLASS)
                              (meetsTemporally ?TIME1 ?TIME2))))))

jestliže "decomposition of interval into ? interval-types" se rovná class,
potom pro všechny time1 platí: jestliže time1 je instancí třídy class a time1 doesn't start interval, potom existuje class time2 tak, že time2 meets time1

(=>
      (equal
            (TemporalCompositionFn ?INTERVAL ?INTERVAL-TYPE)
            ?CLASS)
      (forall
            (?TIME1)
            (=>
                  (and
                        (instance ?TIME1 ?CLASS)
                        (not
                              (starts ?TIME1 ?INTERVAL)))
                  (exists
                        (?TIME2)
                        (and
                              (instance ?TIME2 ?CLASS)
                              (meetsTemporally ?TIME2 ?TIME1))))))

Jestliže death je instancí třídy smrt a birth je instancí třídy narození a agent prodělává death a agent prodělává birth, potom existuje time tak, že "doba existence birth" meets time a time meets "doba existence death" a living je atributem agent během time.

(=>
      (and
            (instance ?DEATH Death)
            (instance ?BIRTH Birth)
            (experiencer ?DEATH ?AGENT)
            (experiencer ?BIRTH ?AGENT))
      (exists
            (?TIME)
            (and
                  (meetsTemporally
                        (WhenFn ?BIRTH)
                        ?TIME)
                  (meetsTemporally
                        ?TIME
                        (WhenFn ?DEATH))
                  (holdsDuring
                        ?TIME
                        (attribute ?AGENT Living)))))