# Category-Theoretic Formulation of the Model-Based Systems Architecting Cognitive-Computational Cycle

^{1}

^{2}

^{*}

## Abstract

**:**

## Simple Summary

## Abstract

## 1. Introduction

_{1}) as primary DSE services. Management tools, interoperability services, digital representations, systems, things, auditing, and reporting services (MIDSTAR

_{2}) are regarded as primary interfaces. We shall refer collectively to such results or artifacts following model processing or analysis as views of those models.

^{2}matrix of inter-component dependencies [16]. UML Activity Diagrams assume a “swimlane” layout that helps divide complex multi-participant activities with columns. Sequence Diagrams apply a similar idea, using vertically-aligned lifelines as anchors for input and output exchange steps [17].

## 2. Related Work

#### 2.1. Object–Process Methodology (OPM)

#### 2.2. Graph Data Structures (GDS)

_{1}, R, N

_{2}> reads: “N

_{1}R N

_{2}”, “R connects N

_{1}to N

_{2}”, or “the direction of R is from N

_{1}to N

_{2}”. Arrows can have types, values, and additional attributes. Figure 3i shows a simple directed graph with one type of arrow and a value index. Graphs lend themselves to various representations and visualizations, including matrices. Figure 3ii presents the graph in (i) as an adjacency matrix. The rows and columns of the adjacency matrix are the nodes of the graph, and the cells represent the values or labels of the edges.

#### 2.3. Stakeholder-Informing Matrices (SIM)

_{i}that participate in an Exhibition–Characterization relation to S: Exhibition(S,E

_{i}) or Characterization(E

_{i},S). Input(P

_{column}) is the set of entities E

_{i}with an Instrument(E

_{i,}P

_{column}) or Consumption(E

_{i,}P

_{column}) relation to P

_{column}. A 3x3 SAM, consisting of Processes, Operands (inputs, resources, and outputs), and Components, is illustrated in Table 1b, based on [24]. Each sub-SAM has a relation with which the row item relates to the column item, which can be static or dynamic. A row–cell–column tuple in the matrix would read: <row item (iRow)> <cell item (iRow, iCol)> <column item(iCol)>. For example: [Process P2] requires [Operand O2]; [Component C3] exhibits [Process P2].

#### 2.4. Category Theory in Systems Engineering

#### 2.4.1. What Is a Category?

#### 2.4.2. How Are Systems, Models, and Categories Related?

#### 2.4.3. Applications of Category Theory in Systems Engineering, Analysis, and Design

#### 2.5. Transforming Models to Graphs

## 3. Methods

_{1}, …, M

_{M}, to all views V

_{1}, …, V

_{V}.

**Proposition**

**1:**

**Proposition**

**2:**

**Proposition**

**3:**

**Proposition**

**4:**

**Proposition**

**5.**

#### 3.1. The Conceptual System Architecture as a Category

#### 3.2. The Modeling Language as a Category

#### 3.3. Transforming Models to Graphs

- 0.
- ML types are defined as RSTUV identity tuples. This step is only done once per ML.
- 1.
- Entities are mapped to their OPM entity type (model, diagram, object, process, etc.) using a Classification relation.
- 2.
- Relations, such that E
_{i}and E_{j}are entities connected by relation R, are mapped as is. - 3.
- Each entity E
_{j}is mapped to any diagram D_{i}that includes it by an Inclusion relation. - 4.
- Relations are mapped to any diagram that includes them by an Inclusion relation.
- 5.
- Affiliations of entities (systemic/environmental) are mapped as Affiliation relations.
- 6.
- Essences of entities (physical/informatical) are mapped as Essence relations [4].

- 7.
- Entities are mapped to universally-unique identification numbers (UUIDs) as an Identity relation that constitutes the identity morphism of each entity onto itself.
- 8.
- Relations are mapped to UUIDs through an Identity relation that constitutes the identity morphism of each relation onto itself.

`OPM.ExportedReport`).

`ExportedReport`provides most of the information needed for analyzing an OPM model (It does not include shape positions in the diagrams, and therefore, it is not possible to reconstruct the diagrams with the shapes’ exact positioning, but only up to the participation of elements in each diagram).

`ExportedReport`, we generate two interim categories:

`ElementDictionary`and

`OPLSpec`. We refer to both objects as sets, but due to the complicated and heterogenous structure of set members, we need further decomposition and transformation of set members to their appropriate data structures. For example, we need to find the OPDs in which each Object and Process appear (

`ObjectOPDs`and

`ProcessOPDs`).

`ElementDictionary`does not specify appearance of relations in OPDs, but the statements referring to the relations are specified in the OPL text accompanying each OPD. To extract this information, we need to analyze

`OPLSpec`, identify the sentence that specifies each relation under the diagrams in which it is shown, and match the OPD→

`OPLStatement`relation to the right Relation.

`A`generic transformation function,

`OntologyMapping`, converts or extends ontological terms and executes all parts of the OPML→GDS functor.

`OntologyMapping`starts from the raw input representing external models and other sources of information (e.g.,

`OPM.ExportedReport`). It continues recursively to either create new items or extend existing ones. The

`ExportedReport→ElementDictionary`transform and the following three transforms

`ElementDictionary→{ObjectElement, ProcessElement, RelationSet}`create new items sets.

`RelationSet`is further transformed into a new set of

`Relation`items. This step is due to OPCloud’s exported report clustering of all relations of the same type in groups.

`OntologyMapping`extends

`ObjectElement`with attributes such as

`IsObject`,

`ObjectName`, and

`ObjectStates`. It similarly extends

`ProcessElement`with the attributes

`IsProcess`,

`ProcessOPDs`etc., and

`RelationSet`with the attributes

`RelationBlock`,

`RelationSource`, and

`RelationTarget`.

`OntologyMapping`allows it to recursively search for additional mappings needed due to the creation of new items, but it would first make sure all the extended attributes are computed, because those attributes might be needed for creating new items. For instance, to create

`RSTUVCandidates`that cover all the relevant relations pertaining to the Process item, we need to know which OPDs the process is in, and create a separate

`RSTUVCandidate`with R = ‘Inclusion’, S =

`ProcessElement(p).ProcessOPD`, and T =

`ProcessElement(p).Process`, where p is a member of the

`ProcessElement`set, p = 1…,|

`ProcessElement`|.

`OntologyMapping`also supports mapping and classifying items as Identity Attributes—attributes whose values are converted to Identity and Classification relations.

