physical (Physical)

An entity that has a location in space-time. Note that locations are themselves understood to have a location in space-time.

Ontology

SUMO / BASE-ONTOLOGY

Superclass(es)

entity

physical

Subclass(es)

object process

Coordinate term(s)

abstract

Constrains relations

when fn where fn cooccur date distance has purpose has purpose for agent located refers represents for agent represents in language time

Related WordNet synsets

entity, something: anything having existence (living or nonliving)
phenomenon: any state or process known through the senses rather than by intuition or reasoning
natural order: the physical universe considered as an orderly system subject to natural (not human or supernatural) laws
spatiotemporal, spaciotemporal: existing in both space and time; having both spatial extension and temporal duration

See more related synsets on a separate page.

Axioms (11)

entity is exhaustively partitioned into physical,abstract.

(partition Entity Physical Abstract)

physical is exhaustively partitioned into object,process.

(partition Physical Object Process)

phys is an instance of physical if and only if there exist loc,time so that phys is located at loc and phys exists during time.

(<=>
      (instance ?PHYS Physical)
      (exists
            (?LOC ?TIME)
            (and
                  (located ?PHYS ?LOC)
                  (time ?PHYS ?TIME))))

If rel(inst1,inst2) holds during interval and inst1 is an instance of physical and inst2 is an instance of physical, then inst1 exists during interval and inst2 exists during interval.

(=>
      (and
            (holdsDuring
                  ?INTERVAL
                  (holds ?REL ?INST1 ?INST2))
            (instance ?INST1 Physical)
            (instance ?INST2 Physical))
      (and
            (time ?INST1 ?INTERVAL)
            (time ?INST2 ?INTERVAL)))

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 thing is an instance of physical, then "before "the time of existence of thing"" meets "the time of existence of thing".

(=>
      (instance ?THING Physical)
      (meetsTemporally
            (PastFn
                  (WhenFn ?THING))
            (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 thing is an instance of physical, then "immediately before "the time of existence of thing"" finishes "before "the time of existence of thing"".

(=>
      (instance ?THING Physical)
      (finishes
            (ImmediatePastFn
                  (WhenFn ?THING))
            (PastFn
                  (WhenFn ?THING))))

If thing is an instance of physical, then "the time of existence of thing" meets "after "the time of existence of thing"".

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

If process is an instance of physical, then "after "the time of existence of process"" is equal to "interval between "the end of "the time of existence of process"" and positive infinity".

(=>
      (instance ?PROCESS Physical)
      (equal
            (FutureFn
                  (WhenFn ?PROCESS))
            (TimeIntervalFn
                  (EndFn
                        (WhenFn ?PROCESS))
                  PositiveInfinity)))

If thing is an instance of physical, then "immediately after "the time of existence of thing"" starts "after "the time of existence of thing"".

(=>
      (instance ?THING Physical)
      (starts
            (ImmediateFutureFn
                  (WhenFn ?THING))
            (FutureFn
                  (WhenFn ?THING))))