-
AuDaLa is Turing Complete arXiv.cs.PL Pub Date : 2024-04-19 Tom T. P. Franken, Thomas Neele
AuDaLa is a recently introduced programming language that follows the new data autonomous paradigm. In this paradigm, small pieces of data execute functions autonomously. Considering the paradigm and the design choices of AuDaLa, it is interesting to determine the expressiveness of the language and to create verification methods for it. In this paper, we take our first steps to such a verification
-
Auto-Formula: Recommend Formulas in Spreadsheets using Contrastive Learning for Table Representations arXiv.cs.PL Pub Date : 2024-04-19 Sibei Chen, Yeye He, Weiwei Cui, Ju Fan, Song Ge, Haidong Zhang, Dongmei Zhang, Surajit Chaudhuri
Spreadsheets are widely recognized as the most popular end-user programming tools, which blend the power of formula-based computation, with an intuitive table-based interface. Today, spreadsheets are used by billions of users to manipulate tables, most of whom are neither database experts nor professional programmers. Despite the success of spreadsheets, authoring complex formulas remains challenging
-
Can Language Models Solve Olympiad Programming? arXiv.cs.PL Pub Date : 2024-04-16 Quan Shi, Michael Tang, Karthik Narasimhan, Shunyu Yao
Computing olympiads contain some of the most challenging problems for humans, requiring complex algorithmic reasoning, puzzle solving, in addition to generating efficient code. However, it has been understudied as a domain to evaluate language models (LMs). In this paper, we introduce the USACO benchmark with 307 problems from the USA Computing Olympiad, along with high-quality unit tests, reference
-
AniFrame: A Programming Language for 2D Drawing and Frame-Based Animation arXiv.cs.PL Pub Date : 2024-04-16 Mark Edward M. Gonzales, Hans Oswald A. Ibrahim, Elyssia Barrie H. Ong, Ryan Austin Fernandez
Creative coding is an experimentation-heavy activity that requires translating high-level visual ideas into code. However, most languages and libraries for creative coding may not be adequately intuitive for beginners. In this paper, we present AniFrame, a domain-specific language for drawing and animation. Designed for novice programmers, it (i) features animation-specific data types, operations,
-
Is Next Token Prediction Sufficient for GPT? Exploration on Code Logic Comprehension arXiv.cs.PL Pub Date : 2024-04-13 Mengnan Qi, Yufan Huang, Yongqiang Yao, Maoquan Wang, Bin Gu, Neel Sundaresan
Large language models (LLMs) has experienced exponential growth, they demonstrate remarkable performance across various tasks. Notwithstanding, contemporary research primarily centers on enhancing the size and quality of pretraining data, still utilizing the next token prediction task on autoregressive transformer model structure. The efficacy of this task in truly facilitating the model's comprehension
-
CodeCloak: A Method for Evaluating and Mitigating Code Leakage by LLM Code Assistants arXiv.cs.PL Pub Date : 2024-04-13 Amit Finkman, Eden Bar-Kochva, Avishag Shapira, Dudu Mimran, Yuval Elovici, Asaf Shabtai
LLM-based code assistants are becoming increasingly popular among developers. These tools help developers improve their coding efficiency and reduce errors by providing real-time suggestions based on the developer's codebase. While beneficial, these tools might inadvertently expose the developer's proprietary code to the code assistant service provider during the development process. In this work,
-
Escape with Your Self: Expressive Reachability Types with Sound and Decidable Bidirectional Type Checking arXiv.cs.PL Pub Date : 2024-04-12 Songlin Jia, Guannan Wei, Siyuan He, Yueyang Tang, Yuyan Bao, Tiark Rompf
Despite Rust's success in systems programming, its "shared XOR mutable" principle significantly restricts how mutable values can be used, precluding many useful functional programming idioms. Reachability types are a recent proposal to address the key limitations of Rust-style "shared XOR mutable" approaches by tracking lifetimes and reachability of shared, escaping, and mutable data, even in the presence
-
KestRel: Relational Verification Using E-Graphs for Program Alignment arXiv.cs.PL Pub Date : 2024-04-11 Robert Dickerson, Prasita Mukherjee, Benjamin Delaware
Many interesting program properties involve the execution of multiple programs, including observational equivalence, noninterference, co-termination, monotonicity, and idempotency. One popular approach to reasoning about these sorts of relational properties is to construct and verify a product program: a program whose correctness implies that the individual programs exhibit the desired relational property
-
Almost-Sure Termination by Guarded Refinement arXiv.cs.PL Pub Date : 2024-04-12 Simon Oddershede Gregersen, Alejandro Aguirre, Philipp G. Haselwarter, Joseph Tassarotti, Lars Birkedal
Almost-sure termination is an important correctness property for probabilistic programs, and a number of program logics have been developed for establishing it. However, these logics have mostly been developed for first-order programs written in languages with specific syntactic patterns for looping. In this paper, we consider almost-sure termination for higher-order probabilistic programs with general
-
Mechanised Hypersafety Proofs about Structured Data: Extended Version arXiv.cs.PL Pub Date : 2024-04-09 Vladimir Gladshtein, Qiyuan Zhao, Willow Ahrens, Saman Amarasinghe, Ilya Sergey
Arrays are a fundamental abstraction to represent collections of data. It is often possible to exploit structural properties of the data stored in an array (e.g., repetition or sparsity) to develop a specialised representation optimised for space efficiency. Formally reasoning about correctness of manipulations with such structured data is challenging, as they are often composed of multiple loops with
-
Comparison of Three Programming Error Measures for Explaining Variability in CS1 Grades arXiv.cs.PL Pub Date : 2024-04-09 Valdemar Švábenský, Maciej Pankiewicz, Jiayi Zhang, Elizabeth B. Cloude, Ryan S. Baker, Eric Fouh
Programming courses can be challenging for first year university students, especially for those without prior coding experience. Students initially struggle with code syntax, but as more advanced topics are introduced across a semester, the difficulty in learning to program shifts to learning computational thinking (e.g., debugging strategies). This study examined the relationships between students'
-
Meaningfulness and Genericity in a Subsuming Framework arXiv.cs.PL Pub Date : 2024-04-09 Delia Kesner, Victor Arrial, Giulio Guerrieri
This paper studies the notion of meaningfulness for a unifying framework called dBang-calculus, which subsumes both call-by-name (dCbN) and call-by-value (dCbV). We first characterize meaningfulness in dBang by means of typability and inhabitation in an associated non-idempotent intersection type system previously proposed in the literature. We validate the proposed notion of meaningfulness by showing
-
Three Subtyping Algorithms for Binary Session Types and their Complexity Analyses arXiv.cs.PL Pub Date : 2024-04-08 Thien UdomsrirungruangUniversity of Oxford, Nobuko YoshidaUniversity of Oxford
Session types are a type discipline for describing and specifying communication behaviours of concurrent processes. Session subtyping, firstly introduced by Gay and Hole, is widely used for enlarging typability of session programs. This paper gives the complexity analysis of three algorithms for subtyping of synchronous binary session types. First, we analyse the complexity of the algorithm from the
-
Behavioural Types for Heterogeneous Systems (Position Paper) arXiv.cs.PL Pub Date : 2024-04-08 Simon FowlerUniversity of Glasgow, Philipp HallerDigital Futures, KTH Royal Institute of Technology, Roland KuhnActyx AG, Sam LindleyThe University of Edinburgh, Alceste ScalasTechnical University of Denmark, Vasco T. VasconcelosUniversity of Lisbon
Behavioural types provide a promising way to achieve lightweight, language-integrated verification for communication-centric software. However, a large barrier to the adoption of behavioural types is that the current state of the art expects software to be written using the same tools and typing discipline throughout a system, and has little support for components over which a developer has no control
-
Session Types for the Transport Layer: Towards an Implementation of TCP arXiv.cs.PL Pub Date : 2024-04-08 Samuel CavojUniversity of Glasgow, Ivan NikitinUniversity of Glasgow, Colin PerkinsUniversity of Glasgow, Ornela DardhaUniversity of Glasgow
Session types are a typing discipline used to formally describe communication-driven applications with the aim of fewer errors and easier debugging later into the life cycle of the software. Protocols at the transport layer such as TCP, UDP, and QUIC underpin most of the communication on the modern Internet and affect billions of end-users. The transport layer has different requirements and constraints
-
A Coq Library of Sets for Teaching Denotational Semantics arXiv.cs.PL Pub Date : 2024-04-08 Qinxiang Cao, Xiwei Wu, Yalun Liang
Sets and relations are very useful concepts for defining denotational semantics. In the Coq proof assistant, curried functions to Prop are used to represent sets and relations, e.g. A -> Prop, A -> B -> Prop, A -> B -> C -> Prop, etc. Further, the membership relation can be encoded by function applications, e.g. X a represents a in X if X: A -> Prop. This is very convenient for developing formal definitions
-
Allo: A Programming Model for Composable Accelerator Design arXiv.cs.PL Pub Date : 2024-04-07 Hongzheng Chen, Niansong Zhang, Shaojie Xiang, Zhichen Zeng, Mengjia Dai, Zhiru Zhang
Special-purpose hardware accelerators are increasingly pivotal for sustaining performance improvements in emerging applications, especially as the benefits of technology scaling continue to diminish. However, designers currently lack effective tools and methodologies to construct complex, high-performance accelerator architectures in a productive manner. Existing high-level synthesis (HLS) tools often
-
KATch: A Fast Symbolic Verifier for NetKAT arXiv.cs.PL Pub Date : 2024-04-07 Mark Moeller, Jules Jacobs, Olivier Savary Belanger, David Darais, Cole Schlesinger, Steffen Smolka, Nate Foster, Alexandra Silva
We develop new data structures and algorithms for checking verification queries in NetKAT, a domain-specific language for specifying the behavior of network data planes. Our results extend the techniques obtained in prior work on symbolic automata and provide a framework for building efficient and scalable verification tools. We present \KATch, an implementation of these ideas in Scala, featuring an
-
From Batch to Stream: Automatic Generation of Online Algorithms arXiv.cs.PL Pub Date : 2024-04-06 Ziteng Wang, Shankara Pailoor, Aaryan Prakash, Yuepeng Wang, Isil Dillig
Online streaming algorithms, tailored for continuous data processing, offer substantial benefits but are often more intricate to design than their offline counterparts. This paper introduces a novel approach for automatically synthesizing online streaming algorithms from their offline versions. In particular, we propose a novel methodology, based on the notion of relational function signature (RFS)
-
IsoPredict: Dynamic Predictive Analysis for Detecting Unserializable Behaviors in Weakly Isolated Data Store Applications arXiv.cs.PL Pub Date : 2024-04-06 Chujun Geng, Spyros Blanas, Michael D. Bond, Yang Wang
This paper presents the first dynamic predictive analysis for data store applications under weak isolation levels, called Isopredict. Given an observed serializable execution of a data store application, Isopredict generates and solves SMT constraints to find an unserializable execution that is a feasible execution of the application. Isopredict introduces novel techniques that handle divergent application
-
Compilation of Modular and General Sparse Workspaces arXiv.cs.PL Pub Date : 2024-04-06 Genghan Zhang, Olivia Hsu, Fredrik Kjolstad
Recent years have seen considerable work on compiling sparse tensor algebra expressions. This paper addresses a shortcoming in that work, namely how to generate efficient code (in time and space) that scatters values into a sparse result tensor. We address this shortcoming through a compiler design that generates code that uses sparse intermediate tensors (sparse workspaces) as efficient adapters between
-
Predictable Verification using Intrinsic Definitions arXiv.cs.PL Pub Date : 2024-04-06 Adithya Murali, Cody Rivera, P. Madhusudan
We propose a novel mechanism of defining data structures using intrinsic definitions that avoids recursion and instead utilizes monadic maps satisfying local conditions. We show that intrinsic definitions are a powerful mechanism that can capture a variety of data structures naturally. We show that they also enable a predictable verification methodology that allows engineers to write ghost code to
-
Linear Contextual Metaprogramming and Session Types arXiv.cs.PL Pub Date : 2024-04-08 Pedro ÂngeloLIACC & Faculdade de Ciências da Universidade do Porto, Portugal, Atsushi IgarashiKyoto University, Kyoto, Japan, Vasco T. VasconcelosLASIGE, Faculdade de Ciências da Universidade de Lisboa, Portugal
We explore the integration of metaprogramming in a call-by-value linear lambda-calculus and sketch its extension to a session type system. We build on a model of contextual modal type theory with multi-level contexts, where contextual values, closing arbitrary terms over a series of variables, may then be boxed and transmitted in messages. Once received, one such value may then be unboxed (with a let-box
-
Quantitative Weakest Hyper Pre: Unifying Correctness and Incorrectness Hyperproperties via Predicate Transformers arXiv.cs.PL Pub Date : 2024-04-07 Linpeng Zhang, Noam Zilberstein, Benjamin Lucien Kaminski, Alexandra Silva
We present a novel \emph{weakest pre calculus} for \emph{reasoning about quantitative hyperproperties} over \emph{nondeterministic and probabilistic} programs. Whereas existing calculi allow reasoning about the expected value that a quantity assumes after program termination from a \emph{single initial state}, we do so for \emph{initial sets of states} or \emph{initial probability distributions}. We
-
GATlab: Modeling and Programming with Generalized Algebraic Theories arXiv.cs.PL Pub Date : 2024-04-07 Owen Lynch, Kris Brown, James Fairbanks, Evan Patterson
Categories and categorical structures are increasingly recognized as useful abstractions for modeling in science and engineering. To uniformly implement category-theoretic mathematical models in software, we introduce GATlab, a domain-specific language for algebraic specification embedded in a technical programming language. GATlab is based on generalized algebraic theories (GATs), a logical system
-
Learning Minimal NAP Specifications for Neural Network Verification arXiv.cs.PL Pub Date : 2024-04-06 Chuqin Geng, Zhaoyue Wang, Haolin Ye, Saifei Liao, Xujie Si
Specifications play a crucial role in neural network verification. They define the precise input regions we aim to verify, typically represented as L-infinity norm balls. While recent research suggests using neural activation patterns (NAPs) as specifications for verifying unseen test set data, it focuses on computing the most refined NAPs, often limited to very small regions in the input space. In
-
Simplifying explicit subtyping coercions in a polymorphic calculus with effects arXiv.cs.PL Pub Date : 2024-04-05 Filip Koprivec, Matija Pretnar
Algebraic effect handlers are becoming increasingly popular way of structuring and reasoning about effectful computations, and their performance is often a concern. One of the proposed approaches towards efficient compilation is tracking effect information through explicit subtyping coercions. However, in the presence of polymorphism, these coercions are compiled to additional arguments of compiled
-
V-Star: Learning Visibly Pushdown Grammars from Program Inputs arXiv.cs.PL Pub Date : 2024-04-05 Xiaodong Jia, Gang Tan
Accurate description of program inputs remains a critical challenge in the field of programming languages. Active learning, as a well-established field, achieves exact learning for regular languages. We offer an innovative grammar inference tool, V-Star, based on the active learning of visibly pushdown automata. V-Star deduces nesting structures of program input languages from sample inputs, employing
-
Proceedings 15th Workshop on Programming Language Approaches to Concurrency and Communication-cEntric Software arXiv.cs.PL Pub Date : 2024-04-04 Diana CostaUniversidade de Lisboa, Raymond HuQueen Mary University of London
This volume contains the proceedings of PLACES 2024, the 15th edition of the Workshop on Programming Language Approaches to Concurrency and Communication-cEntric Software. The PLACES workshop series offers a forum for researchers from different fields to exchange new ideas about the challenges of modern and future programming, where concurrency and distribution are the norm rather than a marginal concern
-
Smart Contract Languages: a comparative analysis arXiv.cs.PL Pub Date : 2024-04-05 Massimo Bartoletti, Lorenzo Benetollo, Michele Bugliesi, Silvia Crafa, Giacomo Dal Sasso, Roberto Pettinau, Andrea Pinna, Mattia Piras, Sabina Rossi, Stefano Salis, Alvise Spanò, Viacheslav Tkachenko, Roberto Tonelli, Roberto Zunino
Decentralized blockchain platforms support the secure exchange of assets among users without relying on trusted third parties. These exchanges are programmed with smart contracts, computer programs directly executed by blockchain nodes. Multiple smart contract languages are available nowadays to developers, each with its own distinctive features, strengths, and weaknesses. In this paper, we examine
-
Towards Trustworthy Automated Program Verifiers: Formally Validating Translations into an Intermediate Verification Language (extended version) arXiv.cs.PL Pub Date : 2024-04-04 Gaurav Parthasarathy, Thibault Dardinier, Benjamin Bonneau, Peter Müller, Alexander J. Summers
Automated program verifiers are typically implemented using an intermediate verification language (IVL), such as Boogie or Why3. A verifier front-end translates the input program and specification into an IVL program, while the back-end generates proof obligations for the IVL program and employs an SMT solver to discharge them. Soundness of such verifiers therefore requires that the front-end translation
-
Equivalence and Similarity Refutation for Probabilistic Programs arXiv.cs.PL Pub Date : 2024-04-04 Krishnendu Chatterjee, Ehsan Kafshdar Goharshady, Petr Novotný, Đorđe Žikelić
We consider the problems of statically refuting equivalence and similarity of output distributions defined by a pair of probabilistic programs. Equivalence and similarity are two fundamental relational properties of probabilistic programs that are essential for their correctness both in implementation and in compilation. In this work, we present a new method for static equivalence and similarity refutation
-
Model Checking Recursive Probabilistic Programs with Conditioning arXiv.cs.PL Pub Date : 2024-04-04 Francesco Pontiggia, Ezio Bartocci, Michele Chiari
We address the problem of model checking temporal logic specifications for probabilistic programs with recursive procedures, nested queries, and conditioning expressed with observe statements. We introduce probabilistic Operator Precedence Automata (pOPA), a new class of probabilistic pushdown automata suitable to model constructs and behaviors of probabilistic programs. We develop a model checking
-
Sound Borrow-Checking for Rust via Symbolic Semantics arXiv.cs.PL Pub Date : 2024-04-03 Son Ho, Aymeric Fromherz, Jonathan Protzenko
The Rust programming language continues to rise in popularity, and as such, warrants the close attention of the programming languages community. In this work, we present a new foundational contribution towards the theoretical understanding of Rust's semantics. We prove that LLBC, a high-level, borrow-centric model previously proposed for Rust's semantics and execution, is sound with regards to a low-level
-
A HAT Trick: Automatically Verifying Representation Invariants Using Symbolic Finite Automata arXiv.cs.PL Pub Date : 2024-04-01 Zhe Zhou, Qianchuan Ye, Benjamin Delaware, Suresh Jagannathan
Functional programs typically interact with stateful libraries that hide state behind typed abstractions. One particularly important class of applications are data structure implementations that rely on such libraries to provide a level of efficiency and scalability that may be otherwise difficult to achieve. However, because the specifications of the methods provided by these libraries are necessarily
-
Activation Steering for Robust Type Prediction in CodeLLMs arXiv.cs.PL Pub Date : 2024-04-02 Francesca Lucchetti, Arjun Guha
Contemporary LLMs pretrained on code are capable of succeeding at a wide variety of programming tasks. However, their performance is very sensitive to syntactic features, such as the names of variables and types, the structure of code, and presence of type hints. We contribute an inference-time technique to make CodeLLMs more robust to syntactic distractors that are semantically irrelevant. Our methodology
-
Polymorphic Records for Dynamic Languages arXiv.cs.PL Pub Date : 2024-03-30 Giuseppe Castagna, Loïc Peyrot
We define and study "row polymorphism" for a type system with set-theoretic types, specifically union, intersection, and negation types. We consider record types that embed row variables and define a subtyping relation by interpreting types into sets of record values and by defining subtyping as the containment of interpretations. We define a functional calculus equipped with operations for field extension
-
Cost-sensitive computational adequacy of higher-order recursion in synthetic domain theory arXiv.cs.PL Pub Date : 2024-03-30 Yue Niu, Jonathan Sterling, Robert Harper
We study a cost-aware programming language for higher-order recursion dubbed $\textbf{PCF}_\mathsf{cost}$ in the setting of synthetic domain theory (SDT). Our main contribution relates the denotational cost semantics of $\textbf{PCF}_\mathsf{cost}$ to its computational cost semantics, a new kind of dynamic semantics for program execution that serves as a mathematically natural alternative to operational
-
There and Back Again: A Netlist's Tale with Much Egraphin' arXiv.cs.PL Pub Date : 2024-03-31 Gus Henry Smith, Zachary D. Sisco, Thanawat Techaumnuaiwit, Jingtao Xia, Vishal Canumalla, Andrew Cheung, Zachary Tatlock, Chandrakana Nandi, Jonathan Balkind
EDA toolchains are notoriously unpredictable, incomplete, and error-prone; the generally-accepted remedy has been to re-imagine EDA tasks as compilation problems. However, any compiler framework we apply must be prepared to handle the wide range of EDA tasks, including not only compilation tasks like technology mapping and optimization (the "there"} in our title), but also decompilation tasks like
-
A formal specification of the jq language arXiv.cs.PL Pub Date : 2024-03-29 Michael Färber
jq is a widely used tool that provides a programming language to manipulate JSON data. However, the jq language is currently only specified by its implementation, making it difficult to reason about its behaviour. To this end, we provide a formal syntax and denotational semantics for a large subset of the jq language. Our most significant contribution is to provide a new way to interpret updates that
-
Offline Imitation Learning from Multiple Baselines with Applications to Compiler Optimization arXiv.cs.PL Pub Date : 2024-03-28 Teodor V. Marinov, Alekh Agarwal, Mircea Trofin
This work studies a Reinforcement Learning (RL) problem in which we are given a set of trajectories collected with K baseline policies. Each of these policies can be quite suboptimal in isolation, and have strong performance in complementary parts of the state space. The goal is to learn a policy which performs as well as the best combination of baselines on the entire state space. We propose a simple
-
ConstraintFlow: A DSL for Specification and Verification of Neural Network Analyses arXiv.cs.PL Pub Date : 2024-03-27 Avaljot Singh, Yasmin Sarita, Charith Mendis, Gagandeep Singh
The uninterpretability of DNNs hinders their deployment to safety-critical applications. Recent works have shown that Abstract-Interpretation-based formal certification techniques provide promising avenues for building trust in DNNs to some extent. The intricate mathematical background of Abstract Interpretation poses two challenges: (i) easily designing the algorithms that capture the intricate DNN
-
Four Formal Models of IEEE 1394 Link Layer arXiv.cs.PL Pub Date : 2024-03-27 Hubert GaravelUniv. Grenoble Alpes, INRIA, CNRS, Grenoble INP, LIG, Grenoble, France, Bas LuttikEindhoven University of Technology, The Netherlands
We revisit the IEEE 1394 high-performance serial bus ("FireWire"), which became a success story in formal methods after three PhD students, by using process algebra and model checking, detected a deadlock error in this IEEE standard. We present four formal models for the asynchronous mode of the Link Layer of IEEE 1394: the original model in muCRL, a simplified model in mCRL2, a revised model in LOTOS
-
CSSTs: A Dynamic Data Structure for Partial Orders in Concurrent Execution Analysis arXiv.cs.PL Pub Date : 2024-03-26 Hünkar Can Tunç, Ameya Prashant Deshmukh, Berk Çirisci, Constantin Enea, Andreas Pavlogiannis
Dynamic analyses are a standard approach to analyzing and testing concurrent programs. Such techniques observe program traces and analyze them to infer the presence or absence of bugs. At its core, each analysis maintains a partial order $P$ that represents order dependencies between events of the analyzed trace $\sigma$. Naturally, the scalability of the analysis largely depends on how efficiently
-
Piecewise Linear Expectation Analysis via $k$-Induction for Probabilistic Programs arXiv.cs.PL Pub Date : 2024-03-26 Tengshun Yang, Hongfei Fu, Jingyu Ke, Naijun Zhan, Shiyang Wu
Quantitative analysis of probabilistic programs aims at deriving tight numerical bounds for probabilistic properties such as expectation and assertion probability, and plays a crucial role in the verification of probabilistic programs. Along this line of research, most existing works consider numerical bounds over the whole state space monolithically and do not consider piecewise bounds. Clearly, monolithic
-
Java Classes with "-Er" and "-Utils" Suffixes Have Higher Complexity arXiv.cs.PL Pub Date : 2024-03-26 Anna Sukhova, Alexey Akhundov, Efim Verzakov, Yegor Bugayenko
In object-oriented programming languages, a belief exists that classes with -Er/-Or and -Utils suffixes are "code smells" because they take over a lot of functional responsibility, turning out to be bulky and complicated, and therefore making it more difficult to maintain the code. In order to validate this intuition, we analyzed complexity and cohesion of 13,861 Java classes from 212 unique open-source
-
FlowFPX: Nimble Tools for Debugging Floating-Point Exceptions arXiv.cs.PL Pub Date : 2024-03-22 Taylor Allred, Xinyi Li, Ashton Wiersdorf, Ben Greenman, Ganesh Gopalakrishnan
Reliable numerical computations are central to scientific computing, but the floating-point arithmetic that enables large-scale models is error-prone. Numeric exceptions are a common occurrence and can propagate through code, leading to flawed results. This paper presents FlowFPX, a toolkit for systematically debugging floating-point exceptions by recording their flow, coalescing exception contexts
-
A hybrid approach to semi-automated Rust verification arXiv.cs.PL Pub Date : 2024-03-22 Sacha-Élie Ayoun, Xavier Denis, Petar Maksimović, Philippa Gardner
While recent years have been witness to a large body of work on efficient and automated verification of safe Rust code, enabled by the rich guarantees of the Rust type system, much less progress has been made on reasoning about unsafe code due to its unique complexities. We propose a hybrid approach to end-to-end Rust verification in which powerful automated verification of safe Rust is combined with
-
Fat API bindings of C++ objects into scripting languages arXiv.cs.PL Pub Date : 2024-03-22 Russell K. Standish
A fat API exposes nearly all of a C++ object's public attributes and methods to a consuming environment, such as a scripting language, or web client. This can be contrasted with a conventional, or thin API, where the API is defined up front, and the C++ object provides the implementation, most of which is private to the C++ layer. Obviously, reflection is required to expose C++ objects to a consuming
-
Lean4Lean: Towards a formalized metatheory for the Lean theorem prover arXiv.cs.PL Pub Date : 2024-03-21 Mario Carneiro
In this paper we present a new "external verifier" for the Lean theorem prover, written in Lean itself. This is the first complete verifier for Lean 4 other than the reference implementation in C++ used by Lean itself, and our new verifier is competitive with the original, running between 20% and 50% slower and usable to verify all of Lean's mathlib library, forming an additional step in Lean's aim
-
E-Syn: E-Graph Rewriting with Technology-Aware Cost Functions for Logic Synthesis arXiv.cs.PL Pub Date : 2024-03-21 Chen Chen, Guangyu Hu, Dongsheng Zuo, Cunxi Yu, Yuzhe Ma, Hongce Zhang
Logic synthesis plays a crucial role in the digital design flow. It has a decisive influence on the final Quality of Results (QoR) of the circuit implementations. However, existing multi-level logic optimization algorithms often employ greedy approaches with a series of local optimization steps. Each step breaks the circuit into small pieces (e.g., k-feasible cuts) and applies incremental changes to
-
Small Scale Reflection for the Working Lean User arXiv.cs.PL Pub Date : 2024-03-19 Vladimir Gladshtein, George Pîrlea, Ilya Sergey
We present the design and implementation of the Small Scale Reflection proof methodology and tactic language (a.k.a. SSR) for the Lean 4 proof assistant. Like its Coq predecessor SSReflect, our Lean 4 implementation, dubbed LeanSSR, provides powerful rewriting principles and means for effective management of hypotheses in the proof context. Unlike SSReflect for Coq, LeanSSR does not require explicit
-
Enhancing Programming Education with ChatGPT: A Case Study on Student Perceptions and Interactions in a Python Course arXiv.cs.PL Pub Date : 2024-03-20 Boxaun Ma, Li Chen, Shin'ichi Konomi
The integration of ChatGPT as a supportive tool in education, notably in programming courses, addresses the unique challenges of programming education by providing assistance with debugging, code generation, and explanations. Despite existing research validating ChatGPT's effectiveness, its application in university-level programming education and a detailed understanding of student interactions and
-
A Coq Mechanization of JavaScript Regular Expression Semantics arXiv.cs.PL Pub Date : 2024-03-18 Noé De Santo, Aurèle Barrière, Clément Pit-Claudel
We present an executable, proven-safe, faithful, and future-proof Coq mechanization of JavaScript regular expression (regex) matching, as specified by the last published edition of ECMA-262 section 22.2. This is, to our knowledge, the first time that an industrial-strength regex language has been faithfully mechanized in an interactive theorem prover. We highlight interesting challenges that arose
-
LOOPer: A Learned Automatic Code Optimizer For Polyhedral Compilers arXiv.cs.PL Pub Date : 2024-03-18 Massinissa Merouani, Khaled Afif Boudaoud, Iheb Nassim Aouadj, Nassim Tchoulak, Islam Kara Bernou, Hamza Benyamina, Fatima Benbouzid-Si Tayeb, Karima Benatchba, Hugh Leather, Riyadh Baghdadi
While polyhedral compilers have shown success in implementing advanced code transformations, they still have challenges in selecting the most profitable transformations that lead to the best speedups. This has motivated the use of machine learning to build cost models to guide the search for polyhedral optimizations. State-of-the-art polyhedral compilers have demonstrated a viable proof-of-concept
-
Data is all you need: Finetuning LLMs for Chip Design via an Automated design-data augmentation framework arXiv.cs.PL Pub Date : 2024-03-17 Kaiyan Chang, Kun Wang, Nan Yang, Ying Wang, Dantong Jin, Wenlong Zhu, Zhirong Chen, Cangyuan Li, Hao Yan, Yunhao Zhou, Zhuoliang Zhao, Yuan Cheng, Yudong Pan, Yiqi Liu, Mengdi Wang, Shengwen Liang, yinhe han, Huawei Li, Xiaowei Li
Recent advances in large language models have demonstrated their potential for automated generation of hardware description language (HDL) code from high-level prompts. Researchers have utilized fine-tuning to enhance the ability of these large language models (LLMs) in the field of Chip Design. However, the lack of Verilog data hinders further improvement in the quality of Verilog generation by LLMs
-
Programming Frameworks for Differential Privacy arXiv.cs.PL Pub Date : 2024-03-17 Marco Gaboardi, Michael Hay, Salil Vadhan
Many programming frameworks have been introduced to support the development of differentially private software applications. In this chapter, we survey some of the conceptual ideas underlying these frameworks in a way that we hope will be helpful for both practitioners and researchers. For practitioners, the survey can provide a starting point for understanding what features may be valuable when selecting
-
NLP Verification: Towards a General Methodology for Certifying Robustness arXiv.cs.PL Pub Date : 2024-03-15 Marco Casadio, Tanvi Dinkar, Ekaterina Komendantskaya, Luca Arnaboldi, Omri Isac, Matthew L. Daggitt, Guy Katz, Verena Rieser, Oliver Lemon
Deep neural networks have exhibited substantial success in the field of Natural Language Processing (NLP) and ensuring their safety and reliability is crucial: there are safety critical contexts where such models must be robust to variability or attack, and give guarantees over their output. Unlike Computer Vision, NLP lacks a unified verification methodology and, despite recent advancements in literature
-
StarMalloc: A Formally Verified, Concurrent, Performant, and Security-Oriented Memory Allocator arXiv.cs.PL Pub Date : 2024-03-14 Antonin Reitz, Aymeric Fromherz, Jonathan Protzenko
In this work, we present StarMalloc, a verified, security-oriented, concurrent memory allocator that can be used as a drop-in replacement in real-world projects. Using the Steel separation logic framework, we show how to specify and verify StarMalloc, relying on dependent types and modular abstractions to enable efficient verification. As part of StarMalloc, we also develop several generic datastructures
-
Formalizing Date Arithmetic and Statically Detecting Ambiguities for the Law arXiv.cs.PL Pub Date : 2024-03-13 Raphaël Monat, Aymeric Fromherz, Denis Merigoux
Legal expert systems routinely rely on date computations to determine the eligibility of a citizen to social benefits or whether an application has been filed on time. Unfortunately, date arithmetic exhibits many corner cases, which are handled differently from one library to the other, making faithfully transcribing the law into code error-prone, and possibly leading to heavy financial and legal consequences