Many formal security criteria in fields like secure compilation (e.g. full abstraction and robust hyperproperty preservation), cryptography (e.g. security games, reduction proofs, and universal composability), and information flow control share a fundamental underlying structure. This underlying structure and related concepts also appear in broader contexts like denotational semantics and computational expressiveness, yet their connections are often overlooked. This paper identifies and systematizes this structure through robust properties (criteria holding in any context), robust abstractions (ensuring preservation of robust properties from abstract to concrete systems) and the new notion of non-degrading abstractions, which guarantees that the concrete system only exhibits concrete violations that are also present in the corresponding abstract system, thereby ensuring no new violations are introduced by the abstraction. By unifying concepts from different areas into a common framework, we highlight existing but underexplored connections, provide new insights and general results, and introduce a valuable perspective for understanding and advancing formal security.

How the brain constructs meaning from individual words and phrases is a fundamental question for research in semantic cognition, language, and their disorders. These two aspects of meaning are traditionally studied separately, resulting in two large, multi-method literatures, which we sought to bring together in this study. Not only would this address basic cognitive questions of how semantic cognition operates but also because, despite their distinct focuses, both literatures ascribe a critical role to the anterior temporal lobe (ATL) in each aspect of semantics. Given these considerations, we explored the notion that these systems rely on common underlying computational principles when activating conceptual semantic representations via single words, versus building a coherent semantic representation across sequences of words. The present pre-registered study used magnetoencephalography and electroencephalography to track brain activity in participants reading nouns and adjective-noun phrases, while integrating conceptual variables from both literatures: the concreteness of nouns (e.g., "lettuce" vs. "fiction") and the denotational semantics of adjectives (subsective vs. privative, e.g., "bad" vs. "fake"). Region-of-interest analyses show that bilateral ATLs responded more strongly to phrases at different time points, irrespective of concreteness. Decoding analyses on ATL signals further revealed a time-varying representational format for adjective semantics, whereas representations of noun concreteness were more stable and maintained for around 300 ms. Further, the neural representation of noun concreteness was modulated by the preceding adjectives: decoders learning concreteness signals in single words generalised better to subsective relative to privative phrases. These findings point to a unified ATL function for semantic memory and composition.

We use the theory of algebraic effects to give a complete equational axiomatization for dynamic threads. Our method is based on parameterized algebraic theories, which give a concrete syntax for strong monads on functor categories, and are a convenient framework for names and binding. Our programs are built from the key primitives 'fork' and 'wait'. 'Fork' creates a child thread and passes its name (thread ID) to the parent thread. 'Wait' allows us to wait for given child threads to finish. We provide a parameterized algebraic theory built from fork and wait, together with basic atomic actions and laws such as associativity of 'fork'. Our equational axiomatization is complete in two senses. First, for closed expressions, it completely captures equality of labelled posets (pomsets), an established model of concurrency: model complete. Second, any two open expressions are provably equal if they are equal under all closing substitutions: syntactically complete. The benefit of algebraic effects is that the semantic analysis can focus on the algebraic operations of fork and wait. We then extend the analysis to a simple concurrent programming language by giving operational and denotational semantics. The denotational semantics is built using the methods of parameterized algebraic theories and we show that it is sound, adequate, and fully abstract at first order for labelled-poset observations.

Differential privacy is a formal definition of privacy that bounds the maximum acceptable information leakage when a query is performed on sensitive data. To ensure this property, a key technique involves bounding the query’s sensitivity (how much input variations affect the output) and adding noise to the result according to this quantity. While prior work like the Fuzz type system focuses on global sensitivity, many useful queries have infinite global sensitivity, restricting the scope of such approaches. This limitation can be addressed by considering a more fine-grained measure: local sensitivity, which quantifies output change for inputs adjacent to a specific dataset. In this article, we introduce Local Fuzz, a type system with dependent coeffects designed to bound the local sensitivity of programs written in a simple functional language. We provide a denotational semantics for this system in the category of extended premetric spaces, leveraging the recently introduced construction of a dependently graded comonad. Finally, we illustrate how Local Fuzz can lead to better differential privacy guarantees than Fuzz, both for mechanisms that rely on global sensitivity and for those that leverage local sensitivity, such as the Propose-Test-Release framework.

