Model Checking Transition System XML Labeling

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Current software development methods are expensive and time-consuming due to errors in source code, with existing testing approaches like dynamic and static analysis being either non-exhaustive or cumbersome, particularly in detecting software bugs and security vulnerabilities.

Innovation Solution

Generating a transition system using XML representation and XPath queries to analyze source code, enabling efficient model checking for static analysis, which identifies bugs and security vulnerabilities by transforming static analysis problems into model checking problems.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Reliability

If dynamic testing is used to test software functionality, then functional correctness can be verified, but the testing is not exhaustive and is cumbersome to generate test cases

Engineering Contradiction:
Improvefunctional correctnessVSAvoidtesting efficiency
Core Design Contradiction:
ReliabilityVSProductivity

Solution Approach 1:

The patent replaces dynamic mechanical testing with static analysis using model checking. Instead of executing code dynamically to verify functionality, the system creates a transition system model and uses model checking algorithms to exhaustively verify properties without execution, substituting the mechanical testing process with a computational modeling approach that achieves both exhaustiveness and efficiency.

Inventive Principle:
Principle #28Mechanics substitution (Replace mechanical system)

Solution Approach 2:

The patent performs preliminary actions by creating a transition system model before actual testing. The model captures all possible states and transitions of the software system in advance, allowing exhaustive verification of properties to be performed on the model rather than requiring exhaustive dynamic testing of the actual software, thereby improving testing efficiency while maintaining reliability.

Inventive Principle:
Principle #10Preliminary action

2Productivity

If static analysis is used to analyze code structure, then exhaustive analysis can be performed, but it requires transforming static analysis problems into model checking problems

Engineering Contradiction:
Improveanalysis exhaustivenessVSAvoidproblem transformation complexity
Core Design Contradiction:
ProductivityVSDevice complexity

Solution Approach 1:

The patent applies universality by creating a unified transition system model that can represent various types of software systems and properties using a single formalism. The model checking framework serves multiple functions: it can verify different types of properties (safety, liveness, fairness), handle different programming languages, and accommodate various analysis scenarios, thereby achieving exhaustive analysis without requiring separate complex transformation processes for each case.

Inventive Principle:
Principle #6Universality (Multi-functionality)

Solution Approach 2:

The patent uses parameter changes by allowing flexible configuration of the transition system model's parameters (states, transitions, initial states, accepting states) to match different software systems and properties. This parameterization approach enables exhaustive analysis of various software systems by simply changing the model parameters rather than requiring fundamental transformations of the analysis methodology, thus reducing the complexity burden.

Inventive Principle:
Principle #35Parameter changes

3Productivity

If model checking is used to verify properties, then efficient searching of state spaces is achieved, but the state space must be represented as a transition system

Engineering Contradiction:
Improvestate space search efficiencyVSAvoidtransition system representation
Core Design Contradiction:
ProductivityVSDevice complexity

Solution Approach 1:

The patent introduces an intermediary layer in the form of a transition system model that mediates between the software system and the model checking algorithm. This intermediary model captures the essential behavior of the software in a form that is easily processable by model checking tools, allowing efficient state space search while the model itself handles the complexity of representing the software system's structure and behavior.

Inventive Principle:
Principle #24Intermediary (Mediator)

4Reliability

If exhaustive static analysis is performed to detect all bugs, then reliability is improved, but detection time and costs increase

Engineering Contradiction:
Improvebug detection completenessVSAvoiddetection time
Core Design Contradiction:
ReliabilityVSLoss of time

Solution Approach 1:

The patent creates a copy of the software system in the form of a transition system model that replicates its essential behavior and structure. By performing exhaustive analysis on this copy rather than on the actual software during execution, the system achieves complete bug detection without the time penalty of running exhaustive tests on the real software, since the model can be analyzed statically and reused for verification.

Inventive Principle:
Principle #26Copying

Data Source

PatentUS8850415B2Generating a transition system for use with model checking
Publication Date: 2014.09.30 NAT ICT AUSTRALIA
  • US8850415B2 patent drawing
  • US8850415B2 patent drawing
  • US8850415B2 patent drawing

AI summary

The invention concerns model program analysis of software code using model checking. Initially, a transition system (22) and an extensible markup language (XML) (24) representation of the data is generated. Next, labels (26) for the transition system are generated by querying the XML representation of the data using (markup) query language. The labels and the structure of the transition system are then used as input to model checking techniques to analyse the software code (28). It is an advantage of the invention that the problem of labelling a transition system can be transformed into the XML domain so that detailed information about the software code can be extracted using queries in a format that can be run in the XML domain which are well known. At the same time the transformation to the XML domain does not prevent the use of efficient model checking technologies.