yusuke1997/dblp-id-title huggingface dataset:
A Simple and General Method for Integrating Abstract Interpretation in SICStus
Property-Based Testing via Proof Reconstruction
Goal-directed execution of answer set programs
Automatic verification of cryptographic protocols: a logic programming approach
Full integration of subtyping and if-expression
Pattern by example: type-driven visual programming of XML queries
Declarative Game Programming: Distilled Tutorial
A Logic for Formalizing Properties of LF Specifications
Generative programming for embedded systems
'Galculator': functional prototype of a Galois-connection based proof assistant
An algebraic view of space/belief and extrusion/utterance for concurrency/epistemic logic
Explicit substitutions in the reduction of lambda terms
A demand-driven narrowing calculus with overlapping definitional trees
Realisability and Complementability of Multiparty Session Types
Enhanced sharing analysis techniques: a comprehensive evaluation
Type-based nondeterminism checking in functional logic programs
Higher-Order unification for free!: Reusing the meta-language unification for the object language
Mechanized metatheory model-checking
Relational semantics for effect-based program transformations with dynamic allocation
Experimental Evaluation of a State-Of-The-Art Grounder
Proceedings of the 27th International Symposium on Principles and Practice of Declarative Programming, PPDP 2025, Rende, Italy, September 10-11, 2025
Reflecting Stacked Continuations in a Fine-Grained Direct-Style Reduction Theory
A Superposition-Based Calculus for Diagrammatic Reasoning
Machine fusion: merging merges, more or less
Parametricity and Proving Free Theorems for Functional-Logic Languages
Lazier Imperative Programming
A historic functional and object-oriented calculus
Rank 2 intersection types for modules
Maintaining distributed logic programs incrementally
On the Verification of Finite Failure
Bijective Collection Encodings and Boolean Operations with Hereditarily Binary Natural Numbers
Formal validation of pattern matching code
A Type Theoretic Specification of Partial Evaluation
Mechanized Type Soundness for Substructural Types using Iris
Proceedings of the 4th international ACM SIGPLAN conference on Principles and practice of declarative programming, October 6-8, 2002, Pittsburgh, PA, USA (Affiliated with PLI 2002)
A parameterized graph transformation calculus for finite graphs with monadic branches
Nominal rewriting systems
Exponential Elimination for Bicartesian Closed Categorical Combinators
A rewriting framework for the composition of access control policies
Intuitionistic Metric Temporal Logic
Reasoning about higher-order relational specifications
Declarative Program Transformation: A Deforestation Case-Study
Model-checking higher-order functions
Two-Phase Dynamic Analysis of Message-Passing Go Programs Based on Vector Clocks
International Symposium on Principles and Practice of Declarative Programming, PPDP 2023, Lisboa, Portugal, October 22-23, 2023
Confluence in Non-Left-Linear Untyped Higher-Order Rewrite Theories
Transparent function types: clearing up opacity
Practical type inference based on success typings
New completeness results for lazy conditional narrowing
Type-directed Program Transformation for Constant-Time Enforcement
Polymorphic algebraic data type reconstruction
Proving Operational Termination of Declarative Programs in General Logics
Observing intermediate structures in a parallel lazy functional language
A Predicate Construct for Declarative Programming in Imperative Languages
A Derived Reasonable Abstract Machine for Strong Call by Value
Program transformation by templates based on term rewriting
CLP projection for constraint handling rules
Proof construction and non-commutativity: a cluster calculus
A simple view of multiparty session types
Proceedings of the 2nd international ACM SIGPLAN conference on on Principles and practice of declarative programming, Montreal, Canada, September 20-23, 2000
Semantic analysis of pointer aliasing, allocation and disposal in Hoare logic351292
A polynomial time λ-calculus with multithreading and side effects
Intersection types for a λ-calculus with global store
Contextual Equivalence in a Probabilistic Call-by-Need Lambda-Calculus
Declarative Ajax and client side evaluation of workflows using iTasks
Principles and Practice of Declarative Programming, International Conference PPDP'99, Paris, France, September 29 - October 1, 1999, Proceedings
Defunctionalisation as modular closure conversion
JIAD: a tool to infer design patterns in refactoring
A modal type system for multi-level generating extensions with persistent code
A high performance Erlang system
A declarative approach to robust weighted Max-SAT
A devil's advocate against termination of direct recursion
Self-tuning resource aware specialisation for prolog
Conditional narrowing without conditions
Declarative interpretations of session-based concurrency
Free Objects in Constraint-logic Object-oriented Programming
Function definitions for compound values in object-oriented languages
Actors may synchronize, safely!
Characterizing strong normalization in a language with control operators
Distributed, Coordination-Free Programming: 10 Years of Progress Since Lasp
Improvements in a functional core language with call-by-need operational semantics
Calculating Distributions
Sharing Equality is Linear
Abstract interpretation for constraint handling rules
Nominal Matching Logic
Monadic concurrent linear logic programming
Run Time Type Information in Mercury
Proofs you can believe in: proving equivalences between Prolog semantics in Coq
Proofs in continuation-passing style: normalization of Gödel's System T extended with sums and delimited control operators: Distilled Tutorial
Canonical proof-objects for coinductive programming: infinets with infinitely many cuts
Papaya: Global Typestate Analysis of Aliased Objects
Towards execution time estimation in abstract machine-based languages
Moulinog: A Generator of Random Student Assignments Written in Prolog
A semantics for tracing declarative multi-paradigm programs
Unification via s e -style of explicit substitution
BiFluX: A Bidirectional Functional Update Language for XML
Exception Handling and Classical Logic
Session Types Revisited: A Decade Later
Abstract machines and small-step semantics: a winning ticket for proof automation?
Functional semantics of parsing actions, and left recursion elimination as continuation passing
Combining algorithmic debugging and program slicing
Context-based proofs of termination for typed delimited-control operators
Generativity and dynamic opacity for abstract types
Automated protocol verification in linear logic
A resolution strategy for verifying cryptographic protocols with CBC encryption and blind signatures
Combining an improvement to PARMA trailing with trailing analysis
A model for comparing the space usage of lazy evaluators
Detecting decidable classes of finitely ground logic programs with function symbols
A declarative encoding of telecommunications feature subscription in SAT
Widening Sharing
Active integrity constraints
HSS: a compiler for cascading style sheets
The RPC calculus
The logical essence of call-by-name CPS translations
Characterization of strong normalizability for a sequent lambda calculus with co-control
Folding Narrowing for the Analysis of Mutual Exclusion Protocols
ASP-based Multi-shot Reasoning via DLV2 with Incremental Grounding
On Formalised Proofs of Termination of Recursive Functions
Towards a framework for algorithm recognition in binary code
Design and Implementation of a Multithreaded Virtual Machine for Executing Linear Logic Programs
Continuations, Processes, and Sharing
Security analysis of network protocols: logical and computational methods
A Computational Understanding of Classical (Co)Recursion
Modular resetting of synchronous data-flow programs
A compositional semantics for CHR
Towards a formal notion of trust
Compilation of extended recursion in call-by-value functional languages
Under Control: Compositionally Correct Closure Conversion with Mutable State
An Implementation of Narrowing Strategies
A verification technique for deterministic parallel programs
Path-sensitive region analysis for mercury programs
Higher-order logic programming: an expressive language for representing qualitative preferences
Local reasoning about storable locks
A Calculus for Interaction Nets
Inferring precise polymorphic type dependencies in logic programs
Symbolic Execution for JavaScript
PPDP '20: 22nd International Symposium on Principles and Practice of Declarative Programming, Bologna, Italy, 9-10 September, 2020
Timed constraint programming: a declarative approach to usage control
Selective unification in constraint logic programming
Normalization by Evaluation for Call-By-Push-Value and Polarized Lambda Calculus
Strongly-Typed Multi-View Stack-Based Computations
Proceedings of the 18th International Symposium on Principles and Practice of Declarative Programming, Edinburgh, United Kingdom, September 5-7, 2016
Multicompatibility for Multiparty-Session Composition
Optimising Bytecode Emulation for Prolog
Detecting concurrency bugs in higher-order programs through abstract interpretation
A logic programming approach to the verification of functional-logic programs
Understanding Lua's Garbage Collection: Towards a Formalized Static Analyzer
Parallel execution of multi-set constraint rewrite rules
On theorem proving for program checking: historical perspective and recent developments
Comparing tag scheme variations using an abstract machine generator
Proceedings of the 20th International Symposium on Principles and Practice of Declarative Programming, PPDP 2018, Frankfurt am Main, Germany, September 03-05, 2018
Poly-controlled partial evaluation
A type system equivalent to static single assignment
Invited talk: program generators and the tools to make them
On Intersection Types and Probabilistic Lambda Calculi
A Decade of Dependent Session Types
Two notions of sub-behaviour for session-based client/server systems
Instruction Merging and Specialization in the SICStus Prolog Virtual Machine
Parallel Execution Models for Constraint Programming over Finite Domains
Typed Equivalence of Labeled Effect Handlers and Labeled Delimited Control Operators
Type-oriented construction of web user interfaces
On Combining Backward and Forward Chaining in Constraint Logic Programming
Heuristics Entwined with Handlers Combined: From Functional Specification to Logic Programming Implementation
Incremental checking of well-founded recursive specifications modulo axioms
Automatic Reordering for Dataflow Safety of Datalog
Towards Effective ASP-based Stream Reasoning: Facilitate the Reasoning over Patterns of Events
Efficient fixpoint computation in linear tabling
Reasoning with hypothetical judgments and open terms in hybrid
Unifying the Knuth-Bendix, recursive path and polynomial orders
A generic operator over discrete time intervals
A Denotational Semantics for Timed Linda
Logical and Meta-Logical Frameworks (Abstract)
Programming Open Distributed Systems in Maude
Proceedings of the 13th International ACM SIGPLAN Conference on Principles and Practice of Declarative Programming, July 20-22, 2011, Odense, Denmark
Effect-dependent transformations for concurrent programs
Shallowly Embedded Functions
Transformation of Combinatorial Optimization Problems Written in Extended SQL into Constraint Problems
Transforming the .NET intermediate language using path logic programming
Proceedings of the 7th International ACM SIGPLAN Conference on Principles and Practice of Declarative Programming, July 11-13 2005, Lisbon, Portugal
Sequential and Parallel Improvements in a Concurrent Functional Programming Language
Generic Encodings of Constructor Rewriting Systems
User Guided Abductive Proof Generation for Answer Set Programming Queries
An Isabelle/HOL-based model of stratego-like traversal strategies
CheckINN: Wide Range Neural Network Verification in Imandra
Nested proof search as reduction in the Lambda-calculus
A simple rewrite notion for call-time choice semantics
Type-Driven Verification of Non-functional Properties
A Parameterized Unfold/Fold Transformation Framework for Definite Logic Programs
Combinatorics of Explicit Substitutions
Two notions of sub-behaviour for session-based client/server systems: 10 Years Later
Closure Conversion, Flat Environments, and the Complexity of Abstract Machines
Localizing and Explaining Reasons for Non-terminating Logic Programs with Failure-Slices
Should UML Be Used for Declarative Programming?
ReactiveML: a reactive extension to ML
Description and evaluation of a generic design to integrate CLP and tabled execution
Automatic refactoring of Erlang programs
Declarative distributed advertisement system for iDTV: an industrial experience
Pattern Matching and Fixed Points: Resource Types and Strong Call-By-Need: Extended Abstract
Extending constraint logic programming with open functions
Task-oriented programming in a pure functional language
Graph-transformation verification using monadic second-order logic
A core calculus for provenance inspection
An operational foundation for the tactic language of Coq
A meta-programming approach to realizing dependently typed logic programming
From dynamic binding to state via modal possibility
Proceedings of the 21st International Symposium on Principles and Practice of Programming Languages, PPDP 2019, Porto, Portugal, October 7-9, 2019
Rewrite-based verification of XML updates
Constraint Programming in OPL
Proceedings of the 16th International Symposium on Principles and Practice of Declarative Programming, Kent, Canterbury, United Kingdom, September 8-10, 2014
Constraint-set satisfiability for overloading
When Do Bounds and Domain Propagation Lead to the Same Search Space?
stableKanren: Integrating Stable Model Semantics with miniKanren
A synthetic operational account of call-by-need evaluation
A new calculus of contexts
Minimal Session Types for the π-calculus
Formalization and abstract implementation of rewriting with nested rules
Efficient memory management in a merged heap/stack prolog machine
Random testing of purely functional abstract datatypes: guidelines for dealing with operation invariance
Equational axiomatization of call-by-name delimited control
Functional derivation of a virtual machine for delimited continuations
Demand-driven incremental object queries
Formalizing Weighted Pushdown Systems in Isabelle/HOL
Non-dependent Types for Standard ML Modules
Development Reuse and the Logic Program Derivation of Two String-Matching Algorithms
Compiling Constraint Handling Rules into Prolog with Attributed Variables
Isolation-only transactions by typing and versioning
Proceedings of the 9th International ACM SIGPLAN Conference on Principles and Practice of Declarative Programming, July 14-16, 2007, Wroclaw, Poland
Proceedings of the 3rd international ACM SIGPLAN conference on Principles and practice of declarative programming, September 5-7, 2001, Florence, Italy
Causality Error Tracing in HipHop.js
System Description: An Infrastructure for Combining Domain Knowledge with Automated Theorem Provers
Ideal Models for Pointwise Relational and State-Free Imperative Programming
Nominal rewriting with name generation: abstraction vs. locality
Classifying integrity checking methods with regard to inconsistency tolerance
Bidirectional Elaboration of Dependently Typed Programs
Data-Dependent Confidentiality in DCR Graphs
Modular termination of context-sensitive rewriting
Computation in focused intuitionistic logic
Induction for positive almost sure termination
Argument Filtering Transformation
Eventual linear ranking functions
Justifying proofs using memo tables
Programming by examples: applications, algorithms, and ambiguity resolution
Foundations of Session Types: 10 Years Later
Dependency Pairs for Expected Innermost Runtime Complexity and Strong Almost-Sure Termination of Probabilistic Term Rewriting
Efficient trust management policy analysis from rules
Grammar-based Pattern Matching and Type Checking for Difference Data Structures
Call pattern analysis for functional logic programs
Semantics-preserving translations between linear concurrent constraint programming and constraint handling rules
Continuations for parallel logic programming
Order-sorted dependency pairs
A functional correspondence between evaluators and abstract machines
Unfolding in CHR
Modeling datalog fact assertion and retraction in linear logic
Intrinsically-Typed Mechanized Semantics for Session Types
Typed polyadic pi-calculus in bigraphs
Semantically linear programming languages
Language-Based Security for Low-Level MPC
Are needed redexes really needed?
Strand spaces with choice via a process algebra semantics
Relating nominal and higher-order abstract syntax specifications
De Bruijn's Syntax and Reductional Equivalence of Lambda-Terms
On the Almost-Sure Termination of Binary Sessions
Typed and unambiguous pattern matching on strings using regular expressions
Theories of Homomorphic Encryption, Unification, and the Finite Variant Property
Shrink fast correctly!
Improving Refutational Completeness of Relational Search via Divergence Test
Non-monotonic Spatial Reasoning for Safety Analysis in Construction
A Calculus of Delayed Reductions
Providing declarative semantics for HH extended constraint logic programs
Generic record combinators with static type checking
A modular semantics for higher-order declarative programming with constraints
Rewriting term-graphs with priority
Relational semantics for effect-based program transformations: higher-order store
Efficient computation of program equivalence for confluent concurrent constraint programming
Incremental and demand-driven points-to analysis using logic programming
Certified Derivation of Small-Step From Big-Step Skeletal Semantics
Modular Termination Proofs for Prolog with Tabling
Proceedings of the 11th International ACM SIGPLAN Conference on Principles and Practice of Declarative Programming, September 7-9, 2009, Coimbra, Portugal
Set functions for functional logic programming
Constraint-based mode analysis of mercury
A characterization of symmetric semantics by domain complementation
Decision Procedures for Proving Inductive Theorems without Induction
A Reflection on Task-Oriented Programming
A framework for abstract interpretation of timed concurrent constraint programs
Spacetime Programming: A Synchronous Language for Composable Search Strategies
A precise type analysis of logic programs
Cooperation of constraint domains in the TOY system
Smart Contracts as Authorized Production Rules
Type inference with expansion variables and intersection types in system E and an exact correspondence with beta-reduction
Layered fixed point logic
Declarative GUIs: Simple, Consistent, and Verified
Crumbling Abstract Machines
Hierarchical Higher-Order Port-Graphs: A Rewriting-Based Modelling Language
Language-integrated provenance
A Direct Approach to Control-Flow Sensitive Region-Based Memory Management
Refining weakly outermost-needed rewriting and narrowing
Proof-carrying code: design, implementation and applications (abstract)
Static Performance Guarantees for Programs with Runtime Checks
Permissive-nominal logic
Interactive, scalable, declarative program analysis: from prototype to implementation
Type inference in intuitionistic linear logic
Open data types and open functions
Using the heap to eliminate stack accesses
On the rewriting and efficient computation of bound disjunctive datalog queries
Counting Qubits and Gates: Resource Analysis in Quantum Programming Languages
On the Preciseness of Subtyping in Session Types: 10 Years Later
Verification by abstract interpretation, soundness and abstract induction
Challenges in compiling Coq
The Computational Structure of Programs and the Universe
Proceedings of the 8th International ACM SIGPLAN Conference on Principles and Practice of Declarative Programming, July 10-12, 2006, Venice, Italy
Finding Candidate Keys and 3NF via Strategic Port Graph Rewriting
Linear logic programming with an ordered context
Minimally strict polymorphic functions
An Adequate While-Language for Hybrid Computation
Model Checking and Synthesis for Strategic Timed CTL using Strategies in Rewriting Logic
Java bytecode as a typed term calculus
Shape analysis in a functional language by using regular languages
Testing of concurrent and imperative software using CLP
Computing constructor forms with non terminating rewrite programs
Proceedings of the 10th International ACM SIGPLAN Conference on Principles and Practice of Declarative Programming, July 15-17, 2008, Valencia, Spain
Accessing biological data as Prolog facts
Reachability Analysis in Micro-Stipula
Formally deriving an STG machine
An interactive type checker for dependent types with general recursion (System Description)
On the Automated Verification of BGP Convergence
Precise complexity analysis for efficient datalog queries
Search by constraint propagation
Model checking object petri nets in prolog
Abstraction carrying code and resource-awareness
Proceedings of the 19th International Symposium on Principles and Practice of Declarative Programming, Namur, Belgium, October 09 - 11, 2017
Static analysis of cloud elasticity
Formal Verification of Executable Matrix Inversion via Adjoint Matrix and Gaussian Elimination
Putting declarative programming into the web: translating curry to javascript
Moderately Complex Paxos Made Simple: High-Level Executable Specification of Distributed Algorithms
Certified Compilation of Financial Contracts
Unification of program expressions with recursive bindings
Scheme fair threads
A framework for easing the development of applications embedding answer set programming
Dynamic variable elimination during propagation solving
Structure-Preserving Compilation: Efficient Integration of Functional DSLs into Legacy Systems
Protocol analysis in Maude-NPA using unification modulo homomorphic encryption
Issues in ethical data management
Degrading Lists
Finite type extensions in constraint programming
A Virtual Machine for a Process Calculus
From monoids to near-semirings: the essence of MonadPlus and alternative
Cycle Therapy: A Prescription for Fold and Unfold on Regular Trees
Functional Reactive Programming, restated
Theory learning with symmetry breaking
Feasible reactivity in a synchronous Pi-calculus
Nondeterministic Manifest Contracts
A dynamically customizable process-centered evaluation model
C--: A Portable Assembly Language that Supports Garbage Collection
A logical correspondence between natural semantics and abstract machines
On the Preciseness of Subtyping in Session Types
Debugging of wrong and missing answers for datalog programs with constraint handling rules
Declarative programming for verification: lessons and outlook
Condate: a proto-language at the confluence between checking and compiling
A Mechanized Semantic Metalanguage for High Level Synthesis
Time refinement in a functional synchronous language
System Presentation -- CARIBOO: An induction based proof tool for termination with strategies
Just enough tabling
A Typed Lambda Calculus with Gradual Intersection Types
Termination in Concurrency, Revisited
Model Checking (with) Declarative Programs
Towards automatic synthesis of software verification tools
A larger decidable semiunification problem
Constraint handling rules: the story so far
Detecting defects in Erlang programs using static analysis
Concurrent constraint programming: towards probabilistic abstract interpretation
A compositional logic for polymorphic higher-order functions
A framework for the recursive definition of data structures
Continuous Verification of Machine Learning: a Declarative Programming Approach
BASS: boxed ambients with safe sessions
Inverting abstract unification for set-sharing
Optimization with mode-directed preferences
Similarity-based reasoning in qualified logic programming
Prolog programming with a map-reduce parallel construct
Security policy in a declarative style
Secure calling contexts for stack inspection
iRho: an imperative rewriting calculus
Proceedings of the 17th International Symposium on Principles and Practice of Declarative Programming, Siena, Italy, July 14-16, 2015
Recovering Commutation of Logically Constrained Rewriting and Equivalence Transformations