> [!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