Henrich Lauko

Mr. Henrich Lauko

Masaryk University, Faculty of Informatics
orcid

Research Focus & Metrics

Academic Career Length

8Years (2019-Present)

(Calculated once Scilit publication data is synced: current year − year of first publication + 1)

Representative Publications

View All Publications
6 August 2022
Verified
Book Chapter
Open access
PDF file
ADAlexandre Duret-Lutz
Alexandre Duret-Lutz
EREtienne Renault
Etienne Renault
MCMaximilien Colange
Maximilien Colange
FRFlorian Renkin
Florian Renkin
AAAlexandre Gbaguidi Aisse
Alexandre Gbaguidi Aisse
HLHenrich Lauko
Henrich Lauko
Spot is a C++17 library for LTL and $$\omega $$ω -automata manipulation, with command-line utilities, and Python bindings. This paper summarizes its evolution over the past six years, since the release of Spot 2.0, which was the first version to support $$\omega $$ω -automata with arbitrary acceptance conditions, and the last version presented at a conference. Since then, Spot has been extended with several features such as acceptance transformations, alternating automata, games, LTL synthesis, and more. We also shed some lights on the data-structure used to store automata.Artifact:https://zenodo.org/record/6521395.

4 April 2019
Verified
Book Chapter
Open access
PDF file
HLHenrich Lauko
Henrich Lauko
VŠVladimír Štill
Vladimír Štill
PRPetr Ročkai
Petr Ročkai
JBJiří Barnat
Jiří Barnat
DIVINE is an LLVM-based verification tool focusing on analysis of real-world C and C++ programs. Such programs often interact with their environment, for example via inputs from users or network. When these programs are analyzed, it is desirable that the verification tool can deal with inputs symbolically and analyze runs for all inputs. In DIVINE, it is now possible to deal with input data via symbolic computation instrumented into the original program at the level of LLVM bitcode. Such an instrumented program maintains symbolic values internally and operates directly on them. Instrumentation allows us to enhance the tool with support for symbolic data without substantial modifications of the tool itself. Namely, this competition contribution uses SMT formulae for representation of input data.

2 October 2019 in Lecture Notes in Computer Science
Verified
Book Chapter
Closed access
PDF file
Agostino CortesiAgostino Cortesi
Agostino Cortesi
HLHenrich Lauko
Henrich Lauko
MOMartina Olliaro
Martina Olliaro
PRPetr Ročkai
Petr Ročkai

30 March 2022
Verified
Book Chapter
Open access
PDF file
HLHenrich Lauko
Henrich Lauko
PRPetr Ročkai
Petr Ročkai
Lart – llvm abstraction and refinement tool – originates from the divine model-checker [5, 7], in which it was employed as an abstraction toolchain for the llvm interpreter. In this contribution, we present a stand-alone tool that does not need a verification backend but performs the verification natively. The core idea is to instrument abstract semantics directly into the program and compile it into a native binary that performs program analysis. This approach provides a performance gain of native execution over the interpreted analysis and allows compiler optimizations to be employed on abstracted code, further extending the analysis efficiency. Compilation-based abstraction introduces new challenges solved by lart, like domain interaction of concrete and abstract values simulation of nondeterministic runtime or constraint propagation.

8 September 2022 in ACM Transactions on Software Engineering and Methodology
Verified
Journal Article
Open access
HLHenrich Lauko
Henrich Lauko
LKLukáš Korenčik
Lukáš Korenčik
PRPetr Rockai
Petr Rockai
Most C and C++ programs use dynamically allocated memory (often known as a heap) to store and organize their data. In practice, it can be useful to compare addresses of different heap objects, for instance, to store them in a binary search tree or a sorted array. However, comparisons of pointers to distinct objects are inherently ambiguous: The address order of two objects can be reversed in different executions of the same program, due to the nature of the allocation algorithm and other external factors. This poses a significant challenge to program verification, since a sound verifier must consider all possible behaviors of a program, including an arbitrary reordering of the heap. A naive verification of all possibilities, of course, leads to a combinatorial explosion of the state space: For this reason, we propose an under-approximating abstract domain that can be soundly refined to consider all relevant heap orderings. We have implemented the proposed abstract domain and evaluated it against several existing software verification tools on a collection of pointer-manipulating programs. In many cases, existing tools only consider a single fixed heap order, which is a source of unsoundness. We demonstrate that using our abstract domain, this unsoundness can be repaired at only a very modest performance cost. Additionally, we show that, even though many verifiers ignore it, ambiguous behavior is present in a considerable fraction of programs from software verification competition ( sv-comp ).

2 June 2022 in arXiv
Verified
Preprint
Open access
PDF file
HLHenrich Lauko
Henrich Lauko
LKLukáš Korenčik
Lukáš Korenčik
PGPeter Goodman
Peter Goodman
In this submission, we explore the use of equality saturation to optimize concurrent computations. A concurrent environment gives rise to new optimization opportunities, like extracting a common concurrent subcomputation. To our knowledge, no existing equality saturation framework allows such an optimization. The challenge with concurrent environments is that they require non-local reasoning since parallel computations are inherently unrelated and disjoint. This submission presents a new approach to optimizing equivalent concurrent computations: extending e-graphs to capture equal concurrent computations in order to replace them with a single computation.