Abstract This paper unites two research lines. The first involves finding categorical models of quantum programming languages with recursion and their type systems. The second line concerns the program of quantization of mathematical structures, which amounts to finding noncommutative generalizations (also called quantum generalizations) of these structures. Using a quantization method called discrete quantization , which essentially amounts to the internalization of structures in a category of von Neumann algebras and quantum relations, we find a noncommutative generalization of $\omega$ -complete partial orders (cpos), called quantum cpos . Cpos are central in domain theory and are widely used to construct categorical models of programming languages with recursion. We show that quantum cpos have similar categorical properties to cpos and are therefore suitable for the construction of categorical models for quantum programming languages, which is illustrated with some examples. Because of their noncommutative character, quantum cpos may form the backbone of a future quantum domain theory that provides structural methods for the denotational semantics of recursive quantum programming languages.

As a National Intangible Cultural Heritage, the intricate visual motifs of Teochew woodcarving serve as a concentrated embodiment of the regional culture of the Chaoshan area. Existing research has predominantly focused on its craftsmanship and stylistic evolution, leaving a gap in the structural analysis of its internal meaning-making system. This study introduces a semiotic semantic analysis framework. Using a sample of 203 pieces from the Guangdong Museum collection and employing both quantitative statistics and qualitative interpretation, it systematically deconstructs the semantic layers of Teochew woodcarving. The research reveals that its semantic system exhibits a clear dual structure. At the denotative semantics level, its themes can be categorized into seven major groups—floral and botanical motifs, auspicious animals and mythical beasts, decorative patterns, scenes from operas and classics, folktales, Buddhist and Daoist immortals, and river and marine creatures—forming a referential system reflecting the geography, history, and livelihood of the Chaoshan region. At the connotative semantics level, these themes are transformed, through cultural coding rules such as homophony, metaphor, and allusion, into a dense symbolic network centered on the core aspirations for "blessings, prosperity, longevity, joy, and wealth." This network profoundly manifests the collective psychology and value hierarchy of the Teochew folk society. This study provides a semiotic pathway for Intangible Cultural Heritage (ICH) research, shifting from "formal analysis" to "meaning decoding," and lays a semantic foundation for the contemporary transformation of Teochew woodcarving.

Developing a web-based virtual caring laboratory to enhance nursing students’ caring competence: an ADDIE study

Purpose of research is to create a compiler model for the functional language Common Lisp, implement this model, and test the compiler model using a target virtual machine to increase the execution speed of programs. Methods . A formal compiler model of the functional language Common Lisp was built using denotational semantics. Compilation takes place in several stages. At the first stage, the source language is transformed into an intermediate lambda language in which all macros are expanded, embedded forms are transformed into similar expressions, and variable names are replaced with local, global, and deep references. At the second stage, the expression in the intermediate language is transformed from a tree structure into a linear list of primitive instructions of the target virtual machine. Results . The resulting primitive instructions are encoded using a special assembler into numeric code for execution on the target virtual machine. The compilation also results in a list of constants and the amount of memory required for the compiled program to run. The target virtual machine consists of memory sections for the encoded program, constants, global variables, stack, list of activation frames, registers (accumulator, stack pointer, instruction pointer, current activation frame). Activation frames are array objects that store a pointer to the previous frame, the call depth level number, and local arguments. Garbage collection takes place using the tagging and cleaning method. Conclusion . As a result, a Common Lisp functional language compiler model was built and implemented. Compared to the interpreter, the speed of the program has increased by an average of 20 times. Further speed increases can be achieved by using various compiler optimizations at different stages. Of the simple optimizations, it can be noted: optimization of arithmetic expressions, elimination of unnecessary commands, simplification of expressions.