- The Identity relation maps each entry to a universally unique ID (UUID).
- The Classification relation maps each entry to its type, which is the attribute name. For example, each item in the Diagram column is mapped to an
`RSTUVTuple`with R = ’Classification’, S = ‘OPM.Diagram’, and T =`Item.UUID`.

`OPM.ObjectState`attributes are mapped to a set of RST tuples with R = StateSpecification, S = {item in

`OPM.Object`: the

`ObjectElement`}, and T = {items in

`OPM.ObjectState`—one or more names of states}. For triplets of Source, Target, and Relation attributes, each triplet of attributes values maps directly into an

`RSTUVTuple`. For example: under the

`OPM.Relation`block, R =

`Relation`, S = {one object, process, or state}, T = {one object, process, or state}.

`RSTUVCandidate`referring to the same relation, source, and target entities might be created from multiple blocks. For example, identity tuples for

`OPM.Diagram`can be generated for both

`ObjectElement`and

`ProcessElement`. OPDs may have two

`RSTUVCandidates`: one due to including an object, and one due to including a process. This is because diagram names are not defined separately in

`ElementDictionary`, only indirectly through the listing of OPDs in which each object and process are visualized. Only one copy of each RST must be kept.

#### 3.4. Transforming Graphs to Views and SIMs

#### 3.5. Transforming Views into Concepts, and Concepts back into Models

## 4. Implementation

`OntologyMapping`functionality. It first reads and transforms the raw data from the model files, which can be MS Excel, PDF, XML, or JSON. The Rules file defines a set of ontology mapping rules. The program reads these mapping rules for the ML of the processed model, and applies them to the raw model. Accordingly, intermediate representations are formed, and may be subject to additional mapping. Therefore, the processing is recursive and returns until no additional mapping rules are applicable to the resulting data set.

`ProcessElement`to

`RSTUVCandidate`is shown in Figure 10. The JSON object can define identity attributes (

`identityVars`); Source-Target attribute pairs with a specified relation (

`sourceTargetPairs`); and Relation-Source-Target triplets (

`relationSourceTargetTriplets`). The mapping function combinatorically searches for all valid pair and triplet permutations and creates a set of unique RSTUV candidates. The mechanism only keeps the first appearance of similar RSTUV candidates with the same RST. Finally, a set of GDS tuples is created.

## 5. Assessment

- M→G→V (a GDS-mediated transformation from model to view) is superior to M→V (a direct transformation from model to view)
- M→G→V is superior to M→R→V (a transformation mediated by a language-bound representation, LBR)
- M→G is a feasible and valid transformation.
- G→V is a feasible and valid transformation.
- G→SIM is a feasible and valid transformation.

- MV: Direct generation of views from a model, that we denote V(M) or MV
- MRV: Indirect generation of views from a model via a common DSML-specific representation, that we would demote V(R
_{DSML}(M_{DSML})) or MRV

- C1—Efficiency is measured by the number of required transformations of M models to V views. For MGV, MRV: sum of model-to-graph transformations (M) and graph-to-view transformations (V); for MV: product of models by views ($M\xb7V$).
- C2—Flexibility is measured by the effort of creating new views for existing models. For MGV, MRV: one effort unit per view (graph-to-view or LBR-to-view); for M: M effort units (models-to-view).
- C3—Robustness is measured by the effort of creating existing views for new models: For MGV: a single effort unit (model-to-graph); for MV: V effort units (model-to-views); for MRV: V+1 effort units (model-to- LBR and LBR-to-views).
- C4—Resilience is measured by the dependency on DSML updates: for MGV, MRV: a single effort unit for updates (model-to-graph or model-to-LBR); for MV: V effort units (model-to-views).

## 6. Application

#### 6.1. Representation and Analysis of Process-to-Process Input–Output Exchange

- Find all the processes, i.e., targets in tuples with S = ‘OPM.Process’ and R = ‘Classification’.
- Find all outputs, i.e., targets in tuples where R = ‘Result’, and retrieve the source process item.
- Find all tuples in which the above outputs are sources in a Consumption relation (i.e., inputs), and retrieve the target process items.
- Cross the process–output set with the input–process set such that output = input.
- Cross process set (1) with output-generating process set (2). Keep all processes including those that are generating no output.
- Cross process set (1) with input-receiving process set (3). Keep all processes including those that are receiving no input.
- Layout a matrix with output-generating processes as rows, input-receiving processes as columns, and identity of matching output-input (onput [81]) item as cells.

#### 6.2. The Lane Keeping System Revisited

`Lane Crossing`object has no source, and that the Road is consumed by the

`Imaging Road`process, rather than remain an instrument as it was specified in the topmost diagram. It is difficult to ensure continuity and consistency this way, and the problem intensifies as the model grows bigger with more objects, processes, and diagrams.

## 7. Discussion

## 8. Conclusions

- Using the CMGVC, stakeholders and decision-makers will be able to derive critical information and insight regarding system development and operation from the system model, rather than through a disparate information gathering and presentation channel, which is the common practice today.
- The preferential dominance that we have proven in Section 5 facilitates efficiency in model analytics, and thus encourages further adoption.
- The transition through GDS enhances system understanding by adding another modality: graphs, which map concepts and relations through one common substantial representation.
- The simple-yet-robust GDS can be a prime facilitator of MBSE interoperability and collaboration across digital value chains.
- Subject matter experts will be able to leverage the CMGVC via semantic and ontological frameworks to better represent emerging patterns and concepts.

## Author Contributions

## Funding

## Data Availability Statement

## Acknowledgments

## Conflicts of Interest

## Acronyms and Glossary Terms

Acronym | Full Term |

CMGVC | Concept→Model→Graph→View Cycle |

DSM | Design Structure Matrix |

GDS | Graph Data Structure |

GR | Generic Representation |

MBSE | Model-Based Systems Engineering |

MGV | Model→Graph→View |

ML | Modeling Language |

OPM | Object–process Methodology |

OPML | Object–process Modeling Language |

SAM | System Architecture Matrix |

SIM | Stakeholder-Informing Matrix |

UUID | Universal Unique ID |

## References

