origin (origin)

(origin process source) means that source indicates where the process began. Note that this relation implies that source is present at the beginning of the process, but need not participate throughout the process. For example, the submarine is the origin in the following proposition: the missile was launched from a submarine.

Ontology

SUMO / BASE-ONTOLOGY

Class(es)

Kategorie

inheritable relation

Fallrolle

origin

Coordinate term(s)

agent bestimmungsort richtung experiencer pfad patient

Type restrictions

origin(Prozess, Gegenstand)

Related WordNet synsets

origin, origination, genesis, inception: an event that is a beginning; a first part or stage of subsequent events
originate in: come from

See more related synsets on a separate page.

Axioms (11)

Wenn process beginnet an obj , dann "die Stelle wo process an "der anfang von "die zeit des Bestehens von process"" war" befindet sich an .

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

Wenn motion ist ein fall von Bewegung und obj ist ein patient von motion und motion beginnet an place , dann "obj befindet sich an " hält während "direkt vor "die zeit des Bestehens von motion"" .

(=>
      (and
            (instance ?MOTION Motion)
            (patient ?MOTION ?OBJ)
            (origin ?MOTION ?PLACE))
      (holdsDuring
            (ImmediatePastFn
                  (WhenFn ?MOTION))
            (located ?OBJ ?PLACE)))

wenn
- path1 ist der pfad entlang dem process geschieht
- process beginnet an source
- process endet an dest
- die länge von path1 ist measure1
- es gibt kein path2,measure2 der path2 ist der pfad entlang dem process geschieht und process beginnet an origin und process endet an dest und die länge von path2 ist measure2 und measure2 ist kleinerAls measure1
,
dann für jeden obj gilt: wenn obj ist ein teil von path1 , dann obj ist zwischen source und dest

(=>
      (and
            (path ?PROCESS ?PATH1)
            (origin ?PROCESS ?SOURCE)
            (destination ?PROCESS ?DEST)
            (length ?PATH1 ?MEASURE1)
            (not
                  (exists
                        (?PATH2 ?MEASURE2)
                        (and
                              (path ?PROCESS ?PATH2)
                              (origin ?PROCESS ?ORIGIN)
                              (destination ?PROCESS ?DEST)
                              (length ?PATH2 ?MEASURE2)
                              (lessThan ?MEASURE2 ?MEASURE1)))))
      (forall
            (?OBJ)
            (=>
                  (part ?OBJ ?PATH1)
                  (between ?SOURCE ?OBJ ?DEST))))

Wenn remove ist ein fall von Entfernen und remove beginnet an place und obj ist ein patient von remove , dann "obj befindet sich an " hält während "direkt vor "die zeit des Bestehens von remove"" und "obj befindet sich an nicht" hält während "sofort nach "die zeit des Bestehens von remove"" .

(=>
      (and
            (instance ?REMOVE Removing)
            (origin ?REMOVE ?PLACE)
            (patient ?REMOVE ?OBJ))
      (and
            (holdsDuring
                  (ImmediatePastFn
                        (WhenFn ?REMOVE))
                  (located ?OBJ ?PLACE))
            (holdsDuring
                  (ImmediateFutureFn
                        (WhenFn ?REMOVE))
                  (not
                        (located ?OBJ ?PLACE)))))

Wenn sub ist ein fall von Ersetzen , dann es gibt ein Setzen put,Entfernen remove,obj1,obj2,place der put ist ein subProzess von sub und remove ist ein subProzess von sub und obj1 ist ein patient von remove und remove beginnet an place und obj2 ist ein patient von put und put endet an place und obj1 ist gleich obj2 nicht.

(=>
      (instance ?SUB Substituting)
      (exists
            (?PUT ?REMOVE ?OBJ1 ?OBJ2 ?PLACE)
            (and
                  (instance ?PUT Putting)
                  (instance ?REMOVE Removing)
                  (subProcess ?PUT ?SUB)
                  (subProcess ?REMOVE ?SUB)
                  (patient ?REMOVE ?OBJ1)
                  (origin ?REMOVE ?PLACE)
                  (patient ?PUT ?OBJ2)
                  (destination ?PUT ?PLACE)
                  (not
                        (equal ?OBJ1 ?OBJ2)))))

