meets temporally (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)

Classe

inheritable relation

PredicatoBinario
is instance of

Classe

inheritable relation

RelazioneTemporale
is instance of

RelazioneAsimmetrica
is instance of

RelazioneIntransitiva
is instance of

meets temporally

Coordinate term(s)

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

Type restrictions

meetsTemporally(IntervalloTemporale, IntervalloTemporale)

Related WordNet synsets

See more related synsets on a separate page.

Axioms (31)

interval1 incontras interval2 se e solo se "la fine di interval1" is uguale a "l' inizio di interval2".

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

Se thing é un' istanza di EntitáConcreta, allora "prima "il tempo di esistenza di thing"" incontras "il tempo di esistenza di thing".

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

Se thing é un' istanza di EntitáConcreta, allora "il tempo di esistenza di thing" incontras "dopo "il tempo di esistenza di thing"".

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

Se day1 é un' istanza di "il giorno number1" e day2 é un' istanza di "il giorno number2" e "(number2-number1" is uguale a , allora day1 incontras day2.

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

Se hour1 é un' istanza di "l' ora number1" e hour2 é un' istanza di "l' ora number2" e "(number2-number1" is uguale a , allora hour1 incontras hour2.

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

Se minute1 é un' istanza di "il minutonumber1" e minute2 é un' istanza di "il minutonumber2" e "(number2-number1" is uguale a , allora minute1 incontras minute2.

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

Se second1 é un' istanza di "il secondo number1" e second2 é un' istanza di "il secondo number2" e "(number2-number1" is uguale a , allora second1 incontras second2.

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

Se year1 é un' istanza di Anno e year2 é un' istanza di Anno e "(year2-year1" is uguale a , allora year1 incontras year2.

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

Se month1 is uguale a "il mese Gennaio" e month2 is uguale a "il mese Febbraio", allora month1 incontras month2.

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

Se month1 is uguale a "il mese Febbraio" e month2 is uguale a "il mese Marzo", allora month1 incontras month2.

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

Se month1 is uguale a "il mese Marzo" e month2 is uguale a "il mese Aprile", allora month1 incontras month2.

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

Se month1 is uguale a "il mese Aprile" e month2 is uguale a "il mese Maggio", allora month1 incontras month2.

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

Se month1 is uguale a "il mese Maggio" e month2 is uguale a "il mese Giugno", allora month1 incontras month2.

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

Se month1 is uguale a "il mese Giugno" e month2 is uguale a "il mese Luglio", allora month1 incontras month2.

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

Se month1 is uguale a "il mese Luglio" e month2 is uguale a "il mese Agosto", allora month1 incontras month2.

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

Se month1 is uguale a "il mese Agosto" e month2 is uguale a "il mese Settembre", allora month1 incontras month2.

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

Se month1 is uguale a "il mese Settembre" e month2 is uguale a "il mese Ottobre", allora month1 incontras month2.

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

Se month1 is uguale a "il mese Ottobre" e month2 is uguale a "il mese Novembre", allora month1 incontras month2.

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

Se month1 is uguale a "il mese Novembre" e month2 is uguale a "il mese Dicembre", allora month1 incontras month2.

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

Se month1 is uguale a "il mese Dicembre" e month2 is uguale a "il mese Gennaio" e year1 incontras year2, allora month1 incontras month2.

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

Se day1 é un' istanza di Lunedí e day2 é un' istanza di Martedí e week é un' istanza di Settimana e day1 é una parte diweek e day2 é una parte diweek, allora day1 incontras day2.

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

Se day1 é un' istanza di Martedí e day2 é un' istanza di Mercoledí e week é un' istanza di Settimana e day1 é una parte diweek e day2 é una parte diweek, allora day1 incontras day2.

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

Se day1 é un' istanza di Mercoledí e day2 é un' istanza di Giovedí e week é un' istanza di Settimana e day1 é una parte diweek e day2 é una parte diweek, allora day1 incontras day2.

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

Se day1 é un' istanza di Giovedí e day2 é un' istanza di Venerdí e week é un' istanza di Settimana e day1 é una parte diweek e day2 é una parte diweek, allora day1 incontras day2.

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

Se day1 é un' istanza di Venerdí e day2 é un' istanza di Sabato e week é un' istanza di Settimana e day1 é una parte diweek e day2 é una parte diweek, allora day1 incontras day2.

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

Se day1 é un' istanza di Sabato e day2 é un' istanza di Domenica e week é un' istanza di Settimana e day1 é una parte diweek e day2 é una parte diweek, allora day1 incontras day2.

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

Se day1 é un' istanza di Domenica e day2 é un' istanza di Lunedí e week1 é un' istanza di Settimana e week2 é un' istanza di Settimana e day1 é una parte diweek1 e day2 é una parte diweek2 e week1 incontras week2, allora day1 incontras 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))

se "decomposizione di interval in ? interval-types" is uguale a class,
allora per ogni time1,time2 vale: se time1 é un' istanza di class e time2 é un' istanza di class e time1 is not uguale a time2, allora time1 incontras time2 o time2 incontras time1 o time1 accades prima di time2 o time2 accades prima di 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)))))

se "decomposizione di interval in ? interval-types" is uguale a class,
allora per ogni time1 vale: se time1 é un' istanza di class e time1 non finisce interval, allora esiste class time2 tale che time1 incontras 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))))))

se "decomposizione di interval in ? interval-types" is uguale a class,
allora per ogni time1 vale: se time1 é un' istanza di class e time1 non inizia interval, allora esiste class time2 tale che time2 incontras 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))))))

Se death é un' istanza di Morte e birth é un' istanza di Nascita e agent esperisces death e agent esperisces birth, allora esiste time tale che "il tempo di esistenza di birth" incontras time e time incontras "il tempo di esistenza di death" e "living is an attribute of agent" vales durante 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)))))