vor (before)

(before point1 point2) means that point1 precedes point2 on the universal timeline.

Ontology

SUMO / TEMPORAL-CONCEPTS

Class(es)

Kategorie

inheritable relation

zeitliche Relation
is instance of

irreflexive Relation
is instance of

transitive Relation
is instance of

vor

Superrelation(s)

vorOderGleichzeitig

vor

Coordinate term(s)

RückseiteFn AnfangFn TagFn EndeFn FrontseiteFn ZukunftFn StundeFn SofortigeZukunftFn DirektVergangenheitFn MinuteFn MonatFn VergangenheitFn RückläufigeZeitAbstandFn RelativeZeitFn SekundFn ZeitlicheAufbauFn ZeitabstandFn WennFn JahrFn attribut vorOderGleichzeitig angeschlosseneTechnikKomponenten zusammenGeschiecht kreuzt verringertWahrscheinlichkeit entwicklungsForm disjunkt während früh beendet graphenTeil grösserAls inListe vergrössertWahrscheinlichkeit hemmt innenteil grösser kleinerAls weise schliesstRäumlichAn schliesstZeitlichAn modalesAttribute decktSichTeilweise decktSichZeitlich pfadLänge vorbedingung verhindert korrektesTeil geschwister kleiner beginnt teilsammlung teilGraph unterOrganisation teilplan %1 ist eine &%teilangelegenheit von %2 %n{nicht} nachfolgerAttributSchliessung oberflächichesTeil zeitlichZwischen zeitlichZwischenOderGleichzeitig zeit version

Type restrictions

before(Zeitpunkt, Zeitpunkt)

Related WordNet synsets

precession, precedence: the act of preceding
earliness: quality of coming early or earlier in time
priority, antecedence, antecedency, anteriority, precedence: preceding in time

See more related synsets on a separate page.

Axioms (19)

Wenn point ist ein fall von Zeitpunkt und point ist gleich positive infinity nicht, dann point geschieht vor positive infinity .

(=>
      (and
            (instance ?POINT TimePoint)
            (not
                  (equal ?POINT PositiveInfinity)))
      (before ?POINT PositiveInfinity))

Wenn point ist ein fall von Zeitpunkt und point ist gleich negative infinity nicht, dann negative infinity geschieht vor point .

(=>
      (and
            (instance ?POINT TimePoint)
            (not
                  (equal ?POINT NegativeInfinity)))
      (before NegativeInfinity ?POINT))

wenn "der anfang von interval" ist gleich point ,
dann für jeden otherpoint gilt: wenn otherpoint ist ein teil von interval und otherpoint ist gleich point nicht, dann point geschieht vor otherpoint

(=>
      (equal
            (BeginFn ?INTERVAL)
            ?POINT)
      (forall
            (?OTHERPOINT)
            (=>
                  (and
                        (temporalPart ?OTHERPOINT ?INTERVAL)
                        (not
                              (equal ?OTHERPOINT ?POINT)))
                  (before ?POINT ?OTHERPOINT))))

wenn "das ende von interval" ist gleich point ,
dann für jeden otherpoint gilt: wenn otherpoint ist ein teil von interval und otherpoint ist gleich point nicht, dann otherpoint geschieht vor point

(=>
      (equal
            (EndFn ?INTERVAL)
            ?POINT)
      (forall
            (?OTHERPOINT)
            (=>
                  (and
                        (temporalPart ?OTHERPOINT ?INTERVAL)
                        (not
                              (equal ?OTHERPOINT ?POINT)))
                  (before ?OTHERPOINT ?POINT))))

interval1 beginnt interval2 nur wenn "der anfang von interval1" ist gleich "der anfang von interval2" und "das ende von interval1" geschieht vor "das ende von interval2" .

(<=>
      (starts ?INTERVAL1 ?INTERVAL2)
      (and
            (equal
                  (BeginFn ?INTERVAL1)
                  (BeginFn ?INTERVAL2))
            (before
                  (EndFn ?INTERVAL1)
                  (EndFn ?INTERVAL2))))

interval1 beendet interval2 nur wenn "der anfang von interval2" geschieht vor "der anfang von interval1" und "das ende von interval2" ist gleich "das ende von interval1" .

(<=>
      (finishes ?INTERVAL1 ?INTERVAL2)
      (and
            (before
                  (BeginFn ?INTERVAL2)
                  (BeginFn ?INTERVAL1))
            (equal
                  (EndFn ?INTERVAL2)
                  (EndFn ?INTERVAL1))))

vor ist innerlich verwandt mit früh .

(relatedInternalConcept before earlier)

wenn obj ist ein fall von Gegenstand ,
dann es gibt ein Zeitpunkt time1,Zeitpunkt time2 der time1 geschieht vor time2 und für jeden time gilt: wenn time1 geschieht vor oder gleichzeitig mit time und time geschieht vor oder gleichzeitig mit time2 , dann obj besteht während time

(=>
      (instance ?OBJ Object)
      (exists
            (?TIME1 ?TIME2)
            (and
                  (instance ?TIME1 TimePoint)
                  (instance ?TIME2 TimePoint)
                  (before ?TIME1 ?TIME2)
                  (forall
                        (?TIME)
                        (=>
                              (and
                                    (beforeOrEqual ?TIME1 ?TIME)
                                    (beforeOrEqual ?TIME ?TIME2))
                              (time ?OBJ ?TIME))))))

wenn obj ist ein resultat von proc ,
dann für jeden time gilt: wenn time geschieht vor "der anfang von "die zeit des Bestehens von proc"" , dann obj besteht während time nicht

(=>
      (result ?PROC ?OBJ)
      (forall
            (?TIME)
            (=>
                  (before
                        ?TIME
                        (BeginFn
                              (WhenFn ?PROC)))
                  (not
                        (time ?OBJ ?TIME)))))

