schliesstZeitlichAn (meetsTemporally)

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

Ontology

SUMO / TEMPORAL-CONCEPTS

Class(es)

Kategorie

inheritable relation

zweistellige Prädikat
is instance of

Kategorie

inheritable relation

zeitliche Relation
is instance of

asymmetrische Relation
is instance of

intransitive Relation
is instance of

schliesstZeitlichAn

Coordinate term(s)

RückseiteFn AnfangFn KardinalitätFn TagFn EndeFn FrontseiteFn ZukunftFn StundeFn SofortigeZukunftFn DirektVergangenheitFn MinuteFn MonatFn VergangenheitFn HauptwirtFn Wahrscheinlichkeit RückläufigeZeitAbstandFn RelativeZeitFn SekundFn OberflächeFn ZeitlicheAufbauFn ZeitabstandFn WennFn JahrFn arctusGewicht attribut schreibt vor vorOderGleichzeitig verursacht causes subclass bürger aufgeschlossen fülltVollständig angeschlossen enthältInformationen zusammenGeschiecht kopie kreuzt datum verringertWahrscheinlichkeit entwicklungsForm disjunkt istDistributiv dokumentation &%dauer von %1 ist %2 %n{nicht} früh herausgeber element beschäftigt %1 ist gleich %2 %n{nicht} äquivalenzrelationMit nutztAus inSpracheAusgedrückt stelltGegenüber verwandt füllt beendet frequenz graphenTeil grösserAls grösserAlsOderGleich hatZweck hatFähigkeit hältWährend hatVerpflichtung hatRecht loch identitätsElement direkterFall direckteTeilkategorie inListe imBereichInteresses vergrössertWahrscheinlichkeit Unabhänigkeitswahrscheinlichkeit wohnt hemmt ausgangsList fall umkehrFunktion irreflexivAur grösser kleinerAls kleinerAlsOderGleich weise material mass mitglied modalesAttribute decktSichZeitlich elternteil teilweiseEinrichtung fülltTeilweise befindetSichTeils pfadLänge dringtEin besitzt vorbedingung verhindert korrektesTeil fülltRichtig eigenschaft veröffentlicht &%bildbereich von %1 ist ein fall von %2 {nicht} bildbereichTeilkategorie realizierung beziehtSichAuf reflexivAuf verwandtesInnenkonzept geschwister kleiner beginnt teilAttribut teilsammlung teilGraph teilliste subProzess %1 ist eine &%teilangelegenheit von %2 %n{nicht} teilkategorie teilrelation fasstInhaltsKategorieZusammen fasstInhaltsFallZusammen nachfolgerAttribut nachfolgerAttributSchliessung fläche zeitlichesTeil zeitlichZwischen zeitlichZwischenOderGleichzeitig zeit gesamteinrichtung trichotomizierungAuf verwendet valenz version

Type restrictions

meetsTemporally(Zeitabstand, Zeitabstand)

Related WordNet synsets

See more related synsets on a separate page.

Axioms (31)

interval1 schliesst interval2 zeitlich an nur wenn "das ende von interval1" ist gleich "der anfang von interval2" .

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

Wenn thing ist ein fall von körperlicher Gegenstand , dann "vor "die zeit des Bestehens von thing"" schliesst "die zeit des Bestehens von thing" zeitlich an.

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

Wenn thing ist ein fall von körperlicher Gegenstand , dann "die zeit des Bestehens von thing" schliesst "nach "die zeit des Bestehens von thing"" zeitlich an.

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

Wenn day1 ist ein fall von "der tag number1" und day2 ist ein fall von "der tag number2" und "(number2-number1)" ist gleich , dann day1 schliesst day2 zeitlich an.

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

Wenn hour1 ist ein fall von "die stunde number1" und hour2 ist ein fall von "die stunde number2" und "(number2-number1)" ist gleich , dann hour1 schliesst hour2 zeitlich an.

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

Wenn minute1 ist ein fall von "die minute number1" und minute2 ist ein fall von "die minute number2" und "(number2-number1)" ist gleich , dann minute1 schliesst minute2 zeitlich an.

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

Wenn second1 ist ein fall von "die sekund number1" und second2 ist ein fall von "die sekund number2" und "(number2-number1)" ist gleich , dann second1 schliesst second2 zeitlich an.

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

Wenn year1 ist ein fall von Jahr und year2 ist ein fall von Jahr und "(year2-year1)" ist gleich , dann year1 schliesst year2 zeitlich an.

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

Wenn month1 ist gleich "der monat Januar" und month2 ist gleich "der monat Februar" , dann month1 schliesst month2 zeitlich an.

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