- Partridge, C.; Gonzalez-Perez, C.; Henderson-Sellers, B. Are conceptual models concept models? Lect. Notes Comput. Sci. Incl. Subser. Lect. Notes Artif. Intell. Lect. Notes Bioinform.
**2013**, 8217 LNCS, 96–105. [Google Scholar] [CrossRef] - Bailer-Jones, D.M. Scientific Models in Philosophy of Science; University of Pittsburgh Pre: Pittsburgh, PA, USA, 2009. [Google Scholar] [CrossRef]
- Soderborg, N.R.; Crawley, E.F.; Dori, D. System Function and Architecture: OPM-Based Definitions and Operational Templates. Commun. ACM
**2003**, 46, 67–72. [Google Scholar] [CrossRef] - Dori, D. Model-Based Systems Engineering with OPM and SysML; Springer: New York, NY, USA, 2016. [Google Scholar] [CrossRef]
- McDermott, T.A.; Hutchinson, N.; Clifford, M.; Van Aken, E.; Slado, A.; Henderson, K. Benchmarking the Benefits and Current Maturity of Model-Based Systems Engineering across the Enterprise; Systems Engineering Research Center (SERC): Hoboken, NJ, USA, 2020. [Google Scholar]
- Bondar, S.; Hsu, J.C.; Pfouga, A.; Stjepandić, J. Agile digital transformation of System-of-Systems architecture models using Zachman framework. J. Ind. Inf. Integr.
**2017**, 7, 33–43. [Google Scholar] [CrossRef] - Hale, J.P.; Zimmerman, P.; Kukkala, G.; Guerrero, J.; Kobryn, P.; Puchek, B.; Bisconti, M.; Baldwin, C.; Mulpuri, M. Digital Model-Based Engineering: Expectations, Prerequisites, and Challenges of Infusion; NASA: Washington, DC, USA, 2017. [Google Scholar]
- Bone, M.; Blackburn, M.; Kruse, B.; Dzielski, J.; Hagedorn, T.; Grosse, I. Toward an Interoperability and Integration Framework to Enable Digital Thread. Systems
**2018**, 6, 46. [Google Scholar] [CrossRef][Green Version] - Hagedorn, T.; Bone, M.; Kruse, B.; Grosse, I.; Blackburn, M. Knowledge Representation with Ontologies and Semantic Web Technologies to Promote Augmented and Artificial Intelligence in Systems Engineering. Insight
**2020**, 23, 15–20. [Google Scholar] [CrossRef] - Mordecai, Y.; de Weck, O.L.; Crawley, E.F. Towards an Enterprise Architecture for a Digital Systems Engineering Ecosystem. In Proceedings of the Conference on Systems Engineering Research (CSER), Virtual, Redondo Beach, CA, USA, 8–10 October 2020. [Google Scholar]
- Subrahmanian, E.; Levy, S.N.; Westerberg, A.W.; Monarch, I.; Konda, S.L.; Reich, Y. Equations aren’t enough: Informal modeling in design. Artif. Intell. Eng. Des. Anal. Manuf.
**1993**, 7, 257–274. [Google Scholar] [CrossRef][Green Version] - Sharpe, J.E.E.; Bracewell, R.H. Application of bond graph methodology to concurrent conceptual design of interdisciplinary systems. In Proceedings of the IEEE Systems Man and Cybernetics Conference—SMC, Le Touquet, France, 17–20 October 1993. [Google Scholar] [CrossRef]
- Ernadote, D. An ontology mindset for system engineering. In Proceedings of the 2015 IEEE International Symposium on Systems Engineering (ISSE), Rome, Italy, 28–30 September 2015; pp. 454–460. [Google Scholar] [CrossRef]
- Cotter, M.; Hadjimichael, M.; Markina-khusid, A.; York, B. Automated Detection of Architecture Patterns in MBSE Models. In Proceedings of the Conference on Systems Engineering Research (CSER), Redondo Beach, CA, USA, 8–10 October 2020. [Google Scholar]
- Reich, Y.; Konda, S.; Subrahmanian, E.; Cunningham, D.; Dutoit, A.; Patrick, R.; Thomas, M.; Westerberg, A.W. Building agility for developing agile design information systems. Res. Eng. Des. Theory Appl. Concurr. Eng.
**1999**, 11, 67–83. [Google Scholar] [CrossRef] - Dennis, A.R.; Hayes, G.S.; Daniels, R.M., Jr. Re-engineering business process modeling. In Proceedings of the 1994 Proceedings of the Twenty-Seventh Hawaii International Conference on System Sciences, Maui, HI, USA, 4–7 January 1994; pp. 244–253. [Google Scholar]
- Object Management Group (OMG). OMG Unified Modeling Language (OMG UML); OMG: Needham, MA, USA, 2015. [Google Scholar] [CrossRef]
- United States Department of Defense (DoD). The DoDAF Architecture Framework Version 2. Available online: https://dodcio.defense.gov/Library/DoD-Architecture-Framework/ (accessed on 3 December 2020).
- Fong, B.; Spivak, D.I. Seven Sketches in Compositionality: An Invitation to Applied Category Theory. arXiv
**2018**, arXiv:1803.05316. [Google Scholar] - Chakraborty, S. Curry-Howard-Lambek Correspondence; University of Calgary: Calgary, AB, Canada, 2011; Available online: http://pages.cpsc.ucalgary.ca/~robin/class/617/projects-10/Subashis.pdf (accessed on 3 December 2020).
- Hamilton, M. Category Theory and the Curry-Howard-Lambek Correspondence; Senior Seminar in Mathematics Lecture Notes; Yale University: New Haven, CT, USA, 2016; Available online: https://mhamilton.net/files/chl.pdf2016 (accessed on 3 December 2020).
- Naur, P. Programming as theory building. Microprocess. Microprogr.
**1985**, 15, 253–261. [Google Scholar] [CrossRef] - ISO/TC 184: ISO 19450 Automation Systems and Integration—Object-Process Methodology; International Organization for Standardization (ISO): Geneva, Switzerland, 2015.
- Crawley, E.; Cameron, B.; Selva, D. Systems Architecture: Strategy and Product Development for Complex Systems; Pearson Higher Education: Hoboken, NJ, USA, 2016. [Google Scholar]
- Mordecai, Y.; Dori, D. Model-Based Operational-Functional Unified Specification for Mission Systems. In Proceedings of the 10th Annual IEEE International Systems Conference (SysCon), Orlando, FL, USA, 18–21 April 2016. [Google Scholar] [CrossRef]
- Mordecai, Y.; Dori, D. Model-based requirements engineering: Architecting for system requirements with stakeholders in mind. In Proceedings of the IEEE International Symposium on Systems Engineering, ISSE, Vienna, Austria, 11–13 October 2017. [Google Scholar] [CrossRef]
- Osorio, C.A.; Dori, D.; Sussman, J. COIM: An Object-Process Based Method for Analyzing Architectures of Complex, Interconnected, Large-Scale Socio-Technical Systems. Syst. Eng.
**2011**, 14. [Google Scholar] [CrossRef][Green Version] - Dori, D.; Jbara, A.; Levi, N.; Wengrowicz, N. Object-Process Methodology, OPM ISO 19450—OPCloud and the Evolution of OPM Modeling Tools. Systems Engineering Newsletter (PPI SyEn), 61, 30 January 2018. Available online: https://www.ppi-int.com/wp-content/uploads/2021/01/SyEN-061.pdf (accessed on 3 December 2020).
- Levi-Soskin, N.; Shaoul, R.; Kohen, H.; Jbara, A.; Dori, D. Model-Based Diagnosis with FTTell: Assessing the Potential for Pediatric Failure to Thrive (FTT) During the Perinatal Stage. In SIGSAND/PLAIS, LNBIP 359; Wrycza, S., Maślankowski, J., Eds.; Springer Nature: Cham, Switzerland, 2019; pp. 37–47. [Google Scholar] [CrossRef]
- Dori, D.; Kohen, H.; Jbara, A.; Wengrowicz, N.; Lavi, R.; Levi-Soskin, N.; Bernstein, K.; Shani, U. OPCloud: An OPM Integrated Conceptual-Executable Modeling Environment for Industry 4. In Systems Engineering in the Fourth Industrial Revolution: Big Data, Novel Technologies, and Modern Systems Engineering; Kenett, R.S., Swarz, R.S., Zonnenshain, A., Eds.; Wiley: Hoboken, NJ, USA, 2020. [Google Scholar]
- Mordecai, Y.; James, N.K.; Crawley, E.F. Object-Process Model-Based Operational Viewpoint Specification for Aerospace Architectures. In Proceedings of the IEEE Aerospace Conference, Big Sky, MT, USA, 7–14 March 2020. [Google Scholar] [CrossRef]
- Ford Motor Company. Lane-Keeping System. Available online: https://www.youtube.com/watch?v=8O3u20MBmsE (accessed on 20 November 2020).
- Object Management Group. Unified Architecture Framework Profile (UAFP); Object Management Group: Needham, MA, USA, 2019. [Google Scholar]
- Browning, T.R. Design Structure Matrix Extensions and Innovations: A Survey and New Opportunities. IEEE Trans. Eng. Manag.
**2016**, 63, 27–52. [Google Scholar] [CrossRef] - Sharon, A.; Dori, D.; de Weck, O. Model-Based Design Structure Matrix: Deriving a DSM from an Object-Process Model. In Proceedings of the Second International Symposium on Engineering Systems, Cambridge, MA, USA, 15–17 June 2009. [Google Scholar]
- Sharon, A.; Dori, D. A Project–Product Model–Based Approach to Planning Work Breakdown Structures of Complex System Projects. IEEE Syst. J.
**2014**, 9, 366–376. [Google Scholar] [CrossRef] - Do, S.; Weck, O. De: A Grammar for Encoding and Synthesizing Life Support. In Proceedings of the 44th International Conference on Environmental Systems, Tucson, AZ, USA, 13–17 July 2014. [Google Scholar]
- Wilschut, T.; Etman, L.F.P.; Rooda, J.E.; Vogel, J.A. Generation of a function-component-parameter multi-domain matrix from structured textual function specifications. Res. Eng. Des.
**2018**, 29, 531–546. [Google Scholar] [CrossRef][Green Version] - Knippenberg, S.C.M.; Etman, L.F.P.; Wilschut, T.; van de Mortel-Fronczak, J.A. Specifying Process Activities for Multi-Domain Matrix Analysis Using a Structured Textual Format. Proc. Des. Soc. Int. Conf. Eng. Des.
**2019**, 1, 1613–1622. [Google Scholar] [CrossRef][Green Version] - Object Management Group. OMG Systems Modeling Language (OMG SysMLTM); Version 1.4; Object Management Group (OMG): Needham, MA, USA, 2015. [Google Scholar] [CrossRef]
- Au-Yong-Oliveira, M.; Moutinho, R.; Ferreira, J.J.P.; Ramos, A.L. Present and future languages—How innovation has changed us. J. Technol. Manag. Innov.
**2015**, 10, 166–182. [Google Scholar] [CrossRef][Green Version] - Johnson, J.M. Analysis of Mission Effectiveness: Modern System Architectures Tools for Project Developers; Naval Postgraduate School: Monterey, CA, USA, 2017. [Google Scholar]
- Kong, P.O. Spreadsheet-Based Graphical User Interface for Modeling of Products Using the Systems Engineering Process. US Patent 8,626,477, 7 January 2014. [Google Scholar]
- Wymore, W.A. Model-Based Systems Engineering; CRC Press: Boca Raton, FL, USA, 1993. [Google Scholar]
- Breiner, S.; Subrahmanian, E.; Jones, A. Categorical foundations for system engineering. Discip. Converg. Syst. Eng. Res.
**2017**, 449–463. [Google Scholar] [CrossRef] - Subrahmanian, E.; Reich, Y.; Krishnan, S. The Story of n-Dim. In We Are Not Users: Dialogues, Diversity, and Design; MIT Press: Cambridge, MA, USA, 2020; pp. 181–196. [Google Scholar] [CrossRef]
- Breiner, S.; Pollard, B.; Subrahmanian, E. Workshop on Applied Category Theory: Bridging Theory and Practice; NIST: Gaithersburg, MD, USA, 2020. [Google Scholar] [CrossRef]
- Patterson, E. Hausdorff and Wasserstein metrics on graphs and other structured data. Inf. Inference A J. IMA.
**2020**, iaaa025. [Google Scholar] [CrossRef] - Koo, H.-Y.B. A Meta-Language for Systems Architecting; Massachusetts Institute of Technology: Cambridge, MA, USA, 2005. [Google Scholar]
- Koo, B.; Hurd, A.; Loda, D.; Dori, D.; Crawley, E.F. Architecting Systems Under Uncertainty with Object-Process Networks. In Proceedings of the International Conference on Complex Systems (ICCS’04), Boston, MA, USA, 16–24 May 2004. [Google Scholar]
- Spivak, D.I.; Kent, R.E. Ologs: A categorical framework for knowledge representation. PLoS ONE
**2012**, 7, e24274. [Google Scholar] [CrossRef] [PubMed] - Mabrok, M.A.; Ryan, M.J. Category theory as a formal mathematical foundation for model-based systems engineering. Appl. Math. Inf. Sci.
**2017**, 11, 43–51. [Google Scholar] [CrossRef] - Censi, A. Uncertainty in Monotone Codesign Problems. IEEE Robot. Autom. Lett.
**2017**, 2, 1556–1563. [Google Scholar] [CrossRef] - Censi, A. A Class of Co-Design Problems with Cyclic Constraints and Their Solution. IEEE Robot. Autom. Lett.
**2017**, 2, 96–103. [Google Scholar] [CrossRef] - Legatiuk, D.; Dragos, K.; Smarsly, K. Modeling and evaluation of cyber-physical systems in civil engineering. Proc. Appl. Math. Mech.
**2017**, 17. [Google Scholar] [CrossRef][Green Version] - Bakirtzis, G.; Vasilakopoulou, C.; Fleming, C.H. Compositional Cyber-Physical Systems Modeling. Proc. ACT
**2020**, 333, 125–138. [Google Scholar] [CrossRef] - Kibret, N.; Edmonson, W.; Gebreyohannes, S. Category theoretic based formalization of the verifiable design process. In Proceedings of the 2019 IEEE International Systems Conference (SysCon), Orlando, FL, USA, 8–11 April 2019. [Google Scholar] [CrossRef]
- Gebreyohannes, S.; Edmonson, W.; Esterline, A. Formal behavioral requirements management. IEEE Syst. J.
**2018**, 12, 3006–3017. [Google Scholar] [CrossRef] - Breiner, S.; Sriram, R.D.; Subrahmanian, E. Compositional Models for Complex Systems. In Artificial Intelligence for the Internet of Everything; Academic Press: London, UK, 2019. [Google Scholar] [CrossRef]
- Kovalyov, S.P. Leveraging category theory in model based enterprise. Adv. Syst. Sci. Appl.
**2020**, 20, 50–65. [Google Scholar] [CrossRef] - Foley, J.D.; Breiner, S.; Subrahmanian, E.; Dusel, J.M. Operads for complex system design specification, analysis and synthesis. arXiv
**2021**, arXiv:2101.11115. [Google Scholar] - Breiner, S.; Pollard, B.; Subrahmanian, E.; Marie-Rose, O. Modeling hierarchical system with operads. Proc. ACT
**2020**. [Google Scholar] [CrossRef] - Diskin, Z.; Maibaum, T. Category theory and model-driven engineering: From formal semantics to design patterns and beyond. Proc. Seventh ACCAT Work. Appl. Comput. Categ. Theory
**2012**. [Google Scholar] [CrossRef][Green Version] - Diskin, Z.; Gómez, A.; Cabot, J. Traceability mappings as a fundamental instrument in model transformations. In Lecture Notes in Computer Science, Proceedings of the International Conference on Fundamental Approaches to Software Engineering, Uppsala, Sweden, 22–29 April 2017; Springer: Berlin/Heidelberg, Germany, 2017. [Google Scholar] [CrossRef]
- Korobeynikov, A.G.; Fedosovsky, M.E.; Gurjanov, A.V.; Zharinov, I.O.; Shukalov, A.V. Development of conceptual modeling method to solve the tasks of computer-aided design of difficult technical complexes on the basis of category theory. Int. J. Appl. Eng. Res.
**2017**, 12, 1114–1122. [Google Scholar] [CrossRef][Green Version] - Cafezeiro, I.; Haeusler, E.H. Semantic interoperability via category theory. In Proceedings of the 26th International Conference on Conceptual Modeling, Auckland, New Zealand, 5–9 November 2007. [Google Scholar]
- Luzeaux, D. A Formal Foundation of Systems Engineering. In Complex Systems Design & Management; Boulanger, F., Krob, D., Morel, G., Roussel, J.C., Eds.; Springer International Publishing: Cham, Switzerland, 2015. [Google Scholar] [CrossRef]
- Libkind, S. An Algebra of Resource Sharing Machines. arXiv
**2020**, arXiv:2007.14442. [Google Scholar] - Baez, J.C.; Fong, B.; Pollard, B.S. A compositional framework for Markov processes. J. Math. Phys.
**2016**, 57. [Google Scholar] [CrossRef][Green Version] - Halter, M.; Herlihy, C.; Fairbanks, J. A Compositional Framework for Scientific Model Augmentation. arXiv
**2019**, arXiv:1907.03536. [Google Scholar] [CrossRef] - Herlihy, C.; Cao, K.; Reparti, S.; Briscoe, E.; Fairbanks, J. Semantic Program Analysis for Scientific Model Augmentation. In Modeling the World’s Systems; Georgia Tech Research Institute: Washington, DC, USA, 2019. [Google Scholar]
- Halter, M.; Patterson, E.; Baas, A.; Fairbanks, J.P. Compositional Scientific Computing with Catlab and SemanticModels. arXiv
**2020**, arXiv:2005.04831. [Google Scholar] - Reich, Y.; Konda, S.L.; Levy, S.N.; Monarch, I.A.; Subrahmanian, E. New roles for machine learning in design. Artif. Intell. Eng.
**1993**, 8, 165–181. [Google Scholar] [CrossRef] - Needham, M.; Hodler, A.E. Graph Algorithms—Practical Examples in Apache Spark & Neo4j; O’Reilly Media, Inc.: Sebastopol, CA, USA, 2019. [Google Scholar]
- Webber, J.; Van Bruggen, R. Graph Databases; John Wiley & Sons, Inc.: Hoboken, NJ, USA, 2020. [Google Scholar]
- Medvedev, D.; Shani, U.; Dori, D. Gaining Insights into Conceptual Models: A Graph-Theoretic Querying Approach. Appl. Sci.
**2021**, 11, 765. [Google Scholar] [CrossRef] - Dori, D. ViSWeb—The Visual Semantic Web: Unifying human and machine knowledge representations with Object-Process Methodology. VLDB J.
**2004**, 13, 120–147. [Google Scholar] [CrossRef] - Shani, U.; Jacobs, S.; Wengrowicz, N.; Dori, D. Engaging ontologies to break MBSE tools boundaries through Semantic Mediation. In Proceedings of the Conference on Systems Engineering Research, Huntsville, AL, USA, 22–24 March 2016. [Google Scholar]
- Zhu, Y.; Wan, J.; Zhou, Z.; Chen, L.; Qiu, L.; Zhang, W.; Jiang, X.; Yu, Y. Triple-to-text: Converting RDF triples into high-quality natural languages via optimizing an inverse KL divergence. In Proceedings of the 42nd International ACM SIGIR Conference on Research and Development in Information Retrieval, Paris, France, 21–25 July 2019; Volume 1, pp. 455–464. [Google Scholar] [CrossRef][Green Version]
- Nadolski, M.; Fairbanks, J. Complex systems analysis of hybrid warfare. Procedia Comput. Sci.
**2019**, 153, 210–217. [Google Scholar] [CrossRef] - Mordecai, Y.; Orhof, O.; Dori, D. Model-Based Interoperability Engineering in Systems-of-Systems and Civil Aviation. IEEE Trans. Syst. Man Cybern. Syst.
**2018**, 48, 637–648. [Google Scholar] [CrossRef] - Thalheim, B. The Theory of Conceptual Models, the Theory of Conceptual Modelling and Foundations of Conceptual Modelling. In Handbook of Conceptual Modeling; Embley, D.W., Thalheim, B., Eds.; Springer: Berlin/Heidelberg, Germany, 2011; pp. 543–577. [Google Scholar] [CrossRef]
- Object Management Group. OMG Systems Modeling Language; Version 1.6; Object Management Group: Needham, MA, USA, 2019. [Google Scholar]
- Booch, G.; Rumbaugh, J.; Jacobson, I. The Unified Modeling Language User Guide; Addison Wesley: Reading, MA, USA, 1998. [Google Scholar]
- MathWorks: Graph with Directed Edges—MATLAB. Available online: https://www.mathworks.com/help/matlab/ref/digraph.html (accessed on 26 November 2020).
- Spivak, D.I. Databases are Categories. Galois Connections; Massachusetts Institute of Technology: Cambridge, MA, USA, 2010. [Google Scholar]
- Bucchiarone, A.; Cabot, J.; Paige, R.F.; Pierantonio, A. Grand challenges in model-driven engineering: An analysis of the state of the research. Softw. Syst. Model.
**2020**, 19, 5–13. [Google Scholar] [CrossRef][Green Version] - Zeigler, B.; Mittal, S.; Traore, M. MBSE with/out Simulation: State of the Art and Way Forward. Systems
**2018**, 6, 40. [Google Scholar] [CrossRef][Green Version] - NAFEMS; INCOSE. What Is Systems Modeling and Simulation? NAFEMS: Glasgow, UK, 2019; Available online: https://www.nafems.org/community/working-groups/systems-modeling-simulation/ (accessed on 22 February 2021).
- Mittal, S.; Zeigler, B.P.; Martin, J. Implementation of formal standard for interoperability in M&S/systems of systems integration with DEVS/SOA. Int. Command Control C2 J. Spec. Issue Model. Simul. Support Netw. Cent. Approaches Capab.
**2009**, 3, 1. [Google Scholar] - Abar, S.; Theodoropoulos, G.K.; Lemarinier, P.; O’Hare, G.M.P. Agent Based Modelling and Simulation tools: A review of the state-of-art software. Comput. Sci. Rev.
**2017**, 24, 13–33. [Google Scholar] [CrossRef]

