> [!note]
> This is a bit of an experimental type of note. Dunno if it's useful or will work at all.
The following is an off-the-cuff, overly-academic description of terms (and their relations) about "systems" and "processes". Probably mostly borrowed from [[OPM]], but stated in my own simple terms. This is more ideating for [[Aaron's Hypothetical Modeling Tool]].
![[System_Process_Ontology.excalidraw.png]]
# Entities
## Thing
- Like [[OPM]], I'd probably include the term "thing" as an abstract supertype of all other terms, encompassing entities.
## System
- A system is a thing that exists consisting of different parts which, when considered together, achieve a purpose
- See [[What is a System]], and in particular the [[What is a System#Features of Systems]]
### Component
- A component is a part of a system.
- All components could (probably) be considered systems of themselves, too, but it's not always useful to do so
- Components are functionally indistinct from systems, I'd consider them as aliases
## Object
- An object is a component in a system which cannot carry out processes
- What [[Archimate]] would call "passive structure"
## Agent / Actor
- A component in a system which can carry out processes
- What [[Archimate]] would call "active structure"
## Mechanism
- A thing that enables (i.e. is required by) a process, but does not drive it nor is it consumed by it
- Covers things like tools & instruction sets
## Attribute
- A property that is exhibited by a thing
## State
- A condition of an object
- Some states are mutually exclusive, whereas others can coexist
- States are related to attributes - they may be explicitly linked to an individual or comprised of several
## Process
- A process is a thing that happens.
- A process takes time to happen.
- A process transforms or generates an object or event, this is assumed to be the *purpose* of the process and its value
### Step
- A part of a process
- All steps could (probably) be considered processes of themselves, too, but it's not always useful to do so.
- Steps are functionally indistinct from processes, I'd consider them as aliases
## Event
- An event is a thing that has happened at a point in time.
### Trigger
- Any event which causes a [[#Process]] to become invoked by an agent
# Relations
## Is A
- For sub-typing
## Triggers
- Event triggers process
## Fires
- Process starting or completing creates an Event
- the link connecting the process to the event should specify `[On start]` or `[On complete]`
- Object state changes can create an Event
- Agents can create Events
## Transforms
- A process transforms an object
### Consumes
- A type of transformation - a process that consumes an object destroys it
### Generates
- A type of transformation - a process can generate an object into existence
## Performs
- An agent performs a process
## Utilizes
- A Thing utilizes another Thing (general relationship)
- Agents and processes can both utilize a objects and/or mechanisms
## Follows
- Process follows another process
- Used in conjunction with or in absence of `process → fires event → triggers process` chains
## Has
- Thing has an Attribute
## Is In
- An object is in a specific state
## Contains
- A Thing can contain other things.
- Systems contain other systems, and contain any other Thing
- Processes contain other processes.
- objects contain other objects.
---
Description document generated by Gemini, modified by me:
```Markdown
Here is the updated and finalized Markdown document summarizing the ontology.
# Entities
## Thing
A fundamental building block. Every other term is a type of Thing. **Textual Representation:** `[Thing Name]`
## System
A collection of things working together for a purpose. **Textual Representation:** `{System Name}`
## Object
A tangible item or piece of information that is created or used. **Textual Representation:** `(Object Name)`
## Process
An action or series of actions that takes time to happen. **Textual Representation:** `[Process Name]`
## Agent
A thing that performs a process. **Textual Representation:** `(Agent Name)`
## Mechanism
A thing that is required by a process but is not consumed. **Textual Representation:** `<Mechanism Name>`
## Event
A specific occurrence that happens at a single point in time. **Textual Representation:** `*Event Name*`
## Attribute
A property or characteristic of a Thing. **Textual Representation:** `:Attribute Name:`
## State
A specific condition or status of an Object. **Textual Representation:** `(Object Name)` (when `in State Name`)
---
# Relations
## Is A / Has Subtype
One thing is a more specific type of another.
- `[Thing A]` → `is a` → `[Thing B]`
- `(Object A)` → `is a` → `(Object B)`
- `[Process A]` → `is a` → `[Process B]`
- `(Agent A)` → `is a` → `(Agent B)`
## Has / Is Had By
One thing has an attribute.
- `[Thing]` → `has` → `:Attribute:`
## Contains / Is Contained By
One thing is made up of or holds other things.
- `{System}` → `contains` → `[Thing]`
- `[Process]` → `contains` → `[Process]`
- `(Object)` → `contains` → `(Object)`
## Performs / Is Performed By
An agent carries out a process.
- `(Agent)` → `performs` → `[Process]`
## Utilizes / Is Utilized By
One thing uses another.
- `{System}` → `utilizes` → `[Process]`
- `[Process]` → `utilizes` → `(Object)`
- `[Process]` → `utilizes` → `<Mechanism>`
- `(Agent)` → `utilizes` → `[Process]`
- `(Agent)` → `utilizes` → `(Object)`
- `(Agent)` → `utilizes` → `<Mechanism>`
## Transforms / Is Transformed By
A process changes an object. This includes generating and consuming.
- `[Process]` → `transforms` → `(Object)`
## Generates / Is Generated By
A process brings a new object into existence.
- `[Process]` → `generates` → `(Object)`
## Consumes / Is Consumed By
A process uses up or destroys an object.
- `[Process]` → `consumes` → `(Object)`
## Is In / Holds
An object is in a specific state.
- `(Object)` → `is in` → `(State)`
## Triggers / Is Triggered By
An event causes a process to start.
- `*Event*` → `triggers` → `[Process]`
## Fires / Is Fired By
A thing creates an event.
- `[Process]` → `fires` → `*Event*`
- `(Object)` → `fires` → `*Event*`
- `(Agent)` → `fires` → `*Event*`
## Follows / Followed By
A process leads to another in a sequence.
- `[Process A]` → `follows` → `[Process B]`
## Affects / Is Affected By
A process changes an attribute or a state of a thing.
- `[Process]` → `affects` → `(State)`
- `[Process]` → `affects` → `:Attribute:`
---
# Example: Making a Sandwich
**Entities:**
- `{Kitchen}`
- `(Chef)`
- `(Knife)`
- `(Bread)`
- `(Deli Meat)`
- `(Cheese)`
- `(Sandwich)`
- `[Slice Ingredients Process]`
- `[Assemble Sandwich Process]`
- `[Eating Process]`
- `*Hunger Event*`
- `:Sharpness:`
**Relationships:**
- `{Kitchen}` `contains` `(Chef)`
- `{Kitchen}` `contains` `(Knife)`
- `(Chef)` `has` `:Hunger:`
- `(Knife)` `has` `:Sharpness:`
- `*Hunger Event*` `triggers` `[Assemble Sandwich Process]`
- `(Chef)` `performs` `[Assemble Sandwich Process]`
- `[Assemble Sandwich Process]` `utilizes` `<Knife>`
- `[Assemble Sandwich Process]` `consumes` `(Bread)`
- `[Assemble Sandwich Process]` `consumes` `(Deli Meat)`
- `[Assemble Sandwich Process]` `consumes` `(Cheese)`
- `[Assemble Sandwich Process]` `generates` `(Sandwich)`
- `(Sandwich)` `is in` `(Whole)` state
- `[Assemble Sandwich Process]` `fires` `*Sandwich Ready Event*`
- `[Eating Process]` `follows` `[Assemble Sandwich Process]` `[if Sandwich is Whole]`
```
****
# More
## Source
- long conversation with Gemini based on ideas I've gleaned from OPM and other things