Wenn month1 ist gleich "der monat Februar" und month2 ist gleich "der monat März" , dann month1 schliesst month2 zeitlich an.

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

Wenn month1 ist gleich "der monat März" und month2 ist gleich "der monat April" , dann month1 schliesst month2 zeitlich an.

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

Wenn month1 ist gleich "der monat April" und month2 ist gleich "der monat Mai" , dann month1 schliesst month2 zeitlich an.

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

Wenn month1 ist gleich "der monat Mai" und month2 ist gleich "der monat Juni" , dann month1 schliesst month2 zeitlich an.

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

Wenn month1 ist gleich "der monat Juni" und month2 ist gleich "der monat Juli" , dann month1 schliesst month2 zeitlich an.

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

Wenn month1 ist gleich "der monat Juli" und month2 ist gleich "der monat August" , dann month1 schliesst month2 zeitlich an.

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

Wenn month1 ist gleich "der monat August" und month2 ist gleich "der monat September" , dann month1 schliesst month2 zeitlich an.

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

Wenn month1 ist gleich "der monat September" und month2 ist gleich "der monat Oktober" , dann month1 schliesst month2 zeitlich an.

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

Wenn month1 ist gleich "der monat Oktober" und month2 ist gleich "der monat November" , dann month1 schliesst month2 zeitlich an.

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

Wenn month1 ist gleich "der monat November" und month2 ist gleich "der monat Dezember" , dann month1 schliesst month2 zeitlich an.

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

Wenn month1 ist gleich "der monat Dezember" und month2 ist gleich "der monat Januar" und year1 schliesst year2 zeitlich an, dann month1 schliesst month2 zeitlich an.

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

Wenn day1 ist ein fall von Montag und day2 ist ein fall von Dienstag und week ist ein fall von Woche und day1 ist ein teil von week und day2 ist ein teil von week , dann day1 schliesst day2 zeitlich an.

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

Wenn day1 ist ein fall von Dienstag und day2 ist ein fall von Mittwoch und week ist ein fall von Woche und day1 ist ein teil von week und day2 ist ein teil von week , dann day1 schliesst day2 zeitlich an.

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

Wenn day1 ist ein fall von Mittwoch und day2 ist ein fall von Donnerstag und week ist ein fall von Woche und day1 ist ein teil von week und day2 ist ein teil von week , dann day1 schliesst day2 zeitlich an.

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

Wenn day1 ist ein fall von Donnerstag und day2 ist ein fall von Freitag und week ist ein fall von Woche und day1 ist ein teil von week und day2 ist ein teil von week , dann day1 schliesst day2 zeitlich an.

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

Wenn day1 ist ein fall von Freitag und day2 ist ein fall von Samstag und week ist ein fall von Woche und day1 ist ein teil von week und day2 ist ein teil von week , dann day1 schliesst day2 zeitlich an.

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

Wenn day1 ist ein fall von Samstag und day2 ist ein fall von Sonntag und week ist ein fall von Woche und day1 ist ein teil von week und day2 ist ein teil von week , dann day1 schliesst day2 zeitlich an.

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

Wenn day1 ist ein fall von Sonntag und day2 ist ein fall von Montag und week1 ist ein fall von Woche und week2 ist ein fall von Woche und day1 ist ein teil von week1 und day2 ist ein teil von week2 und week1 schliesst week2 zeitlich an, dann day1 schliesst day2 zeitlich an.

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

wenn "Aufspaltung von interval auf ? interval-types" ist gleich class ,
dann für jeden time1,time2 gilt: wenn time1 ist ein fall von class und time2 ist ein fall von class und time1 ist gleich time2 nicht, dann time1 schliesst time2 zeitlich an oder time2 schliesst time1 zeitlich an oder time1 geschieht früh als time2 oder time2 geschieht früh als 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)))))

wenn "Aufspaltung von interval auf ? interval-types" ist gleich class ,
dann für jeden time1 gilt: wenn time1 ist ein fall von class und time1 beendet interval nicht, dann es gibt ein class time2 der time1 schliesst time2 zeitlich an

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

wenn "Aufspaltung von interval auf ? interval-types" ist gleich class ,
dann für jeden time1 gilt: wenn time1 ist ein fall von class und time1 beginnt interval nicht, dann es gibt ein class time2 der time2 schliesst time1 zeitlich an

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

Wenn death ist ein fall von Tod und birth ist ein fall von Geburt und agent erfährt death und agent erfährt birth , dann es gibt ein time der "die zeit des Bestehens von birth" schliesst time zeitlich an und time schliesst "die zeit des Bestehens von death" zeitlich an und "living ist ein attribut von agent " hält während 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)))))