Lucas Sakizloglou
Current Organizations / Institutes
The organizations/institutes from the scholar's latest article
Previous Organizations / Institutes
The organizations / institutes from the scholar's other articles in the past ten years
Research Subjects
Lucas Sakizloglou has a total of 14 co-authors. Here are the top co-authors by number of shared publications:
- Holger Giese
Hasso Plattner Institute at the University of Potsdam Prof.-Dr.-Helmert-Str. 2-3 D-14482 Potsdam Germany
7 shared publications - Leen Lambers
Brandenburg University of Technology Cottbus-Senftenberg
5 shared publications - Maria Maximova
University of Potsdam
3 shared publications - Sven Schneider
University of Potsdam
3 shared publications Holger Giese
University of Potsdam, Germany
2 shared publicationsMatthias Barkowsky
University of Potsdam, Germany
2 shared publications
Latest Publications
- Open Access
Exploring a Graph-based Approach to Offline Reinforcement Learning for Sepsis Treatment
Sepsis is a serious, life-threatening condition. When treating sepsis, it is challenging to determine the correct amount of intravenous fluids and vasopressors for a given patient. While automated reinforcement learning (RL)-based methods have been used to support these decisions with promising results, previous studies have relied on relational data. Given the complexity of modern healthcare data, representing data as a graph may provide a more natural and effective approach. This study models patient data from the well-known MIMIC-III dataset as a heterogeneous graph that evolves over time. Subsequently, we explore two Graph Neural Network architectures - GraphSAGE and GATv2 - for learning patient state representations, adopting the approach of decoupling representation learning from policy learning. The encoders are trained to produce latent state representations, jointly with decoders that predict the next patient state. These representations are then used for policy learning with the dBCQ algorithm. The results of our experimental evaluation confirm the potential of a graph-based approach, while highlighting the complexity of representation learning in this domain.
Open AccessExploring a Graph-based Approach to Offline Reinforcement Learning for Sepsis Treatment
Sepsis is a serious, life-threatening condition. When treating sepsis, it is challenging to determine the correct amount of intravenous fluids and vasopressors for a given patient. While automated reinforcement learning (RL)-based methods have been used to support these decisions with promising results, previous studies have relied on relational data. Given the complexity of modern healthcare data, representing data as a graph may provide a more natural and effective approach. This study models patient data from the well-known MIMIC-III dataset as a heterogeneous graph that evolves over time. Subsequently, we explore two Graph Neural Network architectures - GraphSAGE and GATv2 - for learning patient state representations, adopting the approach of decoupling representation learning from policy learning. The encoders are trained to produce latent state representations, jointly with decoders that predict the next patient state. These representations are then used for policy learning with the dBCQ algorithm. The results of our experimental evaluation confirm the potential of a graph-based approach, while highlighting the complexity of representation learning in this domain.
- Open Access
- 28 June 2025
- Published by Association for Computing Machinery (ACM) in Formal Aspects of Computing
Foundations for Change-driven Query-based Runtime Monitoring of Temporal Properties
In model-driven engineering, monitoring the behavior of systems with complex dynamic structures is typically performed via query-based runtime monitoring: a runtime model captures a graph-based snapshot of the system state, and properties of interest are captured as graph queries, which are evaluated over the model online. For temporal properties, history-aware runtime models encode a trace of timestamped snapshots, which is monitored via temporal graph queries. In this case, the query evaluation needs to consider that a trace may be incomplete, thus future changes to the model may affect current answers. In this article, we present the first comprehensive formal treatment of query-based runtime monitoring of temporal properties over runtime models that encode incomplete traces. First, we introduce a query evaluation semantics for a querying approach we previously presented: the previous ( plain ) semantics did not consider incomplete traces and could hence return answers that could be affected by future changes to the model; the novel ( definite ) semantics only returns answers if they are definite, i.e., no future change to the model will affect them. Then, we present a formalization of a technique for the operationalization of temporal queries for both semantics, which allows for incremental and change-driven query evaluation. However, in contrast to the plain semantics, the definite semantics depends on the timestamp of the model and thus must recompute all answers for each model in the trace; hence, the definite semantics disables change-driven evaluation. Finally, we present a variation of the plain semantics that enables the approach to keep to change-driven evaluation while returning definite answers. We evaluate the performance of the presented semantics over two case studies and compare them to the state-of-the-art.
- 28 June 2025
- Published by Association for Computing Machinery (ACM) in Formal Aspects of Computing
Open AccessFoundations for Change-driven Query-based Runtime Monitoring of Temporal Properties
In model-driven engineering, monitoring the behavior of systems with complex dynamic structures is typically performed via query-based runtime monitoring: a runtime model captures a graph-based snapshot of the system state, and properties of interest are captured as graph queries, which are evaluated over the model online. For temporal properties, history-aware runtime models encode a trace of timestamped snapshots, which is monitored via temporal graph queries. In this case, the query evaluation needs to consider that a trace may be incomplete, thus future changes to the model may affect current answers. In this article, we present the first comprehensive formal treatment of query-based runtime monitoring of temporal properties over runtime models that encode incomplete traces. First, we introduce a query evaluation semantics for a querying approach we previously presented: the previous ( plain ) semantics did not consider incomplete traces and could hence return answers that could be affected by future changes to the model; the novel ( definite ) semantics only returns answers if they are definite, i.e., no future change to the model will affect them. Then, we present a formalization of a technique for the operationalization of temporal queries for both semantics, which allows for incremental and change-driven query evaluation. However, in contrast to the plain semantics, the definite semantics depends on the timestamp of the model and thus must recompute all answers for each model in the trace; hence, the definite semantics disables change-driven evaluation. Finally, we present a variation of the plain semantics that enables the approach to keep to change-driven evaluation while returning definite answers. We evaluate the performance of the presented semantics over two case studies and compare them to the state-of-the-art.
- 2 July 2024
- Published by Springer Nature
- p. 180-200
Taint Analysis for Graph APIs Focusing on Broken Access Control
- 2 July 2024
- Published by Springer Nature
- p. 180-200
Taint Analysis for Graph APIs Focusing on Broken Access Control
- Open Access
- 14 April 2024
- Published by Association for Computing Machinery (ACM)
- p. 57-60
On an Exemplar Supporting Model-based Quality Assurance Research for Healthcare Systems-of-Systems
As healthcare is being massively digitized, it increasingly relies on the harmonious interaction of autonomous and interconnected software systems. In this context, it becomes crucial to ensure that the emergent behavior that occurs when these systems interact remains beneficial to the overall quality goals. This task requires that the interacting systems are conceptualized and further studied as a System-of-Systems (SoS). We present the design and prototypical implementation of an exemplar for such a Healthcare SoS (HSoS) which consists of different types of basic healthcare systems. Its typical quality goals, e.g., safety and interoperability, and selected technical characteristics, e.g., cloud-nativity and support for integration with robotics, render the exemplar representative of modern healthcare solutions. The exemplar simulates patient journeys which rely on the interaction of the constituent systems and thereby may capture the emergent behavior of the HSoS. Our aim is that the exemplar supports future research on quality assurance for HSoSs using model-based techniques, which are suitable for developing both SoSs and safety-critical systems. For each quality goal, we outline relevant challenges as well as our research plans.
- 14 April 2024
- Published by Association for Computing Machinery (ACM)
- p. 57-60
Open AccessOn an Exemplar Supporting Model-based Quality Assurance Research for Healthcare Systems-of-Systems
As healthcare is being massively digitized, it increasingly relies on the harmonious interaction of autonomous and interconnected software systems. In this context, it becomes crucial to ensure that the emergent behavior that occurs when these systems interact remains beneficial to the overall quality goals. This task requires that the interacting systems are conceptualized and further studied as a System-of-Systems (SoS). We present the design and prototypical implementation of an exemplar for such a Healthcare SoS (HSoS) which consists of different types of basic healthcare systems. Its typical quality goals, e.g., safety and interoperability, and selected technical characteristics, e.g., cloud-nativity and support for integration with robotics, render the exemplar representative of modern healthcare solutions. The exemplar simulates patient journeys which rely on the interaction of the constituent systems and thereby may capture the emergent behavior of the HSoS. Our aim is that the exemplar supports future research on quality assurance for HSoSs using model-based techniques, which are suitable for developing both SoSs and safety-critical systems. For each quality goal, we outline relevant challenges as well as our research plans.
- Open Access
- 6 April 2024
- Published by Springer Nature
- p. 22-55
Foundations for Query-based Runtime Monitoring of Temporal Properties over Runtime Models
In model-driven engineering, runtime monitoring of systems with complex dynamic structures is typically performed via a runtime model capturing a snapshot of the system state: the model is represented as a graph and properties of interest as graph queries which are evaluated over the model online. For temporal properties, history-aware runtime models encode a trace of timestamped snapshots, which is monitored via temporal graph queries. In this case, the query evaluation needs to consider that a trace may be incomplete, thus future changes to the model may affect current answers. So far there is no formal foundation for query-based monitoring over runtime models encoding incomplete traces.In this paper, we present a systematic and formal treatment of incomplete traces. First, we introduce a new definite semantics for a first-order temporal graph logic which only returns answers if no future change to the model will affect them. Then, we adjust the query evaluation semantics of a querying approach we previously presented, which is based on this logic, to the definite semantics of the logic. Lastly, we enable the approach to keep to its efficient query evaluation technique, while returning (the more costly) definite answers.
- 6 April 2024
- Published by Springer Nature
- p. 22-55
Open AccessFoundations for Query-based Runtime Monitoring of Temporal Properties over Runtime Models
In model-driven engineering, runtime monitoring of systems with complex dynamic structures is typically performed via a runtime model capturing a snapshot of the system state: the model is represented as a graph and properties of interest as graph queries which are evaluated over the model online. For temporal properties, history-aware runtime models encode a trace of timestamped snapshots, which is monitored via temporal graph queries. In this case, the query evaluation needs to consider that a trace may be incomplete, thus future changes to the model may affect current answers. So far there is no formal foundation for query-based monitoring over runtime models encoding incomplete traces.In this paper, we present a systematic and formal treatment of incomplete traces. First, we introduce a new definite semantics for a first-order temporal graph logic which only returns answers if no future change to the model will affect them. Then, we adjust the query evaluation semantics of a querying approach we previously presented, which is based on this logic, to the definite semantics of the logic. Lastly, we enable the approach to keep to its efficient query evaluation technique, while returning (the more costly) definite answers.
- Open Access
- 20 December 2021
- Published by Springer Nature in Software and Systems Modeling
- Vol. 21 (5) , 1789-1829
Incremental execution of temporal graph queries over runtime models with history and its applications
Modern software systems are intricate and operate in highly dynamic environments for which few assumptions can be made at design-time. This setting has sparked an interest in solutions that use a runtime model which reflects the system state and operational context to monitor and adapt the system in reaction to changes during its runtime. Few solutions focus on the evolution of the model over time, i.e., its history, although history is required for monitoring temporal behaviors and may enable more informed decision-making. One reason is that handling the history of a runtime model poses an important technical challenge, as it requires tracing a part of the model over multiple model snapshots in a timely manner. Additionally, the runtime setting calls for memory-efficient measures to store and check these snapshots. Following the common practice of representing a runtime model as a typed attributed graph, we introduce a language which supports the formulation of temporal graph queries, i.e., queries on the ordering and timing in which structural changes in the history of a runtime model occurred. We present a querying scheme for the execution of temporal graph queries over history-aware runtime models. Features such as temporal logic operators in queries, the incremental execution, the option to discard history that is no longer relevant to queries, and the in-memory storage of the model, distinguish our scheme from relevant solutions. By incorporating temporal operators, temporal graph queries can be used for runtime monitoring of temporal logic formulas. Building on this capability, we present an implementation of the scheme that is evaluated for runtime querying, monitoring, and adaptation scenarios from two application domains.
- 20 December 2021
- Published by Springer Nature in Software and Systems Modeling
- Vol. 21 (5) , 1789-1829
Open AccessIncremental execution of temporal graph queries over runtime models with history and its applications
Modern software systems are intricate and operate in highly dynamic environments for which few assumptions can be made at design-time. This setting has sparked an interest in solutions that use a runtime model which reflects the system state and operational context to monitor and adapt the system in reaction to changes during its runtime. Few solutions focus on the evolution of the model over time, i.e., its history, although history is required for monitoring temporal behaviors and may enable more informed decision-making. One reason is that handling the history of a runtime model poses an important technical challenge, as it requires tracing a part of the model over multiple model snapshots in a timely manner. Additionally, the runtime setting calls for memory-efficient measures to store and check these snapshots. Following the common practice of representing a runtime model as a typed attributed graph, we introduce a language which supports the formulation of temporal graph queries, i.e., queries on the ordering and timing in which structural changes in the history of a runtime model occurred. We present a querying scheme for the execution of temporal graph queries over history-aware runtime models. Features such as temporal logic operators in queries, the incremental execution, the option to discard history that is no longer relevant to queries, and the in-memory storage of the model, distinguish our scheme from relevant solutions. By incorporating temporal operators, temporal graph queries can be used for runtime monitoring of temporal logic formulas. Building on this capability, we present an implementation of the scheme that is evaluated for runtime querying, monitoring, and adaptation scenarios from two application domains.
- Open Access
- 1 June 2021
- Published by Springer Nature in International Journal on Software Tools for Technology Transfer
- Vol. 23 (3) , 411-488
Formal testing of timed graph transformation systems using metric temporal graph logic
Embedded real-time systems generate state sequences where time elapses between state changes. Ensuring that such systems adhere to a provided specification of admissible or desired behavior is essential. Formal model-based testing is often a suitable cost-effective approach. We introduce an extended version of the formalism of symbolic graphs, which encompasses types as well as attributes, for representing states of dynamic systems. Relying on this extension of symbolic graphs, we present a novel formalism of timed graph transformation systems (TGTSs) that supports the model-based development of dynamic real-time systems at an abstract level where possible state changes and delays are specified by graph transformation rules. We then introduce an extended form of the metric temporal graph logic (MTGL) with increased expressiveness to improve the applicability of MTGL for the specification of timed graph sequences generated by a TGTS. Based on the metric temporal operators of MTGL and its built-in graph binding mechanics, we express properties on the structure and attributes of graphs as well as on the occurrence of graphs over time that are related by their inner structure. We provide formal support for checking whether a single generated timed graph sequence adheres to a provided MTGL specification. Relying on this logical foundation, we develop a testing framework for TGTSs that are specified using MTGL. Lastly, we apply this testing framework to a running example by using our prototypical implementation in the tool AutoGraph.
- 1 June 2021
- Published by Springer Nature in International Journal on Software Tools for Technology Transfer
- Vol. 23 (3) , 411-488
Open AccessFormal testing of timed graph transformation systems using metric temporal graph logic
Embedded real-time systems generate state sequences where time elapses between state changes. Ensuring that such systems adhere to a provided specification of admissible or desired behavior is essential. Formal model-based testing is often a suitable cost-effective approach. We introduce an extended version of the formalism of symbolic graphs, which encompasses types as well as attributes, for representing states of dynamic systems. Relying on this extension of symbolic graphs, we present a novel formalism of timed graph transformation systems (TGTSs) that supports the model-based development of dynamic real-time systems at an abstract level where possible state changes and delays are specified by graph transformation rules. We then introduce an extended form of the metric temporal graph logic (MTGL) with increased expressiveness to improve the applicability of MTGL for the specification of timed graph sequences generated by a TGTS. Based on the metric temporal operators of MTGL and its built-in graph binding mechanics, we express properties on the structure and attributes of graphs as well as on the occurrence of graphs over time that are related by their inner structure. We provide formal support for checking whether a single generated timed graph sequence adheres to a provided MTGL specification. Relying on this logical foundation, we develop a testing framework for TGTSs that are specified using MTGL. Lastly, we apply this testing framework to a running example by using our prototypical implementation in the tool AutoGraph.
- Open Access
- 22 March 2021
- Published by Morressier GmbH
Keeping Pace with the History of Evolving Runtime Models
Structural runtime models provide a snapshot of the constituents of a system and their state. Capturing the history of runtime models, i.e., previous snapshots, has been shown to be useful for a number of aims. Handling, however, history at runtime poses important challenges to tool support. We present the InTempo tool which is based on the Eclipse Modeling Framework and encodes
- 22 March 2021
- Published by Morressier GmbH
Open AccessKeeping Pace with the History of Evolving Runtime Models
Structural runtime models provide a snapshot of the constituents of a system and their state. Capturing the history of runtime models, i.e., previous snapshots, has been shown to be useful for a number of aims. Handling, however, history at runtime poses important challenges to tool support. We present the InTempo tool which is based on the Eclipse Modeling Framework and encodes
- Open Access
- 20 March 2021
- Published by Springer Nature
- Vol. 12649, 262-268
Keeping Pace with the History of Evolving Runtime Models
Structural runtime models provide a snapshot of the constituents of a system and their state. Capturing the history of runtime models, i.e., previous snapshots, has been shown to be useful for a number of aims. Handling, however, history at runtime poses important challenges to tool support. We present the InTempo tool which is based on the Eclipse Modeling Framework and encodes runtime models as graphs. Key features of InTempo, such as, the integration of temporal requirements into graph queries, the in-memory storage of the model, and a systematic method to contain the model’s memory consumption, intend to address issues which seemingly place limitations on the available tool support. InTempo offers two operation modes which support both runtime and postmortem application scenarios.
- 20 March 2021
- Published by Springer Nature
- Vol. 12649, 262-268
Open AccessKeeping Pace with the History of Evolving Runtime Models
Structural runtime models provide a snapshot of the constituents of a system and their state. Capturing the history of runtime models, i.e., previous snapshots, has been shown to be useful for a number of aims. Handling, however, history at runtime poses important challenges to tool support. We present the InTempo tool which is based on the Eclipse Modeling Framework and encodes runtime models as graphs. Key features of InTempo, such as, the integration of temporal requirements into graph queries, the in-memory storage of the model, and a systematic method to contain the model’s memory consumption, intend to address issues which seemingly place limitations on the available tool support. InTempo offers two operation modes which support both runtime and postmortem application scenarios.
- Open Access
- 16 October 2020
- Published by Association for Computing Machinery (ACM)
- p. 175-186
A scalable querying scheme for memory-efficient runtime models with history
Runtime models provide a snapshot of a system at runtime at a desired level of abstraction. Via a causal connection to the modeled system and by employing model-driven engineering techniques, models support schemes for runtime adaptation where data from previous snapshots facilitates more informed decisions. Although runtime models and model-based adaptation techniques have been the focus of extensive research, schemes that treat the evolution of the model over time as a first-class citizen have only lately received attention. Consequently, there is a lack of sophisticated technology for such runtime models with history. We present a querying scheme where the integration of temporal requirements with incremental model queries enables scalable querying for runtime models with history. Moreover, our scheme provides for a memory-efficient storage of such models. By integrating these two features into an adaptation loop, we enable efficient history-aware self-adaptation via runtime models, of which we present a reference implementation.
- 16 October 2020
- Published by Association for Computing Machinery (ACM)
- p. 175-186
Open AccessA scalable querying scheme for memory-efficient runtime models with history
Runtime models provide a snapshot of a system at runtime at a desired level of abstraction. Via a causal connection to the modeled system and by employing model-driven engineering techniques, models support schemes for runtime adaptation where data from previous snapshots facilitates more informed decisions. Although runtime models and model-based adaptation techniques have been the focus of extensive research, schemes that treat the evolution of the model over time as a first-class citizen have only lately received attention. Consequently, there is a lack of sophisticated technology for such runtime models with history. We present a querying scheme where the integration of temporal requirements with incremental model queries enables scalable querying for runtime models with history. Moreover, our scheme provides for a memory-efficient storage of such models. By integrating these two features into an adaptation loop, we enable efficient history-aware self-adaptation via runtime models, of which we present a reference implementation.