sub process (subProcess)

(subProcess subproc proc) means that subproc is a subprocess of proc. A subprocess is here understood as a temporally distinguished part (proper or not) of a Process.

Ontology

SUMO / PROCESSES

Class(es)

class

inheritable relation

binary predicate
is instance of

partial ordering relation
is instance of

sub process

Coordinate term(s)

arc weight authors before or equal causes causes subclass citizen closed on connected contains information cooccur copy date decreases likelihood developmental form disjoint distributes documentation duration earlier editor element employs equal equivalence relation on exploits expressed in language faces family relation finishes frequency graph part greater than greater than or equal to has purpose has skill holds during holds obligation holds right hole identity element 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 located material measure meets temporally modal attribute overlaps temporally parent part partial ordering on partly located path length possesses precondition prevents property publishes range range subclass refers reflexive on related internal concept sibling smaller starts sub attribute sub collection sub graph sub list sub proposition subclass subrelation subsumes content class subsumes content instance successor attribute successor attribute closure temporal part time total ordering on trichotomizing on uses valence version

Type restrictions

subProcess(process, process)

Related WordNet synsets

See more related synsets on a separate page.

Axioms (19)

If subproc is a subprocess of proc, then "the time of existence of subproc" is equal to "the time of existence of proc" or "the time of existence of subproc" takes place during "the time of existence of proc".

(=>
      (subProcess ?SUBPROC ?PROC)
      (or
            (equal
                  (WhenFn ?SUBPROC)
                  (WhenFn ?PROC))
            (during
                  (WhenFn ?SUBPROC)
                  (WhenFn ?PROC))))

if subproc is a subprocess of proc,
then for all region holds: if proc is located at region, then subproc is located at region

(=>
      (subProcess ?SUBPROC ?PROC)
      (forall
            (?REGION)
            (=>
                  (located ?PROC ?REGION)
                  (located ?SUBPROC ?REGION))))

If proc is an instance of process and subproc is a subprocess of proc, then there exists time so that subproc exists during time.

(=>
      (and
            (instance ?PROC Process)
            (subProcess ?SUBPROC ?PROC))
      (exists
            (?TIME)
            (time ?SUBPROC ?TIME)))

If digest is an instance of digesting, then there exists chemical decomposition decomp so that decomp is a subprocess of digest.

(=>
      (instance ?DIGEST Digesting)
      (exists
            (?DECOMP)
            (and
                  (instance ?DECOMP ChemicalDecomposition)
                  (subProcess ?DECOMP ?DIGEST))))

If sub is an instance of substituting, then there exist putting put,removing remove,obj1,obj2,place so that put is a subprocess of sub and remove is a subprocess of sub and obj1 is a patient of remove and remove origins at place and obj2 is a patient of put and put ends at place and obj1 is not equal to obj2.

(=>
      (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)))))

If give is an instance of unilateral giving, then there doesn't exist transaction trans so that give is a subprocess of trans.

(=>
      (instance ?GIVE UnilateralGiving)
      (not
            (exists
                  (?TRANS)
                  (and
                        (instance ?TRANS Transaction)
                        (subProcess ?GIVE ?TRANS)))))

If get is an instance of unilateral getting, then there doesn't exist transaction trans so that get is a subprocess of trans.

(=>
      (instance ?GET UnilateralGetting)
      (not
            (exists
                  (?TRANS)
                  (and
                        (instance ?TRANS Transaction)
                        (subProcess ?GET ?TRANS)))))

If trans is an instance of transaction, then there exist agent1,agent2,giving give1,giving give2,obj1,obj2 so that give1 is a subprocess of trans and give2 is a subprocess of trans and give1 is an agent of agent1 and give2 is an agent of agent2 and obj1 is a patient of give1 and obj2 is a patient of give2 and give1 ends at agent2 and give2 ends at agent1 and agent1 is not equal to agent2 and obj1 is not equal to obj2.

