begin fn (BeginFn)

A UnaryFunction that maps a TimeInterval to the TimePoint at which the interval begins.

Ontology

SUMO / TEMPORAL-CONCEPTS

Class(es)

class

inheritable relation

temporal relation
is instance of

class

inheritable relation

unary function
is instance of

begin fn

Coordinate term(s)

absolute value fn abstraction fn arc cosine fn arc sine fn arc tangent fn back fn begin node fn cardinality fn ceiling fn complement fn cosine fn cut set fn day fn denominator fn end fn end node fn extension fn floor fn front fn future fn generalized intersection fn generalized union fn giga fn hour fn imaginary part fn immediate future fn immediate past fn initial node fn integer square root fn kilo fn list length fn magnitude fn mega fn micro fn milli fn minimal cut set fn minute fn month fn nano fn numerator fn organization fn past fn path weight fn pico fn power set fn predecessor fn principal host fn probability fn property fn rational number fn real number fn reciprocal fn recurrent time interval fn relative time fn round fn second fn signum fn sine fn skin fn square root fn successor fn tangent fn temporal composition fn tera fn terminal node fn time interval fn wealth fn when fn year fn before before or equal cooccur earlier finishes meets temporally overlaps temporally temporally between temporally between or equal time

Type restrictions

time point BeginFn(time interval)

Related WordNet synsets

beginning: the event consisting of the start of something: "the beginning of the war"
birth: the time when something begins (especially life); "they divorced after the birth of the child" or "his election signaled the birth of a new age"
terminus a quo, starting point: earliest limiting point

See more related synsets on a separate page.

Axioms (16)

if "the beginning of interval" is equal to point,
then for all otherpoint holds: if otherpoint is a part of interval and otherpoint is not equal to point, then point happen?{s} before otherpoint

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

If process origins at obj, then "the place where process was at "the beginning of "the time of existence of process""" is located at "the place where obj was at "the beginning of "the time of existence of obj""".

(=>
      (origin ?PROCESS ?OBJ)
      (located
            (WhereFn
                  ?PROCESS
                  (BeginFn
                        (WhenFn ?PROCESS)))
            (WhereFn
                  ?OBJ
                  (BeginFn
                        (WhenFn ?OBJ)))))

interval1 starts interval2 if and only if "the beginning of interval1" is equal to "the beginning of interval2" and "the end of interval1" happen?{s} before "the end of interval2".

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

interval1 finishes interval2 if and only if "the beginning of interval2" happen?{s} before "the beginning of interval1" and "the end of interval2" is equal to "the end of interval1".

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

if obj is a result of proc,
then for all time holds: if time happen?{s} before "the beginning of "the time of existence of proc"", then obj doesn't exist during time

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

phys exists during time and time is an instance of time point if and only if time is between or at "the beginning of "the time of existence of phys"" and "the end of "the time of existence of phys"".

(<=>
      (and
            (time ?PHYS ?TIME)
            (instance ?TIME TimePoint))
      (temporallyBetweenOrEqual
            (BeginFn
                  (WhenFn ?PHYS))
            ?TIME
            (EndFn
                  (WhenFn ?PHYS))))

If interval1 takes place during interval2, then "the end of interval1" happen?{s} before "the end of interval2" and "the beginning of interval2" happen?{s} before "the beginning of interval1".

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

interval1 meets interval2 if and only if "the end of interval1" is equal to "the beginning of interval2".

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

If "the beginning of interval1" is equal to "the beginning of interval2" and "the end of interval1" is equal to "the end of interval2", then interval1 is equal to interval2.

(=>
      (and
            (equal
                  (BeginFn ?INTERVAL1)
                  (BeginFn ?INTERVAL2))
            (equal
                  (EndFn ?INTERVAL1)
                  (EndFn ?INTERVAL2)))
      (equal ?INTERVAL1 ?INTERVAL2))

interval1 happens earlier than interval2 if and only if "the end of interval1" happen?{s} before "the beginning of interval2".

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

If "interval between point1 and point2" is equal to interval, then "the beginning of interval" is equal to point1 and "the end of interval" is equal to point2.

(=>
      (equal
            (TimeIntervalFn ?POINT1 ?POINT2)
            ?INTERVAL)
      (and
            (equal
                  (BeginFn ?INTERVAL)
                  ?POINT1)
            (equal
                  (EndFn ?INTERVAL)
                  ?POINT2)))

If thing is an instance of physical, then "the beginning of "the time of existence of thing"" happen?{s} before "the end of "the time of existence of thing"".

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

If process is an instance of physical, then "before "the time of existence of process"" is equal to "interval between negative infinity and "the beginning of "the time of existence of process""".

(=>
      (instance ?PROCESS Physical)
      (equal
            (PastFn
                  (WhenFn ?PROCESS))
            (TimeIntervalFn
                  NegativeInfinity
                  (BeginFn
                        (WhenFn ?PROCESS)))))

If parent is a parent of child, then "the beginning of "the time of existence of parent"" happen?{s} before "the beginning of "the time of existence of child"".

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

if artifact is an instance of stationary artifact,
then there exists place so that for all time holds: if time happen?{s} before or at "the end of "the time of existence of artifact"" and "the beginning of "the time of existence of artifact"" happen?{s} before or at time, then "the place where artifact was at time" is equal to place

(=>
      (instance ?ARTIFACT StationaryArtifact)
      (exists
            (?PLACE)
            (forall
                  (?TIME)
                  (=>
                        (and
                              (beforeOrEqual
                                    ?TIME
                                    (EndFn
                                          (WhenFn ?ARTIFACT)))
                              (beforeOrEqual
                                    (BeginFn
                                          (WhenFn ?ARTIFACT))
                                    ?TIME))
                        (equal
                              (WhereFn ?ARTIFACT ?TIME)
                              ?PLACE)))))

If fully formed is an attribute of obj, then there exists growth growth so that obj experiences growth and non fully formed is an attribute of obj the beginning of "the time of existence of obj".

(=>
      (attribute ?OBJ FullyFormed)
      (exists
            (?GROWTH)
            (and
                  (instance ?GROWTH Growth)
                  (experiencer ?GROWTH ?OBJ)
                  (holdsDuring
                        (BeginFn
                              (WhenFn ?OBJ))
                        (attribute ?OBJ NonFullyFormed)))))