# Difference between revisions of "Publications/paviot.22.forte"

### From LRDE

Line 6: | Line 6: | ||

| booktitle = Proceedings of the 41th IFIP International Conference on Formal Techniques for Distributed Objects, Components and Systems (FORTE'22) |
| booktitle = Proceedings of the 41th IFIP International Conference on Formal Techniques for Distributed Objects, Components and Systems (FORTE'22) |
||

| series = Lecture Notes in Computer Science |
| series = Lecture Notes in Computer Science |
||

− | | volume = |
+ | | volume = 13273 |

− | | pages = |
+ | | pages = 170 to 187 |

| publisher = Springer |
| publisher = Springer |
||

| lrdeprojects = Spot |
| lrdeprojects = Spot |
||

Line 15: | Line 15: | ||

| type = inproceedings |
| type = inproceedings |
||

| id = paviot.22.forte |
| id = paviot.22.forte |
||

− | | identifier = doi: |
+ | | identifier = doi:10.1007/978-3-031-08679-3_11 |

| bibtex = |
| bibtex = |
||

@InProceedings<nowiki>{</nowiki> paviot.22.forte, |
@InProceedings<nowiki>{</nowiki> paviot.22.forte, |
||

Line 28: | Line 28: | ||

month = jun, |
month = jun, |
||

series = <nowiki>{</nowiki>Lecture Notes in Computer Science<nowiki>}</nowiki>, |
series = <nowiki>{</nowiki>Lecture Notes in Computer Science<nowiki>}</nowiki>, |
||

− | volume = |
+ | volume = 13273, |

− | pages = <nowiki>{</nowiki> |
+ | pages = <nowiki>{</nowiki>170--187<nowiki>}</nowiki>, |

publisher = <nowiki>{</nowiki>Springer<nowiki>}</nowiki>, |
publisher = <nowiki>{</nowiki>Springer<nowiki>}</nowiki>, |
||

− | doi = <nowiki>{</nowiki> |
+ | doi = <nowiki>{</nowiki>10.1007/978-3-031-08679-3_11<nowiki>}</nowiki>, |

abstract = <nowiki>{</nowiki> Verification of properties expressed as omega-regular |
abstract = <nowiki>{</nowiki> Verification of properties expressed as omega-regular |
||

languages such as LTL can benefit hugely from stutter |
languages such as LTL can benefit hugely from stutter |

## Revision as of 16:53, 17 June 2022

- Authors
- Emmanuel Paviot-Adet, Denis Poitrenaud, Etienne Renault, Yann Thierry-Mieg
- Where
- Proceedings of the 41th IFIP International Conference on Formal Techniques for Distributed Objects, Components and Systems (FORTE'22)
- Type
- inproceedings
- Publisher
- Springer
- Projects
- Spot
- Date
- 2022-04-18

## Abstract

Verification of properties expressed as omega-regular languages such as LTL can benefit hugely from stutter insensitivity, using a diverse set of reduction strategies. However properties that are not stutter invariant, for instance due to the use of the neXt operator of LTL or to some form of counting in the logic, are not covered by these techniques in general. We propose in this paper to study a weaker property than stutter insensitivity. In a stutter insensitive language both adding and removing stutter to a word does not change its acceptance, any stuttering can be abstracted away; by decomposing this equivalence relation into two implications we obtain weaker conditions. We define a shortening insensitive language where any word that stutters less than a word in the language must also belong to the language. A lengthening insensitive language has the dual property. A semi-decision procedure is then introduced to reliably prove shortening insensitive properties or deny lengthening insensitive properties while working with a reduction of a system. A reduction has the property that it can only shorten runs. Lipton's transaction reductions or Petri net agglomerations are examples of eligible structural reduction strategies. An implementation and experimental evidence is provided showing most non- random properties sensitive to stutter are actually shortening or lengthening in- sensitive. Performance of experiments on a large (random) benchmark from the model-checking competition indicate that despite being a semi-decision proce- dure, the approach can still improve state of the art verification tools. 1 Introduction Model checking is an automatic verification technique for proving the correctness of systems that have finite state abstractions. Properties can be expressed using the popular Linear-time Temporal Logic (LTL). To verify LTL properties, the automata-theoretic approach [25] builds a product between a Buchi automaton representing the negation of the LTL formula and the reachable state graph of the system (seen as a set of infinite runs). This approach has been used successfully to verify both hardware and software components, but it suffers from the so called "state explosion problem": as the number of state variables in the system increases, the size of the system state space grows exponentially.

## Documents

## Bibtex (lrde.bib)

@InProceedings{ paviot.22.forte, author = {Emmanuel Paviot-Adet and Denis Poitrenaud and Etienne Renault and Yann Thierry-Mieg}, title = {LTL under reductions with weaker conditions than stutter invariance}, booktitle = {Proceedings of the 41th IFIP International Conference on Formal Techniques for Distributed Objects, Components and Systems (FORTE'22)}, year = 2022, month = jun, series = {Lecture Notes in Computer Science}, volume = 13273, pages = {170--187}, publisher = {Springer}, doi = {10.1007/978-3-031-08679-3_11}, abstract = { Verification of properties expressed as omega-regular languages such as LTL can benefit hugely from stutter insensitivity, using a diverse set of reduction strategies. However properties that are not stutter invariant, for instance due to the use of the neXt operator of LTL or to some form of counting in the logic, are not covered by these techniques in general. We propose in this paper to study a weaker property than stutter insensitivity. In a stutter insensitive language both adding and removing stutter to a word does not change its acceptance, any stuttering can be abstracted away; by decomposing this equivalence relation into two implications we obtain weaker conditions. We define a shortening insensitive language where any word that stutters less than a word in the language must also belong to the language. A lengthening insensitive language has the dual property. A semi-decision procedure is then introduced to reliably prove shortening insensitive properties or deny lengthening insensitive properties while working with a reduction of a system. A reduction has the property that it can only shorten runs. Lipton's transaction reductions or Petri net agglomerations are examples of eligible structural reduction strategies. An implementation and experimental evidence is provided showing most non- random properties sensitive to stutter are actually shortening or lengthening in- sensitive. Performance of experiments on a large (random) benchmark from the model-checking competition indicate that despite being a semi-decision proce- dure, the approach can still improve state of the art verification tools. 1 Introduction Model checking is an automatic verification technique for proving the correctness of systems that have finite state abstractions. Properties can be expressed using the popular Linear-time Temporal Logic (LTL). To verify LTL properties, the automata-theoretic approach [25] builds a product between a Buchi automaton representing the negation of the LTL formula and the reachable state graph of the system (seen as a set of infinite runs). This approach has been used successfully to verify both hardware and software components, but it suffers from the so called "state explosion problem": as the number of state variables in the system increases, the size of the system state space grows exponentially.} }