Wenn point1 geschieht vor oder gleichzeitig mit point2 , dann point1 geschieht vor point2 oder point1 ist gleich point2 .

(=>
      (beforeOrEqual ?POINT1 ?POINT2)
      (or
            (before ?POINT1 ?POINT2)
            (equal ?POINT1 ?POINT2)))

point2 ist zwischen point1 und point3 nur wenn point1 geschieht vor point2 und point2 geschieht vor point3 .

(<=>
      (temporallyBetween ?POINT1 ?POINT2 ?POINT3)
      (and
            (before ?POINT1 ?POINT2)
            (before ?POINT2 ?POINT3)))

Wenn interval1 geschieht während interval2 , dann "das ende von interval1" geschieht vor "das ende von interval2" und "der anfang von interval2" geschieht vor "der anfang von interval1" .

(=>
      (during ?INTERVAL1 ?INTERVAL2)
      (and
            (before
                  (EndFn ?INTERVAL1)
                  (EndFn ?INTERVAL2))
            (before
                  (BeginFn ?INTERVAL2)
                  (BeginFn ?INTERVAL1))))

interval1 geschieht früh als interval2 nur wenn "das ende von interval1" geschieht vor "der anfang von interval2" .

(<=>
      (earlier ?INTERVAL1 ?INTERVAL2)
      (before
            (EndFn ?INTERVAL1)
            (BeginFn ?INTERVAL2)))

Wenn thing ist ein fall von körperlicher Gegenstand , dann "der anfang von "die zeit des Bestehens von thing"" geschieht vor "das ende von "die zeit des Bestehens von thing"" .

(=>
      (instance ?THING Physical)
      (before
            (BeginFn
                  (WhenFn ?THING))
            (EndFn
                  (WhenFn ?THING))))

Wenn predict ist ein fall von Voraussagen und formula ist ein patient von predict , dann es gibt ein time der formula hält während time und time geschieht vor "die zeit des Bestehens von predict" oder time geschieht früh als "die zeit des Bestehens von predict" .

(=>
      (and
            (instance ?PREDICT Predicting)
            (patient ?PREDICT ?FORMULA))
      (exists
            (?TIME)
            (and
                  (holdsDuring ?TIME ?FORMULA)
                  (or
                        (before
                              ?TIME
                              (WhenFn ?PREDICT))
                        (earlier
                              ?TIME
                              (WhenFn ?PREDICT))))))

Wenn remember ist ein fall von Erinnern und formula ist ein patient von remember , dann es gibt ein time der formula hält während time und time geschieht vor "die zeit des Bestehens von remember" oder time geschieht früh als "die zeit des Bestehens von remember" .

(=>
      (and
            (instance ?REMEMBER Remembering)
            (patient ?REMEMBER ?FORMULA))
      (exists
            (?TIME)
            (and
                  (holdsDuring ?TIME ?FORMULA)
                  (or
                        (before
                              ?TIME
                              (WhenFn ?REMEMBER))
                        (earlier
                              ?TIME
                              (WhenFn ?REMEMBER))))))

Wenn parent ist das elterntiel von child , dann "der anfang von "die zeit des Bestehens von parent"" geschieht vor "der anfang von "die zeit des Bestehens von child"" .

(=>
      (parent ?CHILD ?PARENT)
      (before
            (BeginFn
                  (WhenFn ?PARENT))
            (BeginFn
                  (WhenFn ?CHILD))))

Wenn "ausgabe int1 von text" ist gleich edition1 und "ausgabe int2 von text" ist gleich edition2 und int2 ist grösserAls int1 und pub1 ist ein fall von Publikation und pub2 ist ein fall von Publikation und edition1 ist ein patient von pub1 und edition2 ist ein patient von pub2 und datum von pub1 ist date1 und datum von pub2 ist date2 , dann "das ende von date1" geschieht vor "das ende von date2" .

(=>
      (and
            (equal
                  (EditionFn ?TEXT ?INT1)
                  ?EDITION1)
            (equal
                  (EditionFn ?TEXT ?INT2)
                  ?EDITION2)
            (greaterThan ?INT2 ?INT1)
            (instance ?PUB1 Publication)
            (instance ?PUB2 Publication)
            (patient ?PUB1 ?EDITION1)
            (patient ?PUB2 ?EDITION2)
            (date ?PUB1 ?DATE1)
            (date ?PUB2 ?DATE2))
      (before
            (EndFn ?DATE1)
            (EndFn ?DATE2)))

Wenn text ist eine teilkategorie von Zeitschrift und "Band int1 in der reihe text" ist gleich volume1 und "Band int2 in der reihe text" ist gleich volume2 und int2 ist grösserAls int1 und pub1 ist ein fall von Publikation und pub2 ist ein fall von Publikation und volume1 ist ein patient von pub1 und volume2 ist ein patient von pub2 und datum von pub1 ist date1 und datum von pub2 ist date2 , dann "das ende von date1" geschieht vor "das ende von date2" .

(=>
      (and
            (subclass ?TEXT Periodical)
            (equal
                  (SeriesVolumeFn ?TEXT ?INT1)
                  ?VOLUME1)
            (equal
                  (SeriesVolumeFn ?TEXT ?INT2)
                  ?VOLUME2)
            (greaterThan ?INT2 ?INT1)
            (instance ?PUB1 Publication)
            (instance ?PUB2 Publication)
            (patient ?PUB1 ?VOLUME1)
            (patient ?PUB2 ?VOLUME2)
            (date ?PUB1 ?DATE1)
            (date ?PUB2 ?DATE2))
      (before
            (EndFn ?DATE1)
            (EndFn ?DATE2)))