An imperative programming language is considered that has integer scalar data and one-dimensional arrays. Each variable a in this language is either an integer scalar variable a or an integer one-dimensional array a[k], where k>0 is a positive integer. Such an array has k elements, which are sequentially arranged and numbered as a[0], a[1], ..., a[k-1]. A program is a separate statement, usually a block with a description of local integer variables (scalar or arrays) and a list of statements – the body of the block. All expressions in the statements calculate a scalar integer value. Work with an array is carried out only element by element. If a[k] is an entire one-dimensional array, then access to an individual element of the array is performed by an indexing operation - a record of the form a[e]. The value of the integer expression e – must be an integer from 0 to k-1.In a program, one name can refer to different values (a variable description in the inner and outer blocks). In addition, one array name is associated with multiple values (elements with different indices). To associate variable names with their denotations (memory addresses where the current value of the variable is stored), an environment is used – a value of type Env. type Env = [(String,(Maybe Int, Int))]If Int a is a scalar variable with the denotation (Nothing,3) associated with it in the environment, then 3 is the memory address containing the current value of a. If Int b[4] is an array with which the denotation (Just 4,7) is associated, then 7 is the memory address containing the current value of element b[0], 6 is the address where the value b[1] is found, 5 is the address of b[2], and 4 is the address of b[3], respectively.The functional language Haskell is used to describe this imperative language, which includes syntax and denotational semantics. All functions included in the description are pure. It is shown how to use these functions to build a pure function – a language interpreter.

Human Leukocyte Antigen (HLA) compatibility is a key driver of kidney allograft outcomes, yet how matching interacts with immunosuppressant dosing remains unclear. This study evaluates whether low-resolution HLA match fractions affect mean dosing and quantified the joint impact of match quality and dose on rejection risk. In 519 transplants grouped by HLA match (0-1.0 in 7 strata), full data completeness and variance homogeneity is confirmed, followed by the usage of one-way ANOVA to compare mean doses. Ridge-penalized logistic regression models was fitted at each match level to predict rejection probability across low- and high-dose regimens, deriving absolute and relative risk reductions. ANOVA showed no significant dosing differences by match (F6,512 = 0.93, p = 0.47). Logistic models revealed that Absolute Risk Reduction rose from ~0.75% at zero match to ~1.25% at perfect match, while mid-range match groups (0.2-0.6) yielded the highest total prevented rejections under high-dose therapy. Uniform baseline dosing eliminates bias, allowing clear attribution of benefit to immunologic compatibility. These findings endorse a risk-tailored immunosuppression approach intensifying doses where match is low and potentially reducing them in highly compatible transplants and identify match ranges that maximize rejection prevention.

BackgroundBiospecimen collection from study participants is essential for translational research, but operational challenges in study setup and conduct often impede successful delivery. This study uses a comparative approach to explore key logistical and staffing factors influencing setup duration, recruitment efficiency, sample acquisition, and data completeness across three investigator-led microbiome-wide association studies (MWAS) conducted at cancer centres in Ireland.MethodsThree academic observational MWAS enrolling participants with cancers of the breast, gastrointestinal tract, lung, biliary system, kidney, and skin were compared. Data from three cancer centres were analysed. Key variables included study team composition, administrative infrastructure, and full-time equivalent (FTE) research staffing. Metrics assessed included setup duration, recruitment rates, sample acquisition, and data completeness. Descriptive statistics, correlation analyses, and regression models were used to examine relationships between staffing and study performance.ResultsSetup duration ranged from 30 days (Site B, with a pre-established trials unit) to 390 days (Site A, with no dedicated setup personnel). At Site C, the addition of an Academic Clinical Trials Coordinator reduced the remaining setup timeline from 274 to 185 days. Recruitment rates ranged from 1.1 to 1.3 participants/month, with the highest rates at sites with dedicated research nurses (RN +). Sample acquisition was 100% at RN + sites and 70.5% at the RN− site. Site C achieved full data completeness, defined as comprehensive documentation of screening, exclusions, and follow-up outcomes. Statistical modelling suggested that dedicated staffing (both administrative and clinical) was associated with improvements across all metrics, although small sample size limited statistical significance.ConclusionsDedicated administrative and clinical trial personnel significantly may enhance study efficiency, participant recruitment, and biospecimen collection in academic translational research. This study provides practical insights for improving study design and infrastructure planning in future observational studies. To our knowledge, this is the first multi-site comparative evaluation of operational determinants in academic MWAS.Supplementary InformationThe online version contains supplementary material available at 10.1186/s12967-025-07074-1.

In the literature, two structurally different approaches to associating transition system semantics with event structure models have been distinguished. One approach is based on configurations, which are sets of already executed events. The other approach is based on model residuals, which are not yet executed fragments of the model. Configuration-based transition systems appear to be primarily used for representing the semantics of event structures. Residual-based transition systems are actively applied to demonstrate the consistency between operational and denotational semantics of concurrent process calculi and to visualize models dynamics. Reversible computing is a novel paradigm that has recently emerged and extends traditional forwards-only computation with the capability to execute in the reverse direction, making it possible for computation to run backwards as well as forwards. The present paper focuses on prime event structures extended with asymmetric conflict and causality-respecting reversibility. Two types of transition system semantics are constructed, and their pairwise bisimilarity is proven.

We present a new approach to scaling exact inference for probabilistic programs, using generating functions (GFs) as a compilation target. Existing methods that target representations like binary decision diagrams (BDDs) achieve strong state-of-the-art results. We show that a compiler targeting GFs can be similarly competitive—and, in some cases, more scalable—on a range of inference problems where BDD-based methods perform well. We present a formal model of this compiler, providing the first definition of GF compilation for a functional probabilistic language. We prove that this compiler is correct with respect to a denotational semantics. Our approach is implemented in a probabilistic programming system and evaluated on a range of inference problems. Our results establish GF compilation as a principled and powerful paradigm for exact inference: it offers strong scalability, good expressiveness, and a solid theoretical foundation.

Multi-stage programming is a popular approach to typed meta-programming, reducing abstraction overhead and producing performant programs. However, the traditional quote-and-splice staging syntax, as introduced by Rowan Davies in 1996, can introduce complexities in managing expression evaluation, and also often necessitates sophisticated mechanisms for advanced features such as code pattern matching. This paper introduces λ○▷, a novel staging calculus featuring let-splice bindings, a construct that explicitly binds splice expressions to splice variables, providing flexibility in managing, sharing, and reusing splice computations. Inspired by contextual modal type theory, our type system associates types with a typing context to capture variables dependencies of splice variables. We demonstrate that this mechanism seamlessly scales to features like code pattern matching, by formalizing λ○▷, an extension of λ○▷ pat with code pattern matching and rewriting. We establish the syntactic type soundness of both calculi. Furthermore, we define a denotational semantics using a Kripke-style model, and prove adequacy results. All proofs have been fully mechanized using the Agda proof assistant.

The purpose of the research is to model and implement a system of functions and combinators for parsing languages that can be defined using context-free grammars, as well as to reduce the source code of the parsing program. Methods. Using denotational semantics, a formal model of a system of functions and combinators for parsing was constructed, the type of parsing function was determined, and basic parsing functions were defined: successful parsing, unsuccessful parsing, and predicate parsing. Based on the basic functions, a function for parsing a given character is defined. A formal model of a combinator of a sequence of parsing functions, a combinator of parallel (alternative) parsing, and a combinator of applying a function to the results of parsing is given. Denotational semantics is also used to define combinators for repeating the parsing function.Results. Based on the obtained combinators and parsing functions, the implementation of Common Lisp parsing is demonstrated. First, the grammar of the language in the extended Backus-Naur form is given. Then the parsing func- tions for lexical analysis are given: functions of voids, decimal numbers, hexadecimal numbers, identifiers, and single characters. Then, based on the previous functions, functions for parsing numbers, strings, atoms, lists, arrays, func- tional closures, and the s-expressions themselves are set. The resulting function combining the previous functions is also provided. The resulting program is compared by the LOC metric (number of lines of code) with a reference imple- mentation of a lexical and syntactic analyzer written in C.Conclusion. As a result of the work, a model of a system of functions and combinators for parsing languages that can be specified by context-free grammars was built and implemented. The parsing program using this system is quite compact due to the fact that grammars and semantic rules are written declaratively in almost their denotational form. This allows you to reduce the number of lines of code several times compared to the top-down recursive implementation of parsing.

Abstract interpretation is widely used to determine programs' numerical properties. However, current abstract domains primarily focus on mathematical semantics, which do not fully capture the complexities of real-world programs relying on machine integer semantics and involving extensive bit-vector operations. This paper presents a solution that combines a bit-level abstraction and a word-level abstraction to capture machine integer semantics. First, we generalize the bit-level abstraction used in the Linux eBPF verifier for determining known and unknown bits of real-world programs, by supplementing all required operations as a standard abstract domain. Based on this abstraction, we design an abstract domain that is signedness-aware and simultaneously retains both the above bit-level and the word-level bound information. These two levels of information cooperate via a standard reduced product operation to improve analysis precision. We implement the proposed domains in the Crab analyzer and the out-of-kernel eBPF verifier PREVAL. Experiments demonstrate their effectiveness in analyzing SV-COMP benchmark programs, assisting hardware designs, and eBPF verification.

A singular function is a partial function such that at one or more points, the left and/or right limit diverge (e.g., the function 1/ x ). Since programming languages typically support division, programs may denote singular functions. Although on its own, a singularity may be considered a bug, introducing a division-by-zero error, singular integrals —a version of the integral that is well-defined when the integrand is a singular function and the domain of integration contains a singularity—arise in science and engineering, including in physics, aerodynamics, mechanical engineering, and computer graphics. In this paper, we present the first semantics of a programming language for singular integration. Our differentiable programming language, SingularFlow, supports the evaluation and differentiation of singular integrals. We formally define the denotational semantics of SingularFlow, deriving all the necessary mathematical machinery so that this work is rigorous and self-contained. We then define an operational semantics for SingularFlow that estimates integrals and their derivatives using Monte Carlo samples, and show that the operational semantics is a well-behaved estimator for the denotational semantics. We implement SingularFlow in JAX and evaluate the implementation on a suite of benchmarks that perform the finite Hilbert transform , an integral transform related to the Fourier transform, which arises in domains such as physics and electrical engineering. We then use SingularFlow to approximate the solutions to four singular integral equations —equations where the unknown function is in the integrand of a singular integral—arising in aerodynamics and mechanical engineering.

We introduce a version of probabilistic Kleene algebra with angelic nondeterminism and a corresponding class of automata. Our approach implements semantics via distributions over multisets in order to overcome theoretical barriers arising from the lack of a distributive law between the powerset and Giry monads. We produce a full Kleene theorem and a coalgebraic theory, as well as both operational and denotational semantics and equational reasoning principles.

We present Dependent Lambek Calculus (Lambek D ), a domain-specific dependent type theory for verified parsing and formal grammar theory. In Lambek D , linear types are used as a syntax for formal grammars, and parsers can be written as linear terms. The linear typing restriction provides a form of intrinsic verification that a parser yields only valid parse trees for the input string. We demonstrate the expressivity of this system by showing that the combination of inductive linear types and dependency on non-linear data can be used to encode commonly used grammar formalisms such as regular and context-free grammars as well as traces of various types of automata. Using these encodings, we define parsers for regular expressions using deterministic automata, as well as examples of verified parsers of context-free grammars. We present a denotational semantics of our type theory that interprets the linear types as functions from strings to sets of abstract parse trees and terms as parse transformers. Based on this denotational semantics, we have made a prototype implementation of Lambek D using a shallow embedding in the Agda proof assistant. All of our examples parsers have been implemented in this prototype implementation.

The selection monad on a set consists of selection functions. These select an element from the set, based on a loss (dually, reward) function giving the loss resulting from a choice of an element. Abadi and Plotkin used the monad to model a language with operations making choices of computations taking account of the loss that would arise from each choice. However, their choices were optimal, and they asked if they could instead be programmer provided. In this work, we present a novel design enabling programmers to do so. We present a version of algebraic effect handlers enriched by computational ideas inspired by the selection monad. Specifically, as well as the usual delimited continuations, our new kind of handlers additionally have access to choice continuations, that give the possible future losses. In this way programmers can write operations implementing optimisation algorithms that are aware of the losses arising from their possible choices. We give an operational semantics for a higher-order model language λ C , and establish desirable properties including progress, type soundness, and termination for a subset with a mild hierarchical constraint on allowable operation types. We give this subset a selection monad denotational semantics, and prove soundness and adequacy results. We also present a Haskell implementation and give a variety of programming examples.