Wenn change ist ein fall von Änderung des Besitzes und change beginnet an agent1 und change endet an agent2 und agent2 ist ein fall von Agent und obj ist ein patient von change , dann "agent1 besitzt obj " hält während "direkt vor "die zeit des Bestehens von change"" und "agent2 besitzt obj " hält während "sofort nach "die zeit des Bestehens von change"" .

(=>
      (and
            (instance ?CHANGE ChangeOfPossession)
            (origin ?CHANGE ?AGENT1)
            (destination ?CHANGE ?AGENT2)
            (instance ?AGENT2 Agent)
            (patient ?CHANGE ?OBJ))
      (and
            (holdsDuring
                  (ImmediatePastFn
                        (WhenFn ?CHANGE))
                  (possesses ?AGENT1 ?OBJ))
            (holdsDuring
                  (ImmediateFutureFn
                        (WhenFn ?CHANGE))
                  (possesses ?AGENT2 ?OBJ))))

Wenn give ist ein fall von Geben und give ist der agent von agent1 und give endet an agent2 und agent2 ist ein fall von Agent und obj ist ein patient von give , dann es gibt ein Erhalten get der get ist der agent von agent2 und get beginnet an agent1 und obj ist ein patient von get .

(=>
      (and
            (instance ?GIVE Giving)
            (agent ?GIVE ?AGENT1)
            (destination ?GIVE ?AGENT2)
            (instance ?AGENT2 Agent)
            (patient ?GIVE ?OBJ))
      (exists
            (?GET)
            (and
                  (instance ?GET Getting)
                  (agent ?GET ?AGENT2)
                  (origin ?GET ?AGENT1)
                  (patient ?GET ?OBJ))))

Wenn give ist ein fall von Geben und give ist der agent von agent , dann give beginnet an agent .

(=>
      (and
            (instance ?GIVE Giving)
            (agent ?GIVE ?AGENT))
      (origin ?GIVE ?AGENT))

Es gibt ein Borgen borrow der borrow ist der agent von agent1 und borrow beginnet an agent2 und object ist ein patient von borrow nur wenn es gibt ein Verleihen lend der lend ist der agent von agent2 und lend endet an agent1 und object ist ein patient von lend .

(<=>
      (exists
            (?BORROW)
            (and
                  (instance ?BORROW Borrowing)
                  (agent ?BORROW ?AGENT1)
                  (origin ?BORROW ?AGENT2)
                  (patient ?BORROW ?OBJECT)))
      (exists
            (?LEND)
            (and
                  (instance ?LEND Lending)
                  (agent ?LEND ?AGENT2)
                  (destination ?LEND ?AGENT1)
                  (patient ?LEND ?OBJECT))))

Es gibt ein Kaufen buy der buy ist der agent von agent1 und buy beginnet an agent2 und object ist ein patient von buy nur wenn es gibt ein Verkaufen sell der sell ist der agent von agent2 und sell endet an agent1 und object ist ein patient von sell .

(<=>
      (exists
            (?BUY)
            (and
                  (instance ?BUY Buying)
                  (agent ?BUY ?AGENT1)
                  (origin ?BUY ?AGENT2)
                  (patient ?BUY ?OBJECT)))
      (exists
            (?SELL)
            (and
                  (instance ?SELL Selling)
                  (agent ?SELL ?AGENT2)
                  (destination ?SELL ?AGENT1)
                  (patient ?SELL ?OBJECT))))

Wenn sell ist ein fall von Verkaufen und sell ist der agent von agent , dann sell beginnet an agent .

(=>
      (and
            (instance ?SELL Selling)
            (agent ?SELL ?AGENT))
      (origin ?SELL ?AGENT))