(=>
      (instance ?TRANS Transaction)
      (exists
            (?AGENT1 ?AGENT2 ?GIVE1 ?GIVE2 ?OBJ1 ?OBJ2)
            (and
                  (instance ?GIVE1 Giving)
                  (instance ?GIVE2 Giving)
                  (subProcess ?GIVE1 ?TRANS)
                  (subProcess ?GIVE2 ?TRANS)
                  (agent ?GIVE1 ?AGENT1)
                  (agent ?GIVE2 ?AGENT2)
                  (patient ?GIVE1 ?OBJ1)
                  (patient ?GIVE2 ?OBJ2)
                  (destination ?GIVE1 ?AGENT2)
                  (destination ?GIVE2 ?AGENT1)
                  (not
                        (equal ?AGENT1 ?AGENT2))
                  (not
                        (equal ?OBJ1 ?OBJ2)))))

If act is an instance of surgery and animal is a patient of act, then there exists cutting subact so that animal is an instance of animal and cutting is a patient of animal and subact is a subprocess of act.

(=>
      (and
            (instance ?ACT Surgery)
            (patient ?ACT ?ANIMAL))
      (exists
            (?SUBACT)
            (and
                  (instance ?SUBACT Cutting)
                  (instance ?ANIMAL Animal)
                  (patient ?ANIMAL ?CUTTING)
                  (subProcess ?SUBACT ?ACT))))

If combustion is an instance of combustion, then there exist heating heat,radiating light light so that heat is a subprocess of combustion and light is a subprocess of combustion.

(=>
      (instance ?COMBUSTION Combustion)
      (exists
            (?HEAT ?LIGHT)
            (and
                  (instance ?HEAT Heating)
                  (instance ?LIGHT RadiatingLight)
                  (subProcess ?HEAT ?COMBUSTION)
                  (subProcess ?LIGHT ?COMBUSTION))))

If war is an instance of war, then there exists battle battle so that battle is a subprocess of war.

(=>
      (instance ?WAR War)
      (exists
            (?BATTLE)
            (and
                  (instance ?BATTLE Battle)
                  (subProcess ?BATTLE ?WAR))))

If battle is an instance of battle, then there exists war war so that battle is a subprocess of war.

(=>
      (instance ?BATTLE Battle)
      (exists
            (?WAR)
            (and
                  (instance ?WAR War)
                  (subProcess ?BATTLE ?WAR))))

If battle is an instance of battle, then there exists violent contest attack so that attack is a subprocess of battle.

(=>
      (instance ?BATTLE Battle)
      (exists
            (?ATTACK)
            (and
                  (instance ?ATTACK ViolentContest)
                  (subProcess ?ATTACK ?BATTLE))))

If move is an instance of maneuver, then there exists contest contest so that move is a subprocess of contest.

(=>
      (instance ?MOVE Maneuver)
      (exists
            (?CONTEST)
            (and
                  (instance ?CONTEST Contest)
                  (subProcess ?MOVE ?CONTEST))))

If tactile is an instance of tactile perception, then there exists touching touch so that touch is a subprocess of tactile.

(=>
      (instance ?TACTILE TactilePerception)
      (exists
            (?TOUCH)
            (and
                  (instance ?TOUCH Touching)
                  (subProcess ?TOUCH ?TACTILE))))

If melt is an instance of melting, then there exists heating heat so that heat is a subprocess of melt.

(=>
      (instance ?MELT Melting)
      (exists
            (?HEAT)
            (and
                  (instance ?HEAT Heating)
                  (subProcess ?HEAT ?MELT))))

If boil is an instance of boiling, then there exists heating heat so that heat is a subprocess of boil.

(=>
      (instance ?BOIL Boiling)
      (exists
            (?HEAT)
            (and
                  (instance ?HEAT Heating)
                  (subProcess ?HEAT ?BOIL))))

If cond is an instance of condensing, then there exists cooling cool so that cool is a subprocess of cond.

(=>
      (instance ?COND Condensing)
      (exists
            (?COOL)
            (and
                  (instance ?COOL Cooling)
                  (subProcess ?COOL ?COND))))

If freeze is an instance of freezing, then there exists cooling cool so that cool is a subprocess of freeze.

(=>
      (instance ?FREEZE Freezing)
      (exists
            (?COOL)
            (and
                  (instance ?COOL Cooling)
                  (subProcess ?COOL ?FREEZE))))