Software Logic Modeling With Traceable Block-Level Transformation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing model-based design systems struggle to efficiently and accurately model complex, long-lived, safety-critical software systems, particularly in bridging past knowledge with future transformative innovations, and maintaining stringent certification requirements.
Innovation Solution
The system employs an Arbitrary Software Logic Modeling (ASLM) platform that automatically models software logic using block entities and control flow networks, maintaining traceability between high and low-level requirements, and enabling model transformation across units.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Measurement precision
If manual modeling of software logic is performed, then modeling accuracy can be maintained, but time consumption and error probability increase significantly
Solution Approach 1:
The patent uses model extraction to create a formal representation (copy) of the existing software logic from source code. This extracted model captures the control flow and logic structures automatically, eliminating manual modeling while preserving accuracy through systematic analysis of the original code structure.
Solution Approach 2:
The patent replaces the mechanical process of manual modeling with an automated model extraction mechanism. The system uses program analysis techniques to automatically derive control flow graphs and logic models from source code, substituting human effort with computational processes that are both faster and equally accurate.
2Reliability
If existing model-based design tools are used, then reactive systems can be modeled, but they lack the constructs needed for complex interactive information systems
Solution Approach 1:
The patent creates a universal modeling framework that can represent both reactive systems and complex interactive information systems. The formal model extraction approach uses general control flow graph representations and logic structures that are applicable across different system types, making the tool versatile while maintaining certification capability.
Solution Approach 2:
The patent segments the modeling process into distinct formal components (control flow graphs, logic structures, requirement mappings) that can be independently analyzed and certified. This segmentation allows the system to handle diverse system types by combining appropriate formal constructs while maintaining rigorous verification capabilities.
3Ease of operation
If UML activity diagrams are used for new system design, then design visualization is achieved, but they are not helpful for modeling existing arbitrary logic
Solution Approach 1:
The patent extracts and copies the actual control flow structure directly from existing source code into a formal model representation. This approach faithfully reproduces the existing logic as it truly operates, rather than requiring reinterpretation through UML notation, making it applicable to any existing system regardless of how arbitrary its logic may be.
Solution Approach 2:
Instead of translating existing code into UML diagrams (code → visualization), the patent inverts the approach by directly analyzing and extracting formal models from code structure (code → formal model). This inversion eliminates the lossy translation step and directly captures the executable logic in a certifiable format.
4Ease of operation
If software logic is modeled manually for maintenance and evolution, then understanding can be achieved, but the process is expensive and error-prone
Solution Approach 1:
The patent enables the software system to model itself automatically through program analysis. The model extraction process is self-service in that it uses the code's own structure, symbols, and control flow to generate its formal representation without external manual intervention, making maintenance and evolution straightforward through automated model updates.
Solution Approach 2:
The patent replaces the complex manual process of analyzing and modeling software logic with an automated program analysis mechanism. The system uses computational algorithms to extract control flow graphs and logic structures directly from source code, eliminating the need for manual traceability matrix creation and reducing errors while maintaining understandability.
Data Source
Figure 1
Figure 2
Figure 3
AI summary
According to some embodiments, an Arbitrary Software Logic Modeling ("ASLM") data source 110 may store electronic records associated with units, each electronic record including a unit identifier, one or more identification tags, context data, unit parameters, unit variables, and internal logic. An ASLM platform 150 may express system requirements at a logic block level and establish the logic blocks as self-contained entities and connections in accordance with the system requirements (the established logic blocks graphically representing systems logic). The ASLM platform 150 may then explicitly transform the systems logic automatically to output language agnostic common design information exchange model information. The ASLM platform 150 may also translate and maintain traceability among the system requirements, common design information exchange model information, and generated code.