Model Checker Representation Retaining Code Structure
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current verification methods for software components of automated driving functions, such as model checking, struggle to retain the code structure during translation into finite automata, making it difficult to attribute errors to specific operations or instructions in the native program code, thus hindering effective error elimination.
Innovation Solution
A computer-implemented method that converts native program code into a finite automaton with uniquely assignable states and transitions, allowing the code structure to be retained in the model checker representation, enabling clear attribution and elimination of errors through a multi-step conversion process, including mining and embedding of FA-like structures.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If native program code is translated into model checker representation using conventional model checking tools, then formal mathematical proof of error-free software can be obtained, but the code structure is lost or heavily obscured making error attribution impossible
Solution Approach 1:
The translation process is divided into multiple sequential steps (parsing, intermediate representation generation, finite automaton conversion, model checker representation) where each step preserves structural information. This segmentation allows the code structure to be maintained throughout the translation process while still enabling formal verification.
Solution Approach 2:
An intermediate representation is introduced as a mediator between the native program code and the finite automaton model. This intermediate representation preserves the code structure while being suitable for conversion to model checker format, thus acting as a bridge that maintains structural information throughout the translation process.
2Productivity
If conventional model checking translation is used, then verification can be performed, but errors cannot be traced back to specific operations or instructions in the native program code
Solution Approach 1:
The translation process establishes a feedback mechanism where model checker errors can be traced back through the preserved code structure to specific operations or instructions in the native program code. This allows verification to be performed while maintaining the ability to locate and fix errors efficiently.
Solution Approach 2:
The code structure is preserved in advance during the translation process, before model checking occurs. This preliminary preservation of structural information enables error attribution to be performed efficiently during the verification phase without requiring additional analysis steps.
3Extent of automation
If automatic mining of finite automata is performed, then translation can be automated, but the reference to program structure is lost or heavily obscured
Solution Approach 1:
The automatic translation process is segmented into multiple controlled steps, each preserving structural information. This allows automation to be achieved while maintaining program structure reference, as each transformation step is designed to preserve relevant structural characteristics for later error attribution.
Solution Approach 2:
The intermediate representation serves as an automated intermediary that preserves program structure reference. This mediator enables the automatic translation process to maintain structural information that would otherwise be lost in conventional automated mining approaches.
Data Source
AI summary
A computer-implemented method for verifying a software component of an automated driving function. The method includes: translating the native program code into a model checker representation of the software component to be verified and analyzing the model checker representation of the software component to be verified using a model checking method. The native program code of the software component to be verified is limited to a set of operations of the programming language used that are defined as permissible. To do this, the native program code is converted into a finite automaton, the states and state transitions of which can be uniquely assigned to the code structure of the native program code. The model checker representation is generated based on the finite automaton such that the code structure of the native program code is substantially retained when the native program code is translated into the model checker representation.