**Figure 1.**(

**a**) The Model⇔Concept duo extended to (

**b**) Model→View→Concept trio extended as a (

**c**) Concept→Model→Graph→View Cycle (CMGVC).

**Figure 2.**OPM model (OPD on the left, OPL on the right) of a

**Lane Keeping System**, loosely based on [32]. The system handles a

**Lane Keeping**function that provides

**Improved Safety**.

**Lane Keeping**generates

**Alerts**that inform the

**Driving**process, and

**Steering Commands**that affect the

**Vehicle**’s

**Propelling**function. The

**Road**constitutes an instrument for both

**Propelling**and

**Lane Keeping**.

**Driving**and

**Propelling**affect each other regardless of the

**Lane Keeping System**.

**Figure 3.**Equivalent representations of relations between pairs of objects as: (

**i**) a digraph, (

**ii**) an adjacency matrix (cell (r,c) holds the arrow value of row object (r) to column object (c), and (

**iii**) a set of tuples (triplets of source object (S), target object (T), and value (V), relating S to T.

**Figure 4.**A category with three types: Type1, Type2, and Type3. The morphisms $m12:Type1\to Type2$ and $m23:Type2\to Type3$ are specified. The morphism $m13$ is a composition of $m23$ after $m13$—it transforms Type1 to Type3 by transforming Type1 to Type2, then Type2 to Type3.

**Figure 5.**The CMGVC, as a cognitive–computational cycle of Conceptual Modeling, Model Transforming, Stakeholder-informing View Rendering, and Reasoning. The System, OPM Model, GDS, and SIM are specializations of the respective generic artifacts: Concept, Model, Generic Representation, and View.

**Figure 6.**The OPM modeling language, OPML, as a category. Modeling (the morphism m) is like hopping through the instantiation of category types based on existing artifacts. For example: (a) creating a new Diagram D1 in a Model M, (b) creating an Object Ob1 in D1, (c) creating a Process P1 in D1, (d) creating a RelationRr1(Ob1,P1) from Ob1 to P1, (e) creating a new Diagram D2 from P1, (f) adding States St11 and St12 to Ob1 in D2, and so on. Every instantiation of a type also affects the Spec, and therefore all graphical elements have a mapping into Spec (the morphism s). Spec also feeds into the Rendering morphism r, which renders a Report from the Spec, currently in the form of a PDF file. Diagram created using MATLAB 2019b digraph plotting capabilities [85].

**Figure 7.**A graph rendition of a subset of the Lane Keeping System (LKS) model in Figure 2. The graph maps the OPM-specifiable terms “$Object”, and “$Process” to Domain entities: Object classifies Vehicle, Driver, and LKS; Process classifies Driving, Propelling, and Lane_Keeping. Domain-internal relations include the mutual invocation between Driving and Propelling, output of Alert and Steering_Command to Driving and Propelling, respectively, and exhibition of Lane_Keeping by LKS. This graph visualizes a subset of the GDS that represents the model. It is clearly difficult to comprehend, and is illustrated for intuition about the possible mapping of a model to a graph.

**Figure 8.**A C-Set mapping functor schema from OPML to GDS (RSTUV tuple set) extracts

`ElementDictionary`from the model’s

`ExportedReport`and transforms

`ElementDictionary`into three sets:

`ObjectElement`,

`ProcessElement`, and

`RelationSet`.

`RelationSet`is decomposed into a set of

`Relations`. The functor computes attributes for each entity type from the report. For example, it lists the

`ObjectOPDs`in which each

`Object`is defined, and extracts the Source object/process and the Target object/process for each

`Relation`. Each entity is then transformed into a set of

`RSTUVCandidates`. Duplicate candidates are removed before the set of

`RSTUVTuple`is compiled. Illustration created using the www.NomnoML.com.

**Figure 10.**A JSON structure defining the required transformations of

`ProcessElement`attributes to

`RSTUVCandidate`items. This example does not include

`relationSourceTargetTriplets`.

**Figure 11.**OPM model with processes and onputs (

**a**), shown in three additional renditions: (

**b**) an onput-on-node/process-on-edge graph, (

**c**) a process-on-node/onput-on-edge graph, and (

**d**) a process-to-process onput exchange matrix. NULL processes and onputs (in all renditions) serve as placeholders for missing or partial relations, like an input without a source process (Ob12), a process without an input (P3) or without an output (P7), and an output without a target process (Ob11). Both graph visualizations were rendered using https://csacademy.com/app/graph_editor/ (accessed on 3 December 2020).

**Figure 12.**Lane Keeping System zooms into Alert Mode, Steer-back Mode, Road Image, Alert Mode, Lane Crossing, and Steer-back Mode, in that vertical sequence, as well as Alerting, Analyzing Road, Imaging Road, Selecting Operational Mode, and Steering (This caption is formal OPL).

(a) 2-2 SAM Mapping of Systems and Processes [37] | ||||

System (S) | Process (P) | |||

System | ID(S_{row}) | Instrument(S,P) | ||

Process | Effect(P,Attribute(S)) | Result(P_{row}, Input(P_{column})) Consumption(Output(P _{row}),P_{column}) | ||

(b) 3-3 SAM of Processes, Operands, and System Components [24] | ||||

[P] | [O] | [C] | ||

Process [P] | [PP] | [PO] | [PC] | |

Operand [O] | [OP] | [OO] | [OC] | |

Component [C] | [CP] | [CO] | [CC] |

Topic/Title/Application | Description | References |
---|---|---|

Complex/Cyber-Physical Systems Architecture and Design | Object–Process Networks, a language for System Architecting | [49,50] |

Representing a system as a category with component types and inter-component relations as morphisms, with Ologs (knowledge representation structures that capture non-mathematical, freely-defined relations among objects as morphisms) to specify design constructs, current-state situations, constraints, and requirements | [51,52] | |

Iterative co-design of electro-mechanical functions in a cyber-physical system architecture | [53,54,55,56] | |

hierarchical requirements engineering, gradually evolving a system architecture; formal and verifiable system design | [57,58,59] | |

Structural and functional composition of system models | [60] | |

Using operads—categorical structures that map multi-object compositions to a single object—for hierarchical decomposition, design synthesis, separation of syntax from semantics, and semantic reasoning about complex systems | [61,62] | |

Model-Driven Software Engineering | Building mathematical foundations for model-driven software engineering (MDE), model management, model merging, bidirectional model updates, design patterns, and model transformations | [63,64] |

Computer-Aided Design | Representing, integrating, and coordinating computer-aided design (CAD) languages, models and simulations for the design of a difficult technical complex (DTC) | [65] |

Categorical Formulations of Systems | Ontological analysis based on a category ONT with ontologies as types and ontology mappings as morphisms | [13,66] |

Representing a system as a symmetric monoidal, compact closed category with block types and input–output morphisms | [67] | |

Algebraic formulation of open dynamical systems that can be characterized as resource sharers as a category of resource-sharing machines | [68] | |

Stochastic Models | Domain-specific reasoning in stochastic systems, mapping causal probabilistic models the category $Stoch$, whose types are measurable spaces, and whose morphisms are Markov kernels between spaces | [69] |

Scientific Models | Semantic modeling for extracting information from, reasoning about, augmenting, and composing computational models of complex systems and natural phenomena | [70,71,72] |

CPS Component | CPS Morphism | Input | Output | Formulation |
---|---|---|---|---|

Engine | Energy Generating | Matter | Energy | ${f}_{Engine}:Matter\to \text{}Energy$ |

Sensor | Sensing | Energy | Data | ${f}_{Sensor}:Energy\to \text{}Data$ |

Actuator | Actuating | Data | Energy | ${f}_{Actuator}:Data\to \text{}Energy$ |

**Table 4.**Mapping the category of Systems, $\mathit{SYS},$ to a category of OPM models,$\mathit{OPML}$, and to a category of Graph Data Structures, $\mathit{GDS}$.

Category | Systems, $\mathit{S}\mathit{Y}\mathit{S}$ | C→M | Object–Process Modeling Language, $\mathit{O}\mathit{P}\mathit{M}\mathit{L}$ | M→G | Graph Data Structure, $\mathit{G}\mathit{D}\mathit{S}$ |
---|---|---|---|---|---|

Types | Model, Diagram, Spec | ||||

Structure | → | Object | |||

Relation | → | Process, Relation | |||

State | → | State | |||

Operand | → | Object | |||

Report | → | Tuple set | |||

Morphisms | Behavior | → | Process | ||

N/A | modeling, specifying, rendering | tuple operation |

Rule | R | S | T |
---|---|---|---|

0. | Identity | Type_{t} | UUID(Type_{t}) |

1. | Classification | E_{i} | OPM.Classification(E_{i}) |

2. | OPM.Relation(E_{i}, E_{j}) | E_{i} | E_{j} |

3. | OPM.Inclusion(D_{i}, E_{j}) | D_{i} | E_{j} |

4. | OPM.Inclusion(D_{i}, Relation(E_{j,} E_{k}) | D_{i} | UUID(Relation(E_{j,} E_{k})) |

5. | OPM.Affiliation | E_{i} | OPM.Affiliation(E_{i}) |

6. | OPM.Essence | E_{i} | OPM.Essence(E_{i}) |

7. | Identity | E_{i} | UUID(E_{i}) |

8. | Identity | R_{k} | UUID(R_{k}) |

Criterion | Weight | MGV | MV | MRV |
---|---|---|---|---|

C1—Efficiency | W1 | M+V | MV | M+V |

C2—Flexibility | W2 | 1 | M | 1 |

C3—Robustness | W3 | 1 | V | V+1 |

C4—Resilience | W4 | 1 | V | 1 |

Total | 1 | Equation (1) | Equation (2) | Equation (3) |

**Table 7.**Preference Relations of MGV over MV depending on the number of MLs (M) and views (V). MV is preferred when M = V = 1; MGV is preferred when $M\ge 2V\ge 2$. When $M=1V\ge 2$ or $M\ge 2V=1$ preference rotates based on weighting. MGV is preferable when weights are equal. The cases of MGV superiority are shaded.

V = 1 | V = 2 | V > 2 | |
---|---|---|---|

M = 1 | $\nexists \text{}{W}_{1}\left(-1\right)\ge 0\text{}$ $\u27f9{S}_{MV}\le {S}_{MGV}$$\u27f9\mathit{MGV}\preccurlyeq \mathit{MV}$ | ${W}_{3}+{W}_{4}\le {W}_{1}$ $\u27f9{S}_{MV}\le {S}_{MGV}$$\u27f9\mathit{MGV}\preccurlyeq \mathit{MV}$ | $({W}_{3}+{W}_{4})\le \frac{{W}_{1}}{3}$ $\u27f9{S}_{MV}\le {S}_{MGV}$$\u27f9\mathit{MGV}\preccurlyeq \mathit{MV}$ |

${W}_{3}+{W}_{4}\ge {W}_{1}$ $\u27f9{S}_{MGV}\le {S}_{MV}\u27f9\mathit{MGV}\succcurlyeq \mathit{MV}$ | $({W}_{3}+{W}_{4})\ge \frac{{W}_{1}}{3}$ $\u27f9\text{}{S}_{MGV}\le {S}_{MV}\u27f9\text{}\mathit{MGV}\succcurlyeq \mathit{MV}$ | ||

M = 2 | ${W}_{1}\ge {W}_{2}$ $\u27f9{S}_{MV}\le {S}_{MGV}\u27f9\mathit{MGV}\preccurlyeq \mathit{MV}$ | ${W}_{2}+{W}_{3}+{W}_{4}\ge 0$ $\u27f9{S}_{MGV}\le {S}_{MV}\u27f9\mathit{MGV}\succcurlyeq \mathit{MV}$ | $m{W}_{1}+{W}_{2}+n\left({W}_{3}+{W}_{4}\right)\ge 0$ $m,n\in \mathbb{N}$ $\u27f9{S}_{MGV}\le {S}_{MV}\u27f9\mathit{MGV}\succcurlyeq \mathit{MV}$ |

${W}_{2}\ge {W}_{1}$ $\u27f9{S}_{MGV}\le {S}_{MV}\u27f9\mathit{MGV}\succcurlyeq \mathit{MV}$ | |||

M > 2 | ${W}_{2}\le \frac{{W}_{1}}{M-1}$ $\u27f9{S}_{MV}\le {S}_{MGV}\u27f9\mathit{MGV}\preccurlyeq \mathit{MV}$ | $m{W}_{1}+n{W}_{2}+{W}_{3}+{W}_{4}\ge 0$ $m,n\in \mathbb{N}$ $\u27f9{S}_{MGV}\le {S}_{MV}\u27f9\mathit{MGV}\succcurlyeq \mathit{MV}$ | $p{W}_{1}+m{W}_{2}+n\left({W}_{3}+{W}_{4}\right)\ge 0$ $m,n,p\in \mathbb{N}$ $\u27f9{S}_{MGV}\le {S}_{MV}\u27f9\mathit{MGV}\succcurlyeq \mathit{MV}$ |

${W}_{2}\ge \frac{{W}_{1}}{M-1}$ $\u27f9{S}_{MGV}\le {S}_{MV}\u27f9\mathit{MGV}\succcurlyeq \mathit{MV}$ |

**Table 8.**POP matrix of LKS model maps processes to each other via onput exchange, instrument providing, and invocation. Color coding highlights discrepancies and potential issues: Red cells with a value of 0 indicate processes without inputs or outputs. Lightly-colored cells need further attention.

Target Process | (Null) | Alerting | Analyzing Road | Imaging Road | Lane Keeping | Selecting Operational Mode | Steering | Driving | Propelling | Outputs per Process | |
---|---|---|---|---|---|---|---|---|---|---|---|

Source Process | |||||||||||

(Null) | Lane Crossing | Road Image | Road | Road | Lane Crossing | Road | 6 | ||||

Lane Keeping | Improved Safety | Alert | Steering Command | 3 | |||||||

Selecting Operational Mode | Alert Mode | Steer-back Mode | 2 | ||||||||

Imaging Road | 0 | ||||||||||

Analyzing Road | 0 | ||||||||||

Alerting | Alert | 1 | |||||||||

Driving | Invocation | 1 | |||||||||

Steering | Steering Command | 1 | |||||||||

Propelling | Invocation | 1 | |||||||||

Inputs per Process | 1 | 2 | 1 | 1 | 1 | 0 | 2 | 3 | 4 |

**Table 9.**Issues identified in the LKS model POP matrix and suggested corrections. Critical issues are marked in red.

Entity | Issue | Correction |
---|---|---|

Lane Keeping | no functional decomposition | Unfold Lane Keeping in a separate diagram and link it to the internal functions in Lane Keeping System to create functional decomposition of top level system function to lower-level functions |

Selecting Operational Mode | no input | Add input from Driver |

Imaging Road | no output | Link through a Result relation to Road Image |

Analyzing Road | no output | Link through a Result relation to Lane Crossing |

Improved Safety | no receiver | Specify as attribute of Lane Keeping System. Since this object represents emergent value, it is not recommended to associate it with a specific function |

Road Image | no provider | Link Imaging Road through a Result relation |

Lane Crossing | no provider | Link Analyzing Road through a Result relation |

Road | no provider | Add Effect Link from Propelling, indicating that vehicle movement affects the immediate portion of interest of the road with which the vehicle interacts |

Driving invokes Propelling | no explicit onput | Consider replacing invocation by driver command gestures (turning, signaling, braking, etc.) |

Propelling invokes Driving | no explicit onput | Consider replacing invocation by vehicle response to driver action |

Publisher’s Note: MDPI stays neutral with regard to jurisdictional claims in published maps and institutional affiliations. |

© 2021 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (http://creativecommons.org/licenses/by/4.0/).

## Share and Cite

**MDPI and ACS Style**

Mordecai, Y.; Fairbanks, J.P.; Crawley, E.F. Category-Theoretic Formulation of the Model-Based Systems Architecting Cognitive-Computational Cycle. *Appl. Sci.* **2021**, *11*, 1945.
https://doi.org/10.3390/app11041945

**AMA Style**

Mordecai Y, Fairbanks JP, Crawley EF. Category-Theoretic Formulation of the Model-Based Systems Architecting Cognitive-Computational Cycle. *Applied Sciences*. 2021; 11(4):1945.
https://doi.org/10.3390/app11041945

**Chicago/Turabian Style**

Mordecai, Yaniv, James P. Fairbanks, and Edward F. Crawley. 2021. "Category-Theoretic Formulation of the Model-Based Systems Architecting Cognitive-Computational Cycle" *Applied Sciences* 11, no. 4: 1945.
https://doi.org/10.3390/app11041945