Concrete Semantics Research Articles

Automating Pruning in Top-Down Enumeration for Program Synthesis Problems with Monotonic Semantics

In top-down enumeration for program synthesis, abstraction-based pruning uses an abstract domain to approximate the set of possible values that a partial program, when completed, can output on a given input. If the set does not contain the desired output, the partial program and all its possible completions can be pruned. In its general form, abstraction-based pruning requires manually designed, domain-specific abstract domains and semantics, and thus has only been used in domain-specific synthesizers. This paper provides sufficient conditions under which a form of abstraction-based pruning can be automated for arbitrary synthesis problems in the general-purpose Semantics-Guided Synthesis (SemGuS) framework without requiring manually-defined abstract domains. We show that if the semantics of the language for which we are synthesizing programs exhibits some monotonicity properties, one can obtain an abstract interval-based semantics for free from the concrete semantics of the programming language, and use such semantics to effectively prune the search space. We also identify a condition that ensures such abstract semantics can be used to compute a precise abstraction of the set of values that a program derivable from a given hole in a partial program can produce. These precise abstractions make abstraction-based pruning more effective. We implement our approach in a tool, Moito, which can tackle synthesis problems defined in the SemGuS framework. Moito can automate interval-based pruning without any a-priori knowledge of the problem domain, and solve synthesis problems that previously required domain-specific, abstraction-based synthesizers— e.g., synthesis of regular expressions, CSV file schema, and imperative programs from examples.

When long jumps fall short: control-flow tracking and misuse detection for nonlocal jumps in C

The C programming language offers setjmp/ longjmp as a mechanism for nonlocal control flow. This mechanism has complicated semantics. As most developers do not encounter it day-to-day, they may be unfamiliar with all its intricacies – leading to subtle programming errors. At the same time, most static analyzers lack proper support, implying that otherwise sound tools miss whole classes of program deficiencies. We propose a concrete semantics of a subset of C with setjmp/ longjmp, where interprocedural longjmps are performed directly, as well as an equivalent formulation where such jumps are implemented via stack-unwinding at the call-sites. Reflecting this semantic equivalence, we propose an approach for lifting existing interprocedural analyses to support setjmp/ longjmp and to flag their misuse. To deal with the nonlocal semantics, our approach leverages side-effecting transfer functions, which, when executed, may additionally trigger contributions for program points that are not static control-flow successors. We showcase our analysis on a real-world example and propose a set of litmus tests for other analyzers.

Locally Abstract, Globally Concrete Semantics of Concurrent Programming Languages

Formal, mathematically rigorous programming language semantics are the essential prerequisite for the design of logics and calculi that permit automated reasoning about concurrent programs. We propose a novel modular semantics designed to align smoothly with program logics used in deductive verification and formal specification of concurrent programs. Our semantics separates local evaluation of expressions and statements performed in an abstract, symbolic environment from their composition into global computations, at which point they are concretised. This makes incremental addition of new language concepts possible, without the need to revise the framework. The basis is a generalisation of the notion of a program trace as a sequence of evolving states that we enrich with event descriptors and trailing continuation markers. This allows to postpone scheduling constraints from the level of local evaluation to the global composition stage, where well-formedness predicates over the event structure declaratively characterise a wide range of concurrency models. We also illustrate how a sound program logic and calculus can be defined for this semantics.

Age-related differences in the interhemispheric asymmetry of local cortical responses to abstract and concrete verbs in children: a magnetic mismatch negativity study

