yusuke1997/dblp-id-title huggingface dataset:
Quantitative Robustness for Vulnerability Assessment
HasChor: Functional Choreographic Programming for All (Functional Pearl)
A Lazy, Concurrent Convertibility Checker
Automating sized-type inference for complexity analysis
Abstract interpretation of distributed network control planes
A High-Level Separation Logic for Heap Space under Garbage Collection
Semantics-guided synthesis
VIP: verifying real-world C idioms with integer-pointer casts
Quantum Control Machine: The Limits of Control Flow in Quantum Programming
Efficient Formal Verification of Quantum Error Correcting Programs
A Low-Level Look at A-Normal Form
Gradually Typed Languages Should Be Vigilant!
Regular Expression Matching using Bit Vector Automata
Verified three-way program merge
PL4XGL: A Programming Language Approach to Explainable Graph Learning
Quantitative robustness analysis of quantum programs
Perfectly parallel fairness certification of neural networks
Semantics of higher-order probabilistic programs with conditioning
Recurrence Sets for Proving Fair Non-termination under Axiomatic Memory Consistency Models
Efficient and provable local capability revocation using uninitialized capabilities
Impredicative Observational Equality
Fuzzing Guided by Bayesian Program Analysis
Repairing Regular Expressions for Extraction
Durable functions: semantics for stateful serverless
Towards understanding the costs of avoiding out-of-thin-air results
Timely Computation
Explicit Refinement Types
Whip: higher-order contracts for modern services
Soundness of Predictive Concurrency Analyses
Algebras for Deterministic Computation Are Inherently Incomplete
EasyBC: A Cryptography-Specific Language for Security Analysis of Block Ciphers against Differential Cryptanalysis
VST-A: A Foundationally Sound Annotation Verifier
Progressful Interpreters for Efficient WebAssembly Mechanisation
ProbNV: probabilistic verification of network control planes
Empowering union and intersection types with integrated subtyping
Fixpoint games on continuous lattices
Multi-modal program inference: a marriage of pre-trained language models and component-based synthesis
Recurrence extraction for functional programs through call-by-push-value
Automating Equational Proofs in Dirac Notation
Optimization-Directed Compiler Fuzzing for Continuous Translation Validation
Unrealizability Logic
Compiling to Linear Neurons
Making pointer analysis more precise by unleashing the power of selective context sensitivity
Persistence for the masses: RRB-vectors in a systems language
ADEV: Sound Automatic Differentiation of Expected Values of Probabilistic Programs
Gauss: program synthesis by reasoning over graphs
FPL: fast Presburger arithmetic through transprecision
A Modal Deconstruction of Löb Induction
Verifying Indistinguishability of Privacy-Preserving Protocols
One down, 699 to go: or, synthesising compositional desugarings
Mechanizing the CMP Abstraction for Parameterized Verification
Artemis: Toward Accurate Detection of Server-Side Request Forgeries through LLM-Assisted Inter-procedural Path-Sensitive Taint Analysis
A Type System for Safe Intermittent Computing
Isolation without taxation: near-zero-cost transitions for WebAssembly and SFI
Polymorphic types and effects with Boolean unification
Interval Parsing Grammars for File Format Parsing
Verifying spatial properties of array computations
How type errors were fixed and what students did?
FuzzFactory: domain-specific fuzzing with waypoints
A graded dependent type system with a usage-aware semantics
Verified Lock-Free Session Channels with Linking
Automated Verification of Higher-Order Probabilistic Programs via a Dependent Refinement Type System
Monotonicity and the Precision of Program Analysis
Computation focusing
Compilation of sparse array programming models
FlashFill++: Scaling Programming by Example by Cutting to the Chase
Abstracting algebraic effects
Secure RDTs: Enforcing Access Control Policies for Offline Available JSON Data
Fully automated functional fuzzing of Android apps for detecting non-crashing logic bugs
An abstract interpretation for SPMD divergence on reducible control flow graphs
SMT2Test: From SMT Formulas to Effective Test Cases
Understanding the use of lambda expressions in Java
Neurosymbolic repair for low-code formula languages
Live functional programming with typed holes
Static analysis with demand-driven value refinement
MISAAL: Synthesis-Based Automatic Generation of Efficient and Retargetable Semantics-Driven Optimizations
A history of the Oz multiparadigm language
KATch: A Fast Symbolic Verifier for NetKAT
Hygienic macro technology
Game semantics for quantum programming
Mergeable replicated data types
Virtual machine design for parallel dynamic programming languages
Copy-and-patch compilation: a fast compilation algorithm for high-level languages and bytecode
Alpaca: intermittent execution without checkpoints
Scalable linear invariant generation with Farkas' lemma
The Geometry of Causality: Multi-token Geometry of Interaction and Its Causal Unfolding
Handling delimited continuations with dependent types
World age in Julia: optimizing method dispatch in the presence of eval
Solver-based gradual type migration
Intrinsically Typed Sessions with Callbacks (Functional Pearl)
A path to DOT: formalizing fully path-dependent types
Combining Formal and Informal Information in Bayesian Program Analysis via Soft Evidences
Decomposition diversity with symmetric data and codata
StkTokens: enforcing well-bracketed control flow and stack encapsulation using linear capabilities
MacoCaml: Staging Composable and Compilable Macros
The root cause of blame: contracts for intersection and union types
Detecting nondeterministic payment bugs in Ethereum smart contracts
FlowCert: Translation Validation for Asynchronous Dataflow via Dynamic Fractional Permissions
Effectful Software Contracts
Intrinsically-typed definitional interpreters à la carte
Origins of the D programming language
Automated Exploit Generation for Node.js Packages
Not so fast: understanding and mitigating negative impacts of compiler optimizations on code reuse gadget sets
Dataflow-based pruning for speeding up superoptimization
A derivative-based parser generator for visibly Pushdown grammars
Liquid resource types
SimuQ: A Framework for Programming Quantum Hamiltonian Simulation with Analog Compilation
Refinement reflection: complete verification with SMT
Efficient algorithms for dynamic bidirected Dyck-reachability
Adventures in monitorability: from branching to linear time and back again
Verification under Intel-x86 with Persistency
User-Customizable Transpilation of Scripting Languages
Progress of concurrent objects with partial methods
Optimistic Stack Allocation and Dynamic Heapification for Managed Runtimes
Verifying observational robustness against a c11-style memory model
On Circuit Description Languages, Indexed Monads, and Resource Analysis
Program Logics à la Carte
Datatype-generic programming meets elaborator reflection
Executing Microservice Applications on Serverless, Correctly
Abstracting extensible data types: or, rows by any other name
Live Verification in an Interactive Proof Assistant
Reference counting with frame limited reuse
SolType: refinement types for arithmetic overflow in solidity
Property-directed reachability as abstract interpretation in the monotone theory
Modular verification of heap reachability properties in separation logic
Obtaining Information Leakage Bounds via Approximate Model Counting
MarQSim: Reconciling Determinism and Randomness in Compiler Optimization for Quantum Simulation
On Learning Polynomial Recursive Programs
WasmRef-Isabelle: A Verified Monadic Interpreter and Industrial Fuzzing Oracle for WebAssembly
Scaling Abstraction Refinement for Program Analyses in Datalog using Graph Neural Networks
Asynchronous Modal FRP
Twist: sound reasoning for purity and entanglement in Quantum programs
Chaperone contracts for higher-order sessions
Modalities, cohesion, and information flow
Relaxed Memory Concurrency Re-executed
Fat Pointers for Temporal Memory Safety of C
Shiftry: RNN inference in 2KB of RAM
Optimal prediction of synchronization-preserving races
Diagrammatic algebra: from linear to concurrent systems
Correctly Rounded Math Libraries without Worrying about the Application's Rounding Mode
Metamorph: Synthesizing Large Objects from Dafny Specifications
FPCC: Detecting Floating-Point Errors via Chain Conditions
Dynamic type inference for gradual Hindley-Milner typing
Lower your guards: a compositional pattern-match coverage checker
SHARP: fast incremental context-sensitive pointer analysis for Java
Formal Abstractions for Packet Scheduling
Actris: session-type based reasoning in separation logic
Optimising Density Computations in Probabilistic Programs via Automatic Loop Vectorisation
Fast Direct Manipulation Programming with Patch-Reconciliation Correspondence
Familial monads and structural operational semantics
A verified optimizer for Quantum circuits
A Mechanized Semantics for Dataflow Circuits
HFL(Z) Validity Checking for Automated Program Verification
Formally Verified Samplers from Probabilistic Programs with Loops and Conditioning
PP-CSA: Practical Privacy-Preserving Software Call Stack Analysis
SMT Theory Arbitrage: Approximating Unbounded Constraints using Bounded Theories
Bridging the Gap between Real-World and Formal Binary Lifting through Filtered-Simulation
Polymorphic Type Inference for Dynamic Languages
APL since 1978
Formal verification of a concurrent bounded queue in a weak memory model
Achieving high-performance the functional way: a functional pearl on expressing high-performance optimizations as rewrite strategies
Corrigendum: Unrealizability Logic
AST vs. Bytecode: Interpreters in the Age of Meta-Compilation
Reliable and automatic composition of language extensions to C: the ableC extensible language framework
Mechanizing Refinement Types
Generically Automating Separation Logic by Functors, Homomorphisms, and Modules
Versatile event correlation with algebraic effects
Hyperblock Scheduling for Verified High-Level Synthesis
Concurrent size
Certifying the synthesis of heap-manipulating programs
Context Sensitivity without Contexts: A Cut-Shortcut Approach to Fast and Precise Pointer Analysis
Coco: Corecursion with Compositional Heterogeneous Productivity
With or Without You: Programming with Effect Exclusion
Linear types for large-scale systems verification
Mutually Iso-Recursive Subtyping
A Family of Sims with Diverging Interests
Derivative-Guided Symbolic Execution
Flexible presentations of graded monads
Highly illogical, Kirk: spotting type mismatches in the large despite broken contracts, unsound types, and too many linters
Searching entangled program spaces
Reasoning on divergent computations with coaxioms
Outcome Logic: A Unifying Foundation for Correctness and Incorrectness Reasoning
Transactions in relaxed memory architectures
Exact Recursive Probabilistic Programming
A Verified Compiler for a Functional Tensor Language
Reductions for safety proofs
Verifying and improving Halide's term rewriting system with program synthesis
Quantifying and Mitigating Cache Side Channel Leakage with Differential Set
A separation logic for concurrent randomized programs
Taking Out the Toxic Trash: Recovering Precision in Mixed Flow-Sensitive Static Analyses
Oriented Metrics for Bottom-Up Enumerative Synthesis
Programming and execution models for parallel bounded exhaustive testing
How to Evaluate Blame for Gradual Types, Part 2
Comparative Synthesis: Learning Near-Optimal Network Designs by Query
Unveiling Heisenbugs with Diversified Execution
Type-Preserving, Dependence-Aware Guide Generation for Sound, Effective Amortized Probabilistic Inference
Task-Based Tensor Computations on Modern GPUs
Language-parametric static semantic code completion
Structure interpretation of text formats
Sound, complete, and tractable linearizability monitoring for concurrent collections
Relaxing Alias Analysis: Exploring the Unexplored Space
Does blame shifting work?
Scalability and precision by combining expressive type systems and deductive verification
Error Credits: Resourceful Reasoning about Error Bounds for Higher-Order Probabilistic Programs
Quantitative strongest post: a calculus for reasoning about the flow of quantitative information
RefinedRust: A Type System for High-Assurance Verification of Rust Programs
Probabilistic programming semantics for name generation
Implementing and verifying release-acquire transactional memory in C11
Modular specification and verification of closures in Rust
Prototyping a query compiler using Coq (experience report)
AdapTT: Functoriality for Dependent Type Casts
On continuation-passing transformations and expected cost analysis
Reliable and fast DWARF-based stack unwinding
Compacting points-to sets through object clustering
Internal and Observational Parametricity for Cubical Agda
Type-preserving CPS translation of Σ and Π types is not not possible
Taype: A Policy-Agnostic Language for Oblivious Computation
Leveraging Immutability to Validate Hazard Pointers for Optimistic Traversals
One polynomial approximation to produce correctly rounded results of an elementary function for multiple representations and rounding modes
Special Delivery: Programming with Mailbox Types
Handling Higher-Order Effectful Operations with Judgemental Monadic Laws
Stuttering for Free
Of JavaScript AOT compilation performance
Drowzee: Metamorphic Testing for Fact-Conflicting Hallucination Detection in Large Language Models
Diffy: Data-Driven Bug Finding for Configurations
Intrinsically-typed definitional interpreters for imperative languages
Coinductive Proofs for Temporal Hyperliveness
Transfinite step-indexing for termination
Symbolic Automata: Omega-Regularity Modulo Theories
Taking Back Control in an Intermediate Representation for GPU Computing
Do you have space for dessert? a verified space cost semantics for CakeML programs
Semantics of Sets of Programs
Familia: unifying interfaces, type classes, and family polymorphism
Deciding ω-regular properties on linear recurrence sequences
A volatile-by-default JVM for server applications
Feedback-driven semi-supervised synthesis of program transformations
Symmetries in reversible programming: from symmetric rig groupoids to reversible programming languages
Efficient tree-traversals: reconciling parallelism and dense data representations
System FR: formalized foundations for the stainless verifier
FairSquare: probabilistic verification of program fairness
Pretend synchrony: synchronous verification of asynchronous distributed programs
IsoPredict: Dynamic Predictive Analysis for Detecting Unserializable Behaviors in Weakly Isolated Data Store Applications
You Only Linearize Once: Tangents Transpose to Gradients
Hamsaz: replication coordination analysis and synthesis
The next 700 relational program logics
Biparsers: Exact Printing for Data Synchronisation
Cross-component garbage collection
The ART of Sharing Points-to Analysis: Reusing Points-to Analysis Results Safely and Efficiently
Differentially-private software frequency profiling under linear constraints
libLISA: Instruction Discovery and Analysis on x86-64
Building Dynamic System Call Sandbox with Partial Order Analysis
Active Learning of Symbolic NetKAT Automata
Hefty Algebras: Modular Elaboration of Higher-Order Algebraic Effects
Much ADO about failures: a fault-aware model for compositional verification of strongly consistent distributed systems
Formal Verification for JavaScript Regular Expressions: A Proven Mechanized Semantics and Its Applications
A type and scope safe universe of syntaxes with binding: their semantics and proofs
A Constraint Solving Approach to Parikh Images of Regular Languages
A solver-aided language for test input generation
Taming transitive redundancy for context-free language reachability
Refinement kinds: type-safe programming with practical type-level computation
Slotted E-Graphs: First-Class Support for (Bound) Variables in E-Graphs
Equivalences for free: univalent parametricity for effective transport
Elipmoc: advanced decompilation of Ethereum smart contracts
Verifying Almost-Sure Termination for Randomized Distributed Algorithms
Automated Expected Value Analysis of Recursive Programs
Non-linear reasoning for invariant synthesis
Boosting the Performance of Alias-Aware IFDS Analysis with CFL-Based Environment Transformers
Almost-Sure Termination by Guarded Refinement
Preservation of Speculative Constant-Time by Compilation
Live Pattern Matching with Typed Holes
A Family of Fast and Memory Efficient Lock- and Wait-Free Reclamation
Making Formulog Fast: An Argument for Unconventional Datalog Evaluation
Why Are Proofs Relevant in Proof-Relevant Models?
Automated transpilation of imperative to functional code using neural-guided program synthesis
Satune: synthesizing efficient SAT encoders
Compiling symbolic execution with staging and algebraic effects
The fine-grained and parallel complexity of andersen's pointer analysis
CAMP: cost-aware multiparty session protocols
Context-Bounded Verification of Context-Free Specifications
Asphalion: trustworthy shielding against Byzantine faults
Ready, set, verify! applying hs-to-coq to real-world Haskell code (experience report)
Simplicitly: foundations and applications of implicit function types
Initialize once, start fast: application initialization at build time
Incremental Verification of Neural Networks
Bluebell: An Alliance of Relational Lifting and Independence for Probabilistic Reasoning
A large-scale longitudinal study of flaky tests
Merlin: a language server for OCaml (experience report)
The VM already knew that: leveraging compile-time knowledge to optimize gradual typing
Decidable Subtyping of Existential Types for Julia
MonkeyDB: effectively testing correctness under weak isolation levels
More Fixpoints! (Functional Pearl)
A Quantitative Probabilistic Relational Hoare Logic
Parametrised Verification of Intel-x86 Programs
A General Fine-Grained Reduction Theory for Effect Handlers
A Synthetic Reconstruction of Multiparty Session Types
𝜆ₛ: computable semantics for differentiable programming with higher-order functions and datatypes
From enhanced coinduction towards enhanced induction
How Domain Experts Use an Embedded DSL
Specifying concurrent programs in separation logic: morphisms and simulations
Monadic composition for deterministic, parallel batch processing
Specifying and testing GPU workgroup progress models
Relational proofs for quantum programs
Qualifying System F <: Some Terms and Conditions May Apply
On the expressive power of user-defined effects: effect handlers, monadic reflection, delimited control
An abstract domain for certifying neural networks
UniRec: a unimodular-like framework for nested recursions and loops
Full abstraction for the quantum lambda-calculus
Grafs: declarative graph analytics
Synthesizing bijective lenses
Generating circuits with generators
Finch: Sparse and Structured Tensor Programming with Control Flow
Kind inference for datatypes
Label dependent lambda calculus and gradual typing
Compiling Probabilistic Programs for Variable Elimination with Information Flow
Distributions for Compositionally Differentiating Parametric Discontinuities
A practical mode system for recursive definitions
Constrained type families
Program analysis via efficient symbolic abstraction
RapunSL: Untangling Quantum Computing with Separation, Linear Combination and Mixing
Subcubic certificates for CFL reachability
A conceptual framework for safe object initialization: a principled and mechanized soundness proof of the Celsius model
Efficient Incremental Verification of Neural Networks Guided by Counterexample Potentiality
Effect handlers, evidently
Relational verification using reinforcement learning
Counterexample-guided correlation algorithm for translation validation
Implementing a modal dependent type theory
Partial type constructors: or, making ad hoc datatypes less ad hoc
Efficient Algorithms for the Uniform Tokenization Problem
On Feller continuity and full abstraction
Fast Constraint Synthesis for C++ Function Templates
Stream Types
Weak persistency semantics from the ground up: formalising the persistency semantics of ARMv8 and transactional models
Synthetiq: Fast and Versatile Quantum Circuit Synthesis
Cyclic proofs, system t, and the power of contraction
Evaluating the Effectiveness of Deep Learning Models for Foundational Program Analysis Tasks
Context-, flow-, and field-sensitive data-flow analysis using synchronized Pushdown systems
Specification and Verification for Unrestricted Algebraic Effects and Handling
Enabling Bounded Verification of Doubly-Unbounded Distributed Agreement-Based Systems via Bounded Regions
Support Triangle Machine
A model for detecting faults in build specifications
Verifying equivalence of database-driven applications
Relatively complete verification of probabilistic programs: an expressive language for expectation-based reasoning
Merging Inductive Relations
Simple Linear Loops: Algebraic Invariants and Applications
Affect: An Affine Type and Effect System
U-Turn: Enhancing Incorrectness Analysis by Reversing Direction
Gradual verification of recursive heap data structures
An Axiomatic Basis for Computer Programming on the Relaxed Arm-A Architecture: The AxSL Logic
Automated Verification of Soundness of DNN Certifiers
Certifying derivation of state machines from coroutines
Super 8 languages for making movies (functional pearl)
Dependence-aware, unbounded sound predictive race detection
Fast and Efficient Boolean Unification for Hindley-Milner-Style Type and Effect Systems
Finding real bugs in big programs with incorrectness logic
Migrating gradual types
Psym: Efficient Symbolic Exploration of Distributed Systems
Skeletal semantics and their interpretations
Verifying concurrent multicopy search structures
Towards Trustworthy Automated Program Verifiers: Formally Validating Translations into an Intermediate Verification Language
VeriEQL: Bounded Equivalence Verification for Complex SQL Queries with Integrity Constraints
Separation logic for sequential programs (functional pearl)
Learning to blame: localizing novice type errors with data-driven diagnosis
Random testing of a higher-order blockchain language (experience report)
Compiling Classical Sequent Calculus to Stock Hardware: The Duality of Compilation
Realistic Realizability: Specifying ABIs You Can Count On
DynamiTe: dynamic termination and non-termination proofs
Formalising Graph Algorithms with Coinduction
Compiling Structured Tensor Algebra
The essence of online data processing
Cocoon: Static Information Flow Control in Rust
Saggitarius: A DSL for Specifying Grammatical Domains
Contextual dispatch for function specialization
Towards Better Semantics Exploration for Browser Fuzzing
Program Analysis for Adaptive Data Analysis
Formally Verifying Optimizations with Block Simulations
Flan: An Expressive and Efficient Datalog Compiler for Program Analysis
On the complexity of bidirected interleaved Dyck-reachability
GLORE: generalized loop redundancy elimination upon LER-notation
Ramsey Quantifiers in Linear Arithmetics
PureCake: A Verified Compiler for a Lazy Functional Language
Coverage-guided tensor compiler fuzzing with joint IR-pass mutation
The anchor verifier for blocking and non-blocking concurrent software
All for One and One for All: Program Logics for Exploiting Internal Determinism in Parallel Programs
Higher Order Bayesian Networks, Exactly
Greedy Implicit Bounded Quantification
Derivative Based Nonbacktracking Real-World Regex Matching with Backtracking Semantics
Higher-order demand-driven symbolic evaluation
Piecewise Analysis of Probabilistic Programs via 𝑘-Induction
WebRelate: integrating web data with spreadsheets using examples
Detecting argument selection defects
Strong functional pearl: Harper's regular-expression matcher in Cedille
A reasonably gradual type theory
Mark-Scavenge: Waiting for Trash to Take Itself Out
Orca: GC and type system co-design for actor languages
Lexical Effect Handlers, Directly
Exploiting the Sparseness of Control-Flow and Call Graphs for Efficient and On-Demand Algebraic Program Analysis
Extensible Data Types with Ad-Hoc Polymorphism
Quarl: A Learning-Based Quantum Circuit Optimizer
TacTok: semantics-aware proof synthesis
Assertion-based optimization of Quantum programs