Context-Dependent Effects and Concurrency in Guarded Interaction Trees

2025-12-12

AI Summary

This paper addresses the failure of traditional compositional principles—such as binding rules in program logics—due to context-sensitive effects (e.g., `call/cc`, `shift`/`reset`). We propose a conservative extension of Guarded Interaction Trees (GIT) to restore compositionality. Methodologically, we unify context-dependent effects and preemptive concurrency within GIT for the first time; adopt direct-style denotational semantics paired with an extended program logic; and support modular verification via atomic state operations (e.g., compare-and-swap), while fully preserving existing reasoning principles for context-free effects. Our contributions are threefold: (1) a type-safety proof for safe interoperability between delimited continuations and higher-order store; (2) a proof of adequacy—i.e., that the denotational semantics fully reflects the operational semantics; and (3) a verifiable, formal foundation for concurrent data structures.

Technology Category

• Constraint Satisfaction and Optimization: Satisfiability Modulo Theories
• Knowledge Representation and Reasoning: Logic Programming
• Reasoning under Uncertainty: Other Foundations of Reasoning under Uncertainty

Application Category

• Security and Privacy: Data transparency and provenance
• Semantics and Knowledge: Provenance, trust, security and privacy, and ethical issues in managing semantic data
• Graph Algorithms and Modeling for the Web: Efficient manipulation of static and dynamic Web-related graphs

Abstract

Guarded Interaction Trees are a structure and a fully formalized framework for representing higher-order computations with higher-order effects in Rocq. We present an extension of Guarded Interaction Trees to support formal reasoning about context-dependent effects. That is, effects whose behaviors depend on the evaluation context, e.g., call/cc, shift and reset. Using and reasoning about such effects is challenging since certain compositionality principles no longer hold in the presence of such effects. For example, the so-called ``bind rule'' in modern program logics is no longer valid. The goal of our extension is to support representation and reasoning about context-dependent effects in the most painless way possible. To that end, our extension is conservative: the reasoning principles for context-independent effects remain the same. We use it to give direct-style denotational semantics for higher-order programming languages with call/cc and with delimited continuations. We extend the program logic for Guarded Interaction Trees to account for context-dependent effects, and we use the program logic to prove that the denotational semantics is adequate with respect to the operational semantics. Additionally, we retain the ability to combine multiple effects in a modular way, which we demonstrate by showing type soundness for safe interoperability of a programming language with delimited continuations and a programming language with higher-order store. Furthermore, as another contribution, in addition to context-dependent effects, we show how to extend Guarded Interaction Trees with preemptive concurrency. To support implementation and verification of concurrent data structures and algorithms in the presence of preemptive concurrency one requires atomic state modification operations, e.g., compare-and-exchange.

Problem

• Extends Guarded Interaction Trees for context-dependent effects representation
• Develops program logic for reasoning about context-dependent effects
• Adds preemptive concurrency support for concurrent data structures verification

Innovation

• Extended Guarded Interaction Trees for context-dependent effects
• Conservative extension maintaining modular reasoning principles
• Added preemptive concurrency support for concurrent algorithms