yusuke1997/dblp-id-title huggingface dataset:
Enabling accuracy-aware Quantum compilers using symbolic resource estimation
A Concurrent Approach to String Transformation Synthesis
Decision procedures for path feasibility of string-manipulating programs with complex operations
Hypra: A Deductive Program Verifier for Hyper Hoare Logic
Languages with Decidable Learning: A Meta-theorem
Synthesis of data completion scripts using finite tree automata
Finitary polymorphism for optimizing type-directed compilation
A General Noninterference Policy for Polynomial Time
Test generation for higher-order functions in dynamic languages
Fully abstract from static to gradual
Back to Direct Style: Typed and Tight
Bridging the semantic gap between qualitative and quantitative models of distributed systems
Formal verification of a constant-time preserving C compiler
IVT: an efficient method for sharing subtype polymorphic objects
Abstract extensionality: on the properties of incomplete abstract interpretations
Modular Control Plane Verification via Temporal Invariants
Probabilistic Resource-Aware Session Types
What is decidable about string constraints with the ReplaceAll function
Internalizing representation independence with univalence
Improving bug detection via context-based code representation learning and attention-based neural networks
Specification-guided component-based synthesis from effectful libraries
Generalizable synthesis through unification
CF-GKAT: Efficient Validation of Control-Flow Transformations
Learning graph-based heuristics for pointer analysis without handcrafting application-specific features
Hyper Hoare Logic: (Dis-)Proving Program Hyperproperties
Functorial semantics for partial theories
Faster coroutine pipelines
Statically Contextualizing Large Language Models with Typed Holes
Robust and compositional verification of object capability patterns
A metaprogramming framework for formal verification
An Expressive Assertion Language for Quantum Programs
Le temps des cerises: efficient temporal stack safety on capability machines using directed capabilities
A Runtime System for Interruptible Query Processing: When Incremental Computing Meets Fine-Grained Parallelism
A separation logic for effect handlers
Stateful Differential Operators for Incremental Computing
Qubit allocation as a combination of subgraph isomorphism and token swapping
The Fine-Grained Complexity of CFL Reachability
Explainable Program Synthesis by Localizing Specifications
Webs and Flow-Directed Well-Typedness Preserving Program Transformations
Foundations for Deductive Verification of Continuous Probabilistic Programs: From Lebesgue to Riemann and Back
Indexed Streams: A Formal Intermediate Representation for Fused Contraction Programs
RefinedProsa: Connecting Response-Time Analysis with C Verification for Interrupt-Free Schedulers
Solving string constraints with Regex-dependent functions through transducers with priorities and variables
Adversarial examples for models of code
Seneca: Taint-Based Call Graph Construction for Java Object Deserialization
Katara: synthesizing CRDTs with verified lifting
Simplifying dependent reductions in the polyhedral model
A Demonic Outcome Logic for Randomized Nondeterminism
Security Reasoning via Substructural Dependency Tracking
On library correctness under weak memory consistency: specifying and verifying concurrent libraries under declarative consistency models
Tachis: Higher-Order Separation Logic with Credits for Expected Costs
Translating C to safer Rust
Automatic and scalable detection of logical errors in functional programming assignments
A HAT Trick: Automatically Verifying Representation Invariants using Symbolic Finite Automata
Quantitative separation logic: a logic for reasoning about probabilistic pointer programs
Monotone Procedure Summarization via Vector Addition Systems and Inductive Potentials
A quick look at impredicativity
Multiparty motion coordination: from choreographies to robotics programs
Programming with a read-eval-synth loop
Higher-Order MSL Horn Constraints
Destination Calculus: A Linear 𝜆-Calculus for Purely Functional Memory Writes
Making Sense of Multi-threaded Application Performance at Scale with NonSequitur
The Decision Problem for Regular First Order Theories
What Happens When Students Switch (Functional) Languages (Experience Report)
ShareJIT: JIT code cache sharing across processes and its practical implementation
Grisette: Symbolic Compilation as a Functional Programming Library
Parametric quantifiers for dependent type theory
Type-Preserving Flat Closure Optimization
Compilation of dynamic sparse tensor algebra
Show Me Why It's Correct: Saving 1/3 of Debugging Time in Program Repair with Interactive Runtime Comparison
Compositional Security Definitions for Higher-Order Where Declassification
The Long Way to Deforestation: A Type Inference and Elaboration Technique for Removing Intermediate Data Structures
Monadic refinements for relational cost analysis
Monadic compiler calculation (functional pearl)
Cakes That Bake Cakes: Dynamic Computation in CakeML
Synthesizing axiomatizations using logic learning
Algorithmic Conversion with Surjective Pairing: A Syntactic and Untyped Approach
Signature restriction for polymorphic algebraic effects
Exploring C semantics and pointer provenance
TreeFuser: a framework for analyzing and fusing general recursive tree traversals
Precise subtyping for asynchronous multiparty sessions
Neural reverse engineering of stripped binaries using augmented control flow graphs
Thunks and Debits in Separation Logic with Time Credits
Synthesizing contracts correct modulo a test generator
Synthesizing abstract transformers
Pathological Cases for a Class of Reachability-Based Garbage Collectors
Eliminating abstraction overhead of Java stream pipelines using ahead-of-time program optimization
Algebraic Effects Meet Hoare Logic in Cubical Agda
Asynchronous Probabilistic Couplings in Higher-Order Separation Logic
Incrementalizing lattice-based program analyses in Datalog
Register Tiling for Unstructured Sparsity in Neural Network Inference
Qurts: Automatic Quantum Uncomputation by Affine Types with Lifetime
Fast and exact analysis for LRU caches
Mossad: defeating software plagiarism detection
Giving semantics to program-counter labels via secure effects
Inference of Resource Management Specifications
Evaluating and improving semistructured merge
Making weak memory models fair
Calculating dependently-typed compilers (functional pearl)
Disentanglement with Futures, State, and Interaction
Beyond Trees: Calculating Graph-Based Compilers (Functional Pearl)
Distributing intersection and union types with splits and duality (functional pearl)
Scala step-by-step: soundness for DOT with step-indexed logical relations in Iris
Effective lock handling in stateless model checking
Parametric polymorphism and operational improvement
Foundations of strong call by need
C4: verified transactional objects
The tensor algebra compiler
Iso: Request-Private Garbage Collection
A new proof rule for almost-sure termination
Program Synthesis from Partial Traces
Tail Recursion Modulo Context: An Equational Approach
API-Guided Dataset Synthesis to Finetune Large Code Models
Gradual liquid type inference
QuAC: Quick Attribute-Centric Type Inference for Python
ChopChop: A Programmable Framework for Semantically Constraining the Output of Language Models
C to checked C by 3c
The future is ours: prophecy variables in separation logic
Fully Verified Instruction Scheduling
Synthesizing Formal Semantics from Executable Interpreters
Local Contextual Type Inference
Enhancing Static Analysis for Practical Bug Detection: An LLM-Integrated Approach
Steel: proof-oriented programming in a dependently typed concurrent separation logic
Sealing pointer-based optimizations behind pure functions
Reasoning about effect interaction by fusion
When Your Infrastructure Is a Buggy Program: Understanding Faults in Infrastructure as Code Ecosystems
Fairness in responsive parallelism
Algebras for weighted search
Sound garbage collection for C using pointer provenance
Staged selective parser combinators
Proof Automation for Linearizability in Separation Logic
Proof transfer for fast certification of multiple approximate neural networks
Automated lemma synthesis in symbolic-heap separation logic
Proving highly-concurrent traversals correct
Denotational Foundations for Expected Cost Analysis
Fast shadow execution for debugging numerical errors using error free transformations
Towards a Higher-Order Mathematical Operational Semantics
A Lightweight Polyglot Code Transformation Language
Kindly bent to free us
Unboxed Data Constructors: Or, How cpp Decides a Halting Problem
Design, implementation, and application of GPU-based Java bytecode interpreters
RacerD: compositional static race detection
Distributed programming using role-parametric session types in go: statically-typed endpoint APIs for dynamically-instantiated communication structures
Interaction trees: representing recursive and impure programs in Coq
Commutativity Simplifies Proofs of Parameterized Programs
Profile inference revisited
Let Generalization, Polymorphic Recursion, and Variable Minimization in Boolean-Kinded Type Systems
Higher-Order Behavioural Conformances via Fibrations
Label-dependent session types
Sound and Complete Proof Rules for Probabilistic Termination
ImageEye: Batch Image Processing using Program Synthesis
A concurrent program logic with a future and history
Fully abstract module compilation
Statistical Testing of Quantum Programs via Fixed-Point Amplitude Amplification
Modular Primal-Dual Fixpoint Logic Solving for Temporal Verification
Parameterized Algebraic Protocols
Inferring scope through syntactic sugar
A Unifying Approach to Product Constructions for Quantitative Temporal Inference
Functional Programming in Financial Markets (Experience Report)
Full Iso-Recursive Types
Incorrectness logic
Leveraging rust types for modular specification and verification
Handle with care: relational interpretation of algebraic effects and handlers
Program Skeletons for Automated Program Translation
Guaranteed Bounds on Posterior Distributions of Discrete Probabilistic Programs with Loops
CYCLE: Learning to Self-Refine the Code Generation
Reactive caching for composed services: polling at the speed of push
Backpropagation in the simply typed lambda-calculus with linear negation
Recalling a witness: foundations and applications of monotonic state
Iterative-Epoch Online Cycle Elimination for Context-Free Language Reachability
A Gradual Probabilistic Lambda Calculus
Loop Rerolling for Hardware Decompilation
PulseCore: An Impredicative Concurrent Separation Logic for Dependently Typed Programs
Melocoton: A Program Logic for Verified Interoperability Between OCaml and C
The semantics of shared memory in Intel CPU/FPGA systems
Collapsing towers of interpreters
Lambda: the ultimate sublanguage (experience report)
A Quantum interpretation of separating conjunction for local reasoning of Quantum programs based on separation logic
The weak call-by-value λ-calculus is reasonable for both time and space
Verification of Neural Networks' Global Robustness
A Partial Order View of Message-Passing Communication Models
Optimal stateless model checking under the release-acquire semantics
How to prove your calculus is decidable: practical applications of second-order algebraic theories and computation
Reasonably programmable literal notation
On the complexity of checking transactional consistency
The Duality of λ-Abstraction
Restricting grammars with tree automata
Getting to the point: index sets and parallelism-preserving autodiff for pointful array programming
Grounding thin-air reads with event structures
What we eval in the shadows: a large-scale study of eval in R programs
HpC: A Calculus for Hybrid and Mobile Systems
A true positives theorem for a static race detector
The Simulation Semantics of Synthesisable Verilog
goSLP: globally optimized superword level parallelism framework
Persistent Owicki-Gries reasoning: a program logic for reasoning about persistent programs on Intel-x86
Functional Meaning for Parallel Streaming
Thrust: A Prophecy-Based Refinement Type System for Rust
Dependent type systems as macros
Admissible Types-to-PERs Relativization in Higher-Order Logic
A Deductive Verification Infrastructure for Probabilistic Programs
What is decidable about gradual types?
Program equivalence for assisted grading of functional programs
Build scripts with perfect dependencies
Bidirectional Object-Oriented Programming: Towards Programmatic and Direct Manipulation of Objects
A Universal, Sound, and Complete Forward Reasoning Technique for Machine-Verified Proofs of Linearizability
ECROs: building global scale systems from sequential code
Smoothness Analysis for Probabilistic Programs with Application to Optimised Variational Inference
Fractional resources in unbounded separation logic
Calculational Design of Hyperlogics by Abstract Interpretation
Gradual type theory
Learning semantic program embeddings with graph interval neural network
On algebraic abstractions for concurrent separation logics
A logical relation for monadic encapsulation of state: proving contextual equivalences in the presence of runST
Probabilistic Programming with Stochastic Probabilities
Formal metatheory of second-order abstract syntax
The Complexity of Testing Message-Passing Concurrency
Detecting locations in JavaScript programs affected by breaking library changes
FP²: Fully in-Place Functional Programming
Value-centric dynamic partial order reduction
JavaDL: automatically incrementalizing Java bug pattern detection
Synthesizing Efficient Memoization Algorithms
Linearity in higher-order recursion schemes
Par means parallel: multiplicative linear logic proofs as concurrent functional programs
Leto: verifying application-specific hardware fault tolerance with programmable execution models
Maximum Consensus Floating Point Solutions for Infeasible Low-Dimensional Linear Programs with Convex Hull as the Intermediate Representation
Equations reloaded: high-level dependently-typed functional programming and proving in Coq
Rhombus: A New Spin on Macros without All the Parentheses
CN: Verifying Systems C Code with Separation-Logic Refinement Types
Sound and robust solid modeling via exact real arithmetic and continuity
From high-level inference algorithms to efficient code
FlowCFL: generalized type-based reachability analysis: graph reduction and equivalence of CFL-based and type-based reachability
Answer Refinement Modification: Refinement Type System for Algebraic Effects and Handlers
Formal Foundations for Translational Separation Logic Verifiers
Abstraction-safe effect handlers via tunneling
Gradually structured data
Sound and Partially-Complete Static Analysis of Data-Races in GPU Programs
A bunch of sessions: a propositions-as-sessions interpretation of bunched implications in channel-based concurrency
Flo: A Semantic Foundation for Progressive Stream Processing
SparseAuto: An Auto-scheduler for Sparse Tensor Computations using Recursive Loop Nest Restructuring
Abstract Operational Methods for Call-by-Push-Value
Automatic differentiation in PCF
Foundational Integration Verification of a Cryptographic Server
GhostCell: separating permissions from data in Rust
A dependently typed calculus with pattern matching and erasure inference
Dynamic Robustness Verification against Weak Memory
Synthesizing configuration file specifications with association rule learning
Reliable Actors with Retry Orchestration
Towards Pen-and-Paper-Style Equational Reasoning in Interactive Theorem Provers by Equality Saturation
Abridging source code
Symbolic value-flow static analysis: deep, precise, complete modeling of Ethereum smart contracts
Data-centric dynamic partial order reduction
Automated testing of graphics shader compilers
Learning the boundary of inductive invariants
Inference of static semantics for incomplete C programs
Typing Records, Maps, and Structs
Contextual Typing
Learning user friendly type-error messages
Beyond Relooper: recursive translation of unstructured control flow to structured control flow (functional pearl)
Unifying analytic and statically-typed quasiquotes
Bidirectional evaluation with direct manipulation
AnyDSL: a partial evaluation framework for programming high-performance libraries
On-the-Fly Static Analysis via Dynamic Bidirected Dyck Reachability
Mechanizing Session-Types using a Structural View: Enforcing Linearity without Linearity
Modular Construction and Optimization of the UZP Sparse Format for SpMV on CPUs
Deep Learning Robustness Verification for Few-Pixel Attacks
Quantum relational Hoare logic
LOUD: Synthesizing Strongest and Weakest Specifications
SpEQ: Translation of Sparse Codes using Equivalences
Leaf: Modularity for Temporary Sharing in Separation Logic
Scaling Optimization over Uncertainty via Compilation
Learning Abstraction Selection for Bayesian Program Analysis
Teaching how to program using automated assessment and functional glossy games (experience report)
Transforming programs and tests in tandem for fault localization
Liquid information flow control
The Bounded Pathwidth of Control-Flow Graphs
Qunity: A Unified Language for Quantum and Classical Computing
Practical initialization race detection for JavaScript web applications
Alone together: compositional reasoning and inference for weak isolation
Verifying Quantum Circuits with Level-Synchronized Tree Automata
Multiverse Notebook: Shifting Data Scientists to Time Travelers
ChiSA: Static Analysis for Lightweight Chisel Verification
Deriving efficient program transformations from rewrite rules
Complete monitors for gradual types
Linear and Non-linear Relational Analyses for Quantum Program Optimization
Modeling and analyzing evaluation cost of CUDA kernels
Automatic diagnosis and correction of logical errors for functional programming assignments
Knowing when to ask: sound scheduling of name resolution in type checkers derived from declarative specifications
LXM: better splittable pseudorandom number generators (and almost as fast)
Persistent software transactional memory in Haskell
Numerical Fuzz: A Type System for Rounding Error Analysis
Gradual typing with union and intersection types
Interaction Equivalence
Binary Cryptographic Function Identification via Similarity Analysis with Path-Insensitive Emulation
Software model-checking as cyclic-proof search
Scenario-Based Proofs for Concurrent Objects
HardTaint: Production-Run Dynamic Taint Analysis via Selective Hardware Tracing
Local refinement typing
Modular Synthesis of Efficient Quantum Uncomputation
Mat2Stencil: A Modular Matrix-Based DSL for Explicit and Implicit Matrix-Free PDE Solvers on Structured Grid
Software multiplexing: share your libraries and statically link them too
Semiring optimizations: dynamic elision of expressions with identity and absorbing elements
QuickSub: Efficient Iso-Recursive Subtyping
A computational interpretation of compact closed categories: reversible programming with negative and fractional types
Foundations for natural proofs and quantifier instantiation
Validating IoT Devices with Rate-Based Session Types
Every data structure deserves lock-free memory reclamation
Automatic repair of regular expressions
Weighted programming: a programming paradigm for specifying mathematical models
Quotient Polymorphism
Synthesizing code quality rules from examples
PλωNK: functional probabilistic NetKAT
Getting into the Flow: Towards Better Type Error Messages for Constraint-Based Type Inference
Safe, modular packet pipeline programming
Dijkstra monads for all
Statically Resolvable Ambiguity
Rewrite rule inference using equality saturation
Automatic amortized resource analysis with the Quantum physicist's method
Automated Detection of Under-Constrained Circuits in Zero-Knowledge Proofs
SQLizer: query synthesis from natural language
Reachability in Continuous Pushdown VASS
Modular, compositional, and executable formal semantics for LLVM IR
Validating SMT Solvers for Correctness and Performance via Grammar-Based Enumeration
Decidability of conversion for type theory in type theory
Semantics of Integrating and Differentiating Singularities
Trillium: Higher-Order Concurrent and Distributed Separation Logic for Intensional Refinement
Algebro-geometric Algorithms for Template-Based Synthesis of Polynomial Programs
Model-assisted machine-code synthesis
Spy game: verifying a local generic solver in Iris
The road not taken: exploring alias analysis based optimizations missed by the compiler
Polymorphic symmetric multiple dispatch with variance
Parameterized Verification of Quantum Circuits
Up-to techniques using sized types
VMSL: A Separation Logic for Mechanised Robust Safety of Virtual Machines Communicating above FF-A
Exploiting Undefined Behavior in C/C++ Programs for Optimization: A Study on the Performance Impact
Parsing randomness
A Modal Type Theory of Expected Cost in Higher-Order Probabilistic Programs
Scalable and Accurate Application-Level Crash-Consistency Testing via Representative Testing
Type-guided worst-case input generation
Parsing with zippers (functional pearl)
First-Class Verification Dialects for MLIR
Data-driven abductive inference of library specifications
A Pure Demand Operational Semantics with Applications to Program Analysis
A fault-tolerant programming model for distributed interactive applications
Neural architecture search using property guided synthesis
Affine Monads and Lazy Structures for Bayesian Programming
Feature-Sensitive Coverage for Conformance Testing of Programming Language Implementations
Handling bidirectional control flow
Practical generic programming over a universe of native datatypes
'do' unchained: embracing local imperativity in a purely functional language (functional pearl)
A modular cost analysis for probabilistic programs
This is the moment for probabilistic loops
Maximal Simplification of Polyhedral Reductions
Verified Extraction from Coq to OCaml
Weakening WebAssembly
Synthesizing Specifications
BDA: practical dependence analysis for binary executables by unbiased whole-program path sampling and per-path abstract interpretation
Combining Functional and Automata Synthesis to Discover Causal Reactive Programs
Incremental relational lenses
Mostly Automated Verification of Liveness Properties for Distributed Protocols with Ranking Functions
Witnessability of Undecidable Problems
Certified Compilers à la Carte
Deconstructing the Calculus of Relations with Tape Diagrams
Intrinsic Verification of Parsers and Formal Grammar Theory in Dependent Lambek Calculus
Type-Checking CRDT Convergence
A Dependent Nominal Physical Type System for Static Analysis of Memory in Low Level Code
Mtac2: typed tactics for backward reasoning in Coq
Composing and decomposing op-based CRDTs with semidirect products
Undecidability of d <: and its decidable fragments
Safe replication through bounded concurrency verification
Proto-Quipper with Dynamic Lifting
Effects and Coeffects in Call-by-Push-Value
RE#: High Performance Derivative-Based Regex Matching with Intersection, Complement, and Restricted Lookarounds
The Functional, the Imperative, and the Sudoku: Getting Good, Bad, and Ugly to Get Along (Functional Pearl)
Gradual parametricity, revisited
QVM: Quantum Gate Virtualization Machine
Stacked borrows: an aliasing model for Rust
Reducing Static Analysis Unsoundness with Approximate Interpretation
Refinement Composition Logic
First-class names for effect handlers
Formulog: Datalog for SMT-based static analysis
Plausible sealing for gradual parametricity
Learning-based controlled concurrency testing
Synchronous Programming with Refinement Types
The fire triangle: how to mix substitution, dependent elimination, and effects
Testing differential privacy with dual interpreters
Two sides of the same coin: session types and game semantics: a synchronous side and an asynchronous side
Consistency-preserving propagation for SMT solving of concurrent program verification
Secure serverless computing using dynamic information flow control
Total Type Error Localization and Recovery with Holes
Discrete Adversarial Attack to Models of Code
Generating Compilers for Qubit Mapping and Routing
Generic deriving of generic traversals
Network Change Validation with Relational NetKAT
Reasoning about the garden of forking paths
How do programmers use unsafe rust?