BACKGROUND: The development of brain neural networks that support lexico-semantic processing in children remains a poorly understood topic in neuroscience. Meanwhile, investigations in adults have provided ample evidence regarding the brain circuits underpinning the processing of abstract and concrete semantics. These studies have shown that interhemispheric asymmetry in neural responses across modal and amodal cortical areas might be an important marker that helps in distinguishing these two types of semantics, with more left-lateralized activity patterns for abstract than concrete word comprehension. However, little is known about such distinctions in children; thus, addressing this gap was the goal of this study. AIM: This study aimed to investigate age-related differences in the lateralization of neural response patterns associated with the processing of abstract and concrete semantics in children. METHODS: This study employed magnetoencephalography and a mismatch negativity (MMN) paradigm in a group of 41 healthy children aged 5–13 years. The participants were passively exposed to the auditory series of abstract and concrete Russian verbs presented outside the focus of attention. Spatiotemporal patterns of the dynamics of neuromagnetic sources activity were reconstructed using minimum-norm estimate within predefined regions of interest: primary auditory cortex, primary motor cortex, and inferior frontal gyrus of both hemispheres. The magnitudes of MMN responses were further compared statistically between the two hemispheres within two age groups: younger (aged 5–9 years) and older (aged 10–13 years) children. RESULTS: Regionally specific differences were found in the lateralization of event-related MMN responses to concrete compared with abstract words in motor and inferior frontal cortical areas (paired permutation tests, p 0.05). Moreover, in the younger group (aged 5–9 years), responses to the abstract and pseudoword stimulus were left-lateralized, and this effect was most pronounced in the inferior frontal regions (45 and 47 Brodmann fields) of the left hemisphere. In the older group (aged 10–13 years), no pronounced left-lateralized response was observed in these areas. However, for the concrete hand action verb stimulus, different patterns of the interhemispheric asymmetry of the hand motor area responses were observed: the response in the younger group was right-lateralized, whereas in the older group, the response was bilateral. CONCLUSION: The present area- and hemisphere-specific dynamics of neuromagnetic responses in the motor cortex and Broca’s area might correlate with the age-related changes in neurocognitive strategies for the comprehension of abstract and concrete language.

Involvement of Broca’s Area and Its Right Hemispheric Homologue in Acquiring Abstract and Concrete Semantics: Transcranial Direct Current Stimulation Study

Involvement of Broca’s Area and Its Right Hemispheric Homologue in Acquiring Abstract and Concrete Semantics: Transcranial Direct Current Stimulation Study

The Involvement of Broca’s Area and Its Right-Hemispheric Homologue in Acquiring Abstract and Concrete Semantics: Transcranial Direct-Current Stimulation Study

The study compared effects of transcranial direct current stimulation (tDCS) of Broca’s area and of its right-hemispheric homologue on the acquisition of novel concrete and abstract words. Word/concept acquisition was achieved through reading sets of sentences, which incorporated novel words, gradually revealing their meaning through context. Before the learning session, a 15-minute anodal or cathodal stimulation of one of the target areas was applied. Lexical decision task was used to assess the learning outcomes immediately after the learning session and 24 hours later. The results showed a larger number of correct responses after right-hemispheric tDCS, in comparison with that of Broca’s area in the left hemisphere. These results suggest that the right-hemispheric counterpart of Broca’s areas is involved in the processing and acquisition of new concrete and abstract semantics. Furthermore, they demonstrate facilitatory effects of tDCS on the processes of overnight consolidation of newly formed word memory traces.

Synthesizing abstract transformers

This paper addresses the problem of creating abstract transformers automatically. The method we present automates the construction of static analyzers in a fashion similar to the way yacc automates the construction of parsers. Our method treats the problem as a program-synthesis problem. The user provides specifications of (i) the concrete semantics of a given operation op , (ii) the abstract domain A to be used by the analyzer, and (iii) the semantics of a domain-specific language L in which the abstract transformer is to be expressed. As output, our method creates an abstract transformer for op in abstract domain A , expressed in L (an “ L -transformer for op over A ”). Moreover, the abstract transformer obtained is a most-precise L -transformer for op over A ; that is, there is no other L -transformer for op over A that is strictly more precise. We implemented our method in a tool called AMURTH. We used AMURTH to create sets of replacement abstract transformers for those used in two existing analyzers, and obtained essentially identical performance. However, when we compared the existing transformers with the transformers obtained using AMURTH, we discovered that four of the existing transformers were unsound, which demonstrates the risk of using manually created transformers.

Spatiotemporal target selection for intracranial neural decoding of abstract and concrete semantics.

Decoding the inner representation of a word meaning from human cortical activity is a substantial challenge in the development of speech brain-machine interfaces (BMIs). The semantic aspect of speech is a novel target of speech decoding that may enable versatile communication platforms for individuals with impaired speech ability; however, there is a paucity of electrocorticography studies in this field. We decoded the semantic representation of a word from single-trial cortical activity during an imageability-based property identification task that required participants to discriminate between the abstract and concrete words. Using high gamma activity in the language-dominant hemisphere, a support vector machine classifier could discriminate the 2-word categories with significantly high accuracy (73.1 ± 7.5%). Activities in specific time components from two brain regions were identified as significant predictors of abstract and concrete dichotomy. Classification using these feature components revealed that comparable prediction accuracy could be obtained based on a spatiotemporally targeted decoding approach. Our study demonstrated that mental representations of abstract and concrete word processing could be decoded from cortical high gamma activities, and the coverage of implanted electrodes and time window of analysis could be successfully minimized. Our findings lay the foundation for the future development of semantic-based speech BMIs.

A formal foundation for symbolic evaluation with merging

Reusable symbolic evaluators are a key building block of solver-aided verification and synthesis tools. A reusable evaluator reduces the semantics of all paths in a program to logical constraints, and a client tool uses these constraints to formulate a satisfiability query that is discharged with SAT or SMT solvers. The correctness of the evaluator is critical to the soundness of the tool and the domain properties it aims to guarantee. Yet so far, the trust in these evaluators has been based on an ad-hoc foundation of testing and manual reasoning. This paper presents the first formal framework for reasoning about the behavior of reusable symbolic evaluators. We develop a new symbolic semantics for these evaluators that incorporates state merging. Symbolic evaluators use state merging to avoid path explosion and generate compact encodings. To accommodate a wide range of implementations, our semantics is parameterized by a symbolic factory, which abstracts away the details of merging and creation of symbolic values. The semantics targets a rich language that extends Core Scheme with assumptions and assertions, and thus supports branching, loops, and (first-class) procedures. The semantics is designed to support reusability, by guaranteeing two key properties: legality of the generated symbolic states, and the reducibility of symbolic evaluation to concrete evaluation. Legality makes it simpler for client tools to formulate queries, and reducibility enables testing of client tools on concrete inputs. We use the Lean theorem prover to mechanize our symbolic semantics, prove that it is sound and complete with respect to the concrete semantics, and prove that it guarantees legality and reducibility. To demonstrate the generality of our semantics, we develop Leanette, a reference evaluator written in Lean, and Rosette 4, an optimized evaluator written in Racket. We prove Leanette correct with respect to the semantics, and validate Rosette 4 against Leanette via solver-aided differential testing. To demonstrate the practicality of our approach, we port 16 published verification and synthesis tools from Rosette 3 to Rosette 4. Rosette 3 is an existing reusable evaluator that implements the classic merging semantics, adopted from bounded model checking. Rosette 4 replaces the semantic core of Rosette 3 but keeps its optimized symbolic factory. Our results show that Rosette 4 matches the performance of Rosette 3 across a wide range of benchmarks, while providing a cleaner interface that simplifies the implementation of client tools.

Acquisition of concrete and abstract words is modulated by tDCS of Wernicke\u2019s area

Previous behavioural and neuroimaging research suggested distinct cortical systems involved in processing abstract and concrete semantics; however, there is a dearth of causal evidence to support this. To address this, we applied anodal, cathodal, or sham (placebo) tDCS over Wernicke’s area before a session of contextual learning of novel concrete and abstract words (n = 10 each), presented five times in short stories. Learning effects were assessed at lexical and semantic levels immediately after the training and, to attest any consolidation effects of overnight sleep, on the next day. We observed successful learning of all items immediately after the session, with decreased performance in Day 2 assessment. Importantly, the results differed between stimulation conditions and tasks. Whereas the accuracy of semantic judgement for abstract words was significantly lower in the sham and anodal groups on Day 2 vs. Day 1, no significant performance drop was observed in the cathodal group. Similarly, the cathodal group showed no significant overnight performance reduction in the free recall task for either of the stimuli, unlike the other two groups. Furthermore, between-group analysis showed an overall better performance of both tDCS groups over the sham group, particularly expressed for abstract semantics and cathodal stimulation. In sum, the results suggest overlapping but diverging brain mechanisms for concrete and abstract semantics and indicate a larger degree of involvement of core language areas in storing abstract knowledge. Furthermore, they demonstrate a possiblity to improve learning outcomes using neuromodulatory techniques.

Concrete vs. Abstract Semantics: From Mental Representations to Functional Brain Mapping.

The nature of abstract and concrete semantics and differences between them have remained a debated issue in psycholinguistic and cognitive studies for decades. Most of the available behavioral and neuroimaging studies reveal distinctions between these two types of semantics, typically associated with a so-called “concreteness effect.” Many attempts have been made to explain these differences using various approaches, from purely theoretical linguistic and cognitive frameworks to neuroimaging experiments. In this brief overview, we will try to provide a snapshot of these diverse views and relationships between them and highlight the crucial issues preventing this problem from being solved. We will argue that one potentially beneficial way forward is to identify the neural mechanisms underpinning acquisition of the different types of semantics (e.g., by using neurostimulation techniques to establish causal relationships), which may help explain the distinctions found between the processing of concrete and abstract semantics.

A Framework for Rewriting Families of String Diagrams

We describe a mathematical framework for equational reasoning about infinite families of string diagrams which is amenable to computer automation. The framework is based on context-free families of string diagrams which we represent using context-free graph grammars. We model equations between infinite families of diagrams using rewrite rules between context-free grammars. Our framework represents equational reasoning about concrete string diagrams and context-free families of string diagrams using double-pushout rewriting on graphs and context-free graph grammars respectively. We prove that our representation is sound by showing that it respects the concrete semantics of string diagrammatic reasoning and we show that our framework is appropriate for software implementation by proving the membership problem is decidable.

Incompleteness of Intuitionistic Propositional Logic with Respect to Proof-Theoretic Semantics

Prawitz proposed certain notions of proof-theoretic validity and conjectured that intuitionistic logic is complete for them [11, 12]. Considering propositional logic, we present a general framework of five abstract conditions which any proof-theoretic semantics should obey. Then we formulate several more specific conditions under which the intuitionistic propositional calculus (IPC) turns out to be semantically incomplete. Here a crucial role is played by the generalized disjunction principle. Turning to concrete semantics, we show that prominent proposals, including Prawitz’s, satisfy at least one of these conditions, thus rendering IPC semantically incomplete for them. Only for Goldfarb’s [1] proof-theoretic semantics, which deviates from standard approaches, IPC turns out to be complete. Overall, these results show that basic ideas of proof-theoretic semantics for propositional logic are not captured by IPC.

Program synthesis using abstraction refinement

We present a new approach to example-guided program synthesis based on counterexample-guided abstraction refinement . Our method uses the abstract semantics of the underlying DSL to find a program P whose abstract behavior satisfies the examples. However, since program P may be spurious with respect to the concrete semantics, our approach iteratively refines the abstraction until we either find a program that satisfies the examples or prove that no such DSL program exists. Because many programs have the same input-output behavior in terms of their abstract semantics , this synthesis methodology significantly reduces the search space compared to existing techniques that use purely concrete semantics. While synthesis using abstraction refinement (SYNGAR) could be implemented in different settings, we propose a refinement-based synthesis algorithm that uses abstract finite tree automata (AFTA) . Our technique uses a coarse initial program abstraction to construct an initial AFTA, which is iteratively refined by constructing a proof of incorrectness of any spurious program. In addition to ruling out the spurious program accepted by the previous AFTA, proofs of incorrectness are also useful for ruling out many other spurious programs. We implement these ideas in a framework called Blaze, which can be instantiated in different domains by providing a suitable DSL and its corresponding concrete and abstract semantics. We have used the Blaze framework to build synthesizers for string and matrix transformations, and we compare Blaze with existing techniques. Our results for the string domain show that Blaze compares favorably with FlashFill, a domain-specific synthesizer that is now deployed in Microsoft PowerShell. In the context of matrix manipulations, we compare Blaze against Prose, a state-of-the-art general-purpose VSA-based synthesizer, and show that Blaze results in a 90x speed-up over Prose. In both application domains, Blaze also consistently improves upon the performance of two other existing techniques by at least an order of magnitude.

Static Analysis of Embedded Real-Time Concurrent Software with Dynamic Priorities

In previous work, we developed a sound static analysis by abstract interpretation to check the absence of run-time errors in concurrent programs, focusing on embedded C programs composed of a fixed set of threads in a shared memory. The method is thread-modular: it considers each thread independently, analyzing them with respect to an abstraction of the effect of the other threads, so-called interference, which are also inferred automatically as part of analyzing the threads. The analysis thus proceeds in a series of rounds that reanalyze all threads, gathering an increasing set of interference, until stabilization. We proved that this method is sound and covers all possible thread interleavings. This analysis was integrated into the Astrée industrial-scale static analyzer, deployed in avionics and automotive industries.In this article, we consider the more specific case of programs running under a priority-based real-time scheduler, as is often the case in embedded systems. In such programs, higher priority threads cannot be preempted by lower priority ones (except when waiting explicitly for some resource). The programmer exploits this property to reduce the reliance on locks when protecting critical sections. We show how our analysis can be refined through partitioning in order to take into account the real-time hypothesis, remove spurious interleavings, and gain precision on programs that rely on priorities. Our analysis supports in particular dynamic priorities: we handle explicit modifications of the priorities by the program, as well as implicit ones through the priority ceiling protocol.We illustrate our construction formally on an idealized language. Following previous work, we first provide a concrete semantics in thread-modular denotational form that is complete for safety properties, and then show how to apply classic abstractions to obtain an effective static analyzer, able to detect all run-time errors, data-races, as well as deadlocks. Finally, we briefly discuss our implementation inside the Astrée analyzer and on-going experimentation, with results limited for now to small programs.

A type theory for incremental computational complexity with control flow changes

Incremental computation aims to speed up re-runs of a program after its inputs have been modified slightly. It works by recording a trace of the program's first run and propagating changes through the trace in incremental runs, trying to re-use as much of the original trace as possible. The recent work CostIt is a type and effect system to establish the time complexity of incremental runs of a program, as a function of input changes. However, CostIt is limited in two ways. First, it prohibits input changes that influence control flow. This makes it impossible to type programs that, for instance, branch on inputs that may change. Second, the soundness of CostIt is proved relative to an abstract cost semantics, but it is unclear how the semantics can be realized. In this paper, we address both these limitations. We present DuCostIt, a re-design of CostIt, that combines reasoning about costs of change propagation and costs of from-scratch evaluation. The latter lifts the restriction on control flow changes. To obtain the type system, we refine Flow Caml, a type system for information flow analysis, with cost effects. Additionally, we inherit from CostIt index refinements to track data structure sizes and a co-monadic type. Using a combination of binary and unary step-indexed logical relations, we prove DuCostIt's cost analysis sound relative to not only an abstract cost semantics, but also a concrete semantics, which is obtained by translation to an ML-like language.

Implicit Kripke semantics and ultraproducts in stratified institutions

We propose stratified institutions (a decade old generalised version of the theory of institutions of Goguen and Burstall) as a fully abstract model theoretic approach to modal logic. This allows for a uniform treatment of model theoretic aspects across the great multiplicity of contemporary modal logic systems. Moreover Kripke semantics (in all its manifold variations) is captured in an implicit manner free from the sometimes bulky aspects of explicit Kripke structures, also accommodating other forms of concrete semantics for modal logic systems. The conceptual power of stratified institutions is illustrated with the development of a modal ultraproducts method that is independent of the concrete details of the actual modal logical systems. Consequently, a wide array of compactness results in concrete modal logics may be derived easily.

A unifying survey on weighted logics and weighted automata

Logical formalisms equivalent to weighted automata have been the topic of numerous research papers in the recent years. It started with the seminal result by Droste and Gastin on weighted logics over semir-ings for words. It has been extended in two dimensions by many authors. First, the weight domain has been extended to valuation monoids, valuation structures, etc., to capture more quantitative properties. Along another dimension, different structures such as ranked or unranked trees, nested words, Mazurkiewiz traces, etc., have been considered. The long and involved proofs of equivalences in all these papers are implicitely based on the same core arguments. This article provides a meta-theorem which unifies these different approaches. Towards this, we first introduce a core weighted logic with a minimal number of features and a simplified syntax. Then, we define a new semantics for weighted automata and weighted logics in two phases—an abstract semantics based on multisets of weight structures (independent of particular weight domains) followed by a concrete semantics. We show at the level of the abstract semantics that weighted automata and core weighted logic have the same expressive power. We show how previous results can be recovered from our result by logical reasoning. In this paper, we prove the meta-theorem for words, ranked and unranked trees, showing the robustness of our approach.

Analyzing Program Analyses

We want to prove that a static analysis of a given program is complete, namely, no imprecision arises when asking some query on the program behavior in the concrete (ie, for its concrete semantics) or in the abstract (ie, for its abstract interpretation). Completeness proofs are therefore useful to assign confidence to alarms raised by static analyses. We introduce the completeness class of an abstraction as the set of all programs for which the abstraction is complete. Our first result shows that for any nontrivial abstraction, its completeness class is not recursively enumerable. We then introduce a stratified deductive system to prove the completeness of program analyses over an abstract domain A. We prove the soundness of the deductive system. We observe that the only sources of incompleteness are assignments and Boolean tests --- unlikely a common belief in static analysis, joins do not induce incompleteness. The first layer of this proof system is generic, abstraction-agnostic, and it deals with the standard constructs for program composition, that is, sequential composition, branching and guarded iteration. The second layer is instead abstraction-specific: the designer of an abstract domain A provides conditions for completeness in A of assignments and Boolean tests which have to be checked by a suitable static analysis or assumed in the completeness proof as hypotheses. We instantiate the second layer of this proof system first with a generic nonrelational abstraction in order to provide a sound rule for the completeness of assignments. Orthogonally, we instantiate it to the numerical abstract domains of Intervals and Octagons, providing necessary and sufficient conditions for the completeness of their Boolean tests and of assignments for Octagons.

Abstract Domains of Affine Relations

This article considers some known abstract domains for affine-relation analysis (ARA), along with several variants, and studies how they relate to each other. The various domains represent sets of points that satisfy affine relations over variables that hold machine integers and are based on an extension of linear algebra to modules over a ring (in particular, arithmetic performed modulo 2 w , for some machine-integer width w ). We show that the abstract domains of Müller-Olm/Seidl (MOS) and King/Søndergaard (KS) are, in general, incomparable. However, we give sound interconversion methods. In other words, we give an algorithm to convert a KS element v KS to an overapproximating MOS element v MOS —that is, γ ( v KS ) ⊆ γ ( v MOS —as well as an algorithm to convert an MOS element w MOS to an overapproximating KS element w KS —that is, γ ( w MOS ) ⊆ γ ( w KS ). The article provides insight on the range of options that one has for performing ARA in a program analyzer: —We describe how to perform a greedy, operator-by-operator abstraction method to obtain KS abstract transformers. —We also describe a more global approach to obtaining KS abstract transformers that considers the semantics of an entire instruction, basic block, or other loop-free program fragment. The latter method can yield best abstract transformers, and hence can be more precise than the former method. However, the latter method is more expensive. We also explain how to use the KS domain for interprocedural program analysis using a bit-precise concrete semantics, but without bit blasting.