yusuke1997/dblp-id-title huggingface dataset:
Abstract Semantics for K Module Composition
Grid Infrastructure Monitoring Service Framework Jiro/JMX Based Implementation
Relational Concurrent Refinement: Automata
Contextual Labelled Semantics for Higher-order Process Calculi
Rewriting-Based Access Control Policies
A Categorical and Graphical Treatment of Closure Conversion
An Epistemic Logic of Extensive Games
A Non-Topological View of Dcpos as Convergence Spaces (Extended Abstract)
Local Module Checking for CTL Specifications
Induction on Concurrent Terms
General Refinement, Part Two: Flexible Refinement
The Traveling Salesman Problem in Circulant Weighted Graphs With Two Stripes
Constraint-aware Schema Transformation
Model Checking of Component Protocol Conformance - Optimizations by Reducing False Negatives
Proof General meets IsaWin: Combining Text-Based And Graphical User Interfaces
Formalising General Correctness
Monitoring Java Programs with Java PathExplorer
Some Remarks Concerning the Algorithmic Analysis of Gene Regulatory Networks
On the Expressivity of Minimal Generic Quantification
Program and Algorithm Visualization in Engineering and Physics
Phase semantics for light linear logic
A Coalgebraic View of Infinite Trees and Iteration
On Combining Probability and Nondeterminism
Feature Interaction Aware Test Case Generation for Embedded Control Systems
The Side Transformation Pattern: Making Transforms Modular and Re-usable
Unifying concurrent and relational refinement
Terminating Tableaux for Dynamic Epistemic Logics
Coordinating Aspects and Objects
Grab and Go Systems: a CPO approach to concurrent web and grid-based computation
A Certifying Code Generation Phase
Fixed points in digital topology (via Helly posets)
Fluid Performability Analysis of Nested Automata Models
BAS: A Case Study for Modeling and Verification in Trustable Model Driven Development
A Relative Timed Semantics for BPMN
L(A) = L(B)?
Negative Modalities, Consistency and Determinedness
Countable Lawvere Theories and Computational Effects
Implementing CCS in Maude 2
Synthesis of Mealy Machines Using Derivatives
Counting Sparse k-edge-connected Hypergraphs with Given Number of Vertices and Edges
Intersection Typed lambda-calculus
Time Bounds for General Function Pointers
OOPS: An S5 n Prover for Educational Settings
Modular Games for Coalgebraic Fixed Point Logics
An Intermediate Language for the Simulation of Biological Systems
A Case Study in Matching Test and Proof Coverage
Temporal Logics of Knowledge and their Applications in Security
Quantifier Elimination and Provers Integration
A Simple Nominal Type Theory
An Abstract Concept of Optimal Implementation
Executable Grammars in Newspeak
A True-Concurrent Interpretation of Behavioural Scenarios
Recent Advances in Real-Time Maude
Towards a Directed Homotopy Type Theory
Preventing Timing Leaks Through Transactional Branching Instructions
Incremental Verification for On-the-Fly Controller Synthesis
A Deterministic Logical Semantics for Esterel
Demandness in Rewriting and Narrowing
Compositionality of Statically Scheduled IP
Performance Evaluation of Security Protocols Specified in LySa
Probabilistic confinement in a declarative framework
Using Term-Graph Rewriting Models to Analyse Relative Space Efficiency
From Concurrency to Algebraic Topology
Towards a Quantum Calculus: (Work in Progress, Extended Abstract)
An Algebraic Foundation for Graph-based Diagrams in Computing
A Probabilistic Polynomial-time Calculus For Analysis of Cryptographic Protocols (Preliminary Report)
Specification and Verification of Agent Interaction using Social Integrity Constraints
SOL: A Verifiable Synchronous Language for Reactive Systems
An MDA approach to Access Control Specifications Using MOF and UML Profiles
Fuzzy Logic Programming for Implementing a Flexible XPath-based Query Language
UPGRADE: A Framework for Building Graph-Based Interactive Tools
Automatic visualization of recursion trees: a case study on generic programming
Towards Object-Oriented Klaim
Proving Soundness of Extensional Normal-Form Bisimilarities
Editor's Note
Game-Based Probabilistic Predicate Abstraction in PRISM
On Computable Metrization
Maude MSOS Tool
A Logical Process Calculus
Stability of Reeb Graphs of Closed Curves
Formal Contexts for Algebraic Domains
Runtime Verification of Timed LTL using Disjunctive Normalized Equation Systems
Effectuses from Monads
Verification of Model Transformations: A Survey of the State-of-the-Art
Semimodule Enrichment
Finitary Higher Inductive Types in the Groupoid Model
Pattern-Matching Compiler
Paraconsistent Arithmetic with a Local Consistency Operator and Global Selfreference
The Power of Closed Reduction Strategies
A Translation from Object-Based Hypergraph Grammars into pi-Calculus
A Modular Static Analysis Approach to Affine Loop Invariants Detection
A Category-Theoretic Approach to Social Network Analysis
Regular-Language Semantics for a Call-by-Value Programming Language
A satisfiability-based approach to abstraction refinement in model checking
Relationally Staged Computations in Calculi of Mobile Processes
Unitary Theories, Unitary Categories
Two Problems on Interval Counting
Encoding Transition Systems in Sequent Calculus
Trust Evolution Policies for Security in Collaborative Ad Hoc Applications
Modal Logic Characterization of Markovian Testing and Trace Equivalences
Completion after Program Inversion of Injective Functions
Towards the Composition of Specifications in Event-B
Bisimulations Generated from Corecursive Equations
Timing in the Cospan-Span Model
Debugging Haskell by Observing Intermediate Data Structures
Selective Memoization with Box Types
Validating Component Integration with C-TILCO: A Case Study
Operator Algebras and the Operational Semantics of Probabilistic Languages
Automatic Verification of Counter Systems With Ranking Function
Basic Ideas for Transformations of Specification Architectures
Compositional Asymmetric Cooperations for Process Algebras with Probabilities, Priorities, and Time
Algebras, Graphs and Thetas
True Concurrency = Interleaving Concurrency + Weak Conflict
Proof nets Construction and Automated Deduction in Non-Commutative Linear Logic
Formal ReSpecT
Semantics of Visual Models in a Rule-based Setting
JRebel Tool Demo
Polytypic Programming in Maude
Discounting in Time
A Logic Based Asynchronous Multi-Agent System
Automated validation of distributed software using the IF environment
Domain theoretic models of topological spaces
Towards a Rigorous Approach to UML-Based Development
Inconsistency Management and View Updates
Analog Circuit Verification: a State of an Art
Covering Steps Graphs of Time Petri Nets
Constructive Description Logics Hybrid-Style
Decidability of Reachability for Polymorphic Systems with Arrays: A Complete Classification
Refining and Compressing Abstract Model Checking
An Applicative Control-Flow Graph Based on Huet's Zipper
Paraconsistent Modal Logics
A Prolog Framework for the Rapid Prototyping of Language Processors with Attribute Grammars
Dynamic Subtask Dispersion Reduction in Heterogeneous Parallel Queueing Systems
Connector Colouring I: Synchronisation and Context Dependency
An Implementation Model of the Typed Lambda-Calculus based on Linear Chemical Abstract Machine
A Meta Linear Logical Framework
Jalapa: Securing Java with Local Policies: Tool Demonstration
Modularity in denotational semantics
A Domain-Specific Language for Generating Dataflow Analyzers
Correcting Gene Trees by Leaf Insertions: Complexity and Approximation
Z-abstract Basis
BMC via on-the-fly determinization
Isabelle Theories for Machine Words
Symmetry and Composition in Probabilistic Theories
Polymorphic type checking for the ramified theory of types of Principia Mathematica
Algebras, Coalgebras, Monads and Comonads
On the Verification of Cryptographic Protocols - A Tale of Two Committees
Efficient Algorithms for the Maximum Subarray Problem by Distance Matrix Multiplication
VeriAgent: an Approach to Integrating UML and Formal Verification Tools
Language Design Issues for Agents based on Linear Logic (Extended Abstract)
A general theorem on the total correctness of programs in a category
Encoding First Order Proofs in SMT
Building continuous webbed models for system F
Model Checking Downward Simulations
Trace-based Derivation of a Lock-Free Queue Algorithm
A Distributed Algorithm for Strong Bisimulation Reduction of State Spaces
Simulation Reduction as Constraint
Hybridizing a Logical Framework
A Verification Approach for GALS Integration of Synchronous Components
Sharing Implementations of Graph Rewriting Systems
Meta-programming With Built-in Type Equality
Local Dcpos, Local Cpos and Local Completions
Maximal Introspection of Agents
Query Answering with DBoxes is Hard
Properties of Set Functors
Typing the Behavior of Objects and Component Using Session Types
Markovian Testing and Trace Equivalences Exactly Lump More Than Markovian Bisimilarity
Comparative Analysis of Performance and Quality of Prediction Between ESS and ESS-IM
Norm-weightable Riesz spaces and the dual complexity space
Strongly Compact Closed Semantics
Using CafeOBJ to Implement a Reduction Strategy in the Context of Hardware/Software Partitioning
From Reversible Programs to Univalent Universes and Back
A Core Calculus of Classes and Objects
Two-sorted Point-Interval Temporal Logics
Types for Modules
Speculative Computation and Action Execution in Multi-Agent Systems
Coalgebraic Minimization of Automata by Initiality and Finality
Parametrized quotation and self-reference
Term rewriting with operator evaluation strategies
Computable Riesz Representation for the Dual of C
Survivability Evaluation of Gas, Water and Electricity Infrastructures
Modular Rewriting Semantics in Practice
Testing and Monitoring Model-based Generated Program
Reactive Concurrent Programming Revisited
Implementation of an Optimal Strategy for Algorithmic Debugging
Aspect-orientation For Revitalising Legacy Business Software
Verification of Scenario-based Specifications using Templates
Set-based Nondeterministic Declarative Programming in Singleton
SAXO-RT: Interpreting Esterel Semantic on a Sequential Execution Structure
Concurrent Nets: A Study of Prefixing in Process Calculi
An Operational Semantics for Shared Messaging Communication
Probabilistic Analysis of Wireless Systems Using Theorem Proving
Nominal Lambda Calculus: An Internal Language for FM-Cartesian Closed Categories
On propositions-as-types in realizability models
Prototyping and Programming with Relations
The Tabular Method for Relational Documentation
Zero-safe net models for transactions in Linda
Transformation of a PID Controller for Numerical Accuracy
A Static Semantics for Alloy and its Impact in Refactorings
Operational Properties of Lily, a Polymorphic Linear Lambda Calculus with Recursion
Automatic Detection of Copies Divergence in Collaborative Editing Systems
An Abstract Module Concept for Graph Transformation Systems
Logical Construction of Final Coalgebras
Experiences on Using TRAKLA2 to Teach Spatial Data Algorithms
Network-Conscious π-calculus - A Model of Pastry
Simulations in Coalgebra
Worst Case Reaction Time Analysis of Concurrent Reactive Programs
A Note on Set Agreement with Omission Failures
Bayesian Authentication: Quantifying Security of the Hancke-Kuhn Protocol
Stupid is as Stupid Does: Taking the Square Root of the Square of a Floating-Point Number
Circuits and Circulant Minors
Using kinds to type partially-polymorphic methods
Action Planning for Directed Model Checking of Petri Nets
Symbolic Model Checking for Channel-based Component Connectors
s 2 -Quasialgebraic Posets
Mixing Up Nondeterminism and Probability: a preliminary report
The Identifying Code, the Locating-dominating, the Open Locating-dominating and the Locating Total-dominating Problems Under Some Graph Operations
Fixed points and reflexive domain equations in categories of continuity spaces
Modeling Petri Nets by Local Action Systems
SMT-AI: an Abstract Interpreter as Oracle for k-induction
Intuitionism - Counting its Blessings
Object-Oriented Connector-Component Architectures
Network Conscious π-calculus: A Concurrent Semantics
Improving Termination of MDG-Based Abstract State Enumeration via Term Schematization
Bireflectivity
Parallel Graph Transformation for Model Simulation applied to Timed Transition Petri Nets
Formalizing Java-MaC
The rho-spi Calculus at Work: Authentication Case Studies
Adhesive DPO Parallelism for Monic Matches
Scoped metatheorems
Using Abstract Interpretation for the Safe Verification of Security Protocols
Connectors as Designs
A Truly Concurrent Process Semantics over Multi-Pomsets of Consumable Resources
Concurrent Java Test Generation as a Search Problem
Sub-lambda-calculi, Classified
Intensional semantics of system T of Gödel
Web Interfaces for Proof Assistants
A Denotational Semantics for SPARC TSO
Modelling Grid5000 point availability with SAN
Refinement of Interface Automata Strengthened by Action Semantics
Enhancing Theorem Prover Interfaces with Program Slice Information
Consistent Partial Model Checking
Quantitative Assessment of a Peer-to-peer Cooperative Infrastructure Using Stochastic Well-Formed Nets
Deriving Logical Relations from Interpretations of Predicate Logic
A Calculus for Dynamic Reconfiguration with Low Priority Linking
Linearization of Automatic Arrays and Weave Specifications
Formal Modelling of Salience and Cognitive Load
Counting the Cost in the Picalculus (Extended Abstract)
Finiteness Spaces and Generalized Power Series
Exact Algorithms for MAX-SAT
Combinator Parsers - From Toys to Tools
Quantitative Static Analysis Over Semirings: Analysing Cache Behaviour for Java Card
Tool Support for Proof Engineering
Specifying Component Behavior with Port State Machines
Compiling Join-Patterns
Colouring Proofs: A Lightweight Approach to Adding Formal Structure to Proofs
A Novel Cost Model of XML Serialization
Arguments and Misunderstandings: Fuzzy Unification for Negotiating Agents
Classifying and Formally Verifying Integer Constant Folding
Algorithmic Algebraic Model Checking III: Approximate Methods
Finding Similarities in Source Code Through Factorization
The Duality Theory of General Z-continuous Posets
Bigraphical Semantics of Higher-Order Mobile Embedded Resources with Local Names
Refactoring Real-time Specifications
Performance Evaluation of a Real-time Simulation Architecture using Probabilistic Model Checking
A Distributed Implementation of Mobile Maude
Distributed Graph Traversals by Relabelling Systems with Applications
A note on outward and inward productions in the categorical graph-grammar approach and Delta-grammars
Modular Architectural Representation and Analysis of Fault Propagation and Transformation
Debugging as a Science, that too, when your Program is Changing
Describing properties of concurrent systems (Logic for Traces) (invited talk)
Model-checking the Preservation of Temporal Properties upon Feature Integration
Probabilistic and Nondeterministic Aspects of Anonymity
Using the Alloy Analyzer to Verify Data Refinement in Z
Some Programming Languages Suggested by Game Models (Extended Abstract)
On Succinctness of Hierarchical State Diagrams in Absence of Message Passing
The OMEGA Component Model
Abstract Conditions for the Confluence of Explicit Substitution Calculi
Topological Cones: Foundations for a Domain Theoretical Semantics Combining Probability and Nondeterminism
The Quest for Equational Axiomatizations of Parallel Composition: Status and Open Problems
Trail-directed model checking
Tree Automata for Detecting Attacks on Protocols with Algebraic Cryptographic Primitives
Integrating Time and Resource into Circus
On the Turing equivalence of Linda coordination primitives
Domain Equations Based on Sets with Families of Pre-orders
Checking Z Data Refinements Using Traces Refinement
Recursive Functions with Pattern Matching in Interaction Nets
A coalgebraic introduction to CSP
Integrating test generation functionality into the Teaching Machine environment
Some Examples of Non-Metrizable Spaces Allowing a Simple Type-2 Complexity Theory
Semantic Abstraction and Quantum Computation
WCET Analysis of Data Dependent, Component Oriented, Embedded Software Systems
Expressivity in the kappa Family
Using Aspects for Enforcing Formal Architectural Invariants
Policy Iteration in Finite Templates Domain
Reasoning About Partial Functions in the Formal Development of Programs
A Java Card CAP converter in PVS
Model-Generation of a Fictitious Clock Real-Time Logic Using Sharing Trees
The Descriptive Complexity of Decision Problems through Logics with Relational Fixed-Point and Capturing Results
More infinite results
Supporting JAsCo AOP By Means of Eclipse
Rule-based Programming in Java For Protocol Verification
Run-Time Checking of Dynamic Properties
A General Framework for Overlay Visualization
A powerdomain of possibility measures
Type Inference using Constraint Handling Rules
Aspect-Oriented Action Semantics Descriptions
Getting Train Timetables into the Main Storage
Comparing Control Constructs by Double-barrelled {CPS} Transforms
Approximation Metrics Based on Probabilistic Bisimulations for General State-Space Markov Processes: A Survey
The Story of Re-engineering 350,000 Lines of FORTRAN Code
Augur 2 - A New Version of a Tool for the Analysis of Graph Transformation Systems
On the Role of Metadata in Visual Language Reuse and Reverse Engineering - An Industrial Case
Quantified Interference for a While Language
Recursive Definitions and Fixed-Points
A Petri-Net Based Reflective Framework for the Evolution of Dynamic Systems
Algebraic Specification and Coalgebraic Synthesis of Mealy Automata
Constructive design of a hierarchy of semantics of a transition system by abstract interpretation
Towards ANSI C Program Slicing using XML
Strong fairness and Recursive Communicating Processes
Extending Abstract Acceleration Methods to Data-Flow Programs with Numerical Inputs
Performance Models For Master/Slave Parallel Programs
Formal Verification of Timed Systems Using Cones and Foci
XKlaim and Klava: Programming Mobile Code
A Formalization of Credit and Responsibility Within the GNDC Schema
Directed Homology
Towards Compositional Graph Theory
Faithful pi-nets - A graphical representation of the asynchronous pi-calculus
A Parallel Approach to Concolic Testing with Low-cost Synchronization
Proving Termination by Policy Iteration
Metaprogramming Applied to Web Component Deployment
Model-based Theory Combination
Simulating Emergent Properties of Coordination in Maude: the Collective Sort Case
Towards component based systems: refining connectors
A Software Maintenance Maturity Model (S3M): Measurement Practices at Maturity Levels 3 and 4
Derivable Type Classes
Fairness of Components in System Computations
Categorical Properties of The Complex Numbers
Type Systems for Optimizing Stack-based Code
Through Modeling to Synthesis of Security Automata
Case-based Reasoning for Web Service Discovery and Selection
Complete and Terminating Tableau for the Logic of Proper Subinterval Structures Over Dense Orderings
Remarks on Sigma-definability without the equality test over the Reals
The Leader Election Protocol of IEEE 1394 in Maude
Fragments and Chemical Organisations
New Algorithms for Solving Simple Stochastic Games
A Graph-Based Metamodel for Object-Oriented Software Metrics
The Tractability of Model-checking for LTL: The Good, the Bad, and the Ugly Fragments
Compiling Esterel into Static Discrete-Event Code
The Case for Analog Circuit Verification
Parallel and Symbolic Model Checking for Fixpoint Logic with Chop
A Tutorial on Specifying Data Structures in Maude
A Software System for Computing Labeled Orthogonal Drawings of Graphs
On-The-Fly Path Reduction
A Graph Abstract Machine Describing Event Structure Composition
ACTAS : A System Design for Associative and Commutative Tree Automata Theory
Monads in Semantics
Bibliography on Realizability
Systems Modelling via Resources and Processes: Philosophy, Calculus, Semantics, and Logic
Algorithmic Verification of Noninterference Properties
On a Graph Approach to Modal Logics
Zooming-out on Higraph-based diagrams - Syntactic and Semantic Issues
Development of a Smart Grid Simulation Environment
On the Specification of Full Contracts
An Algebraic Baseline for Automatic Transformations in MDA
Dynamic Transition Refinement
Modal Rules are Co-Implications
On the Complexity of the Pancake Problem
Expansion: the Crucial Mechanism for Type Inference with Intersection Types: A Survey and Explanation
Labelled Transitions for Mobile Ambients (As Synthesized via a Graphical Encoding)
The Algebra of Partial Equivalence Relations
General Secret Sharing Based on the Chinese Remainder Theorem with Applications in E-Voting
Distributivity for a monad and a comonad
An Accurate Join for Zonotopes, Preserving Affine Input/Output Relations
Modeling and Verification of RBC Handover Protocol
Coverage-driven Automated Compiler Test Suite Generation
Combining Proof and Model-checking to Validate Reconfigurable Architectures
Object-oriented Tree Traversal with JJForester
Steps in Modular Specifications for Concurrent Modules (Invited Tutorial Paper)
Categories of Timed Stochastic Relations
A programmed graph rewriting system for software process management
Fujaba-Based Tool Development for eHome Systems
Test set coinduction - Toward automated verification of behavioural properties
Giry and the Machine
Toward the Concept of Backtracking Computation
Towards a Complete Static Analyser for Java: an Abstract Interpretation Framework and its Implementation
Effective Randomness for Computable Probability Measures
A Symbolic Model for Timed Concurrent Constraint Programming
Correct and Complete (Positive) Strategy Annotations for OBJ
On Decidability of LTL+Past Model Checking for Process Rewrite Systems
Enumerations of Pi 1 0 Classes: Acceptability and Decidable Classes
Tool Support for Engineering Certifiable Software
Decidability of a Hybrid Duration Calculus
(Omega, Xi)-Logic: On the Algebraic Extension of Coalgebraic Specifications
mu-Calculus Model Checking in Maude
Modelling Intracellular Fate of FGF Receptors With BioAmbients
A Verifier for Region-Annotated Java Bytecodes
A Generic Process Algebra
Compositional Minimization in Span(Graph): Some Examples
An Inverse Method for Parametric Timed Automata
A fast data protection technique for mobile agents against malicious hosts
Estimating Non-functional Properties of Component-based Software Based on Resource Consumption
The Incremental Satisfiability Problem for a Two Conjunctive Normal Form
Sequent Calculi for the Normal Terms of the - and - Calculi
High-Fidelity C/C++ Code Transformation
Timed CSP = Closed Timed Safety Automata
Eliminating Proofs from Programs
Petri nets with causal time for system verification
Linear types for higher order processes with first class directed channels
Monadic Corecursion - Definition, Fusion Laws, and Applications
Equivalence of Two Formal Semantics for Functional Logic Programs
On intuitionistic proof nets with additional rewrite rules and their approximations
MPTP 0.1: System Description
Evaluating Computational Performance of Backpropagation Learning on Graphics Hardware
A Port Graph Calculus for Autonomic Computing and Invariant Verification
Mathematics, Computer Science, Software Engineering
PVS#: Streamlined Tacticals for PVS
Exploiting User-definable Synchronizations in Graph Transformation
Rank and Select for Succinct Data Structures
How Many Times do We Need an Assumption to Prove a Tautology in Minimal Logic? Examples on the Compression Power of Classical Reasoning
Metric semantics for synchronous and asynchronous communication: a continuation-based approach
Theoretical Foundations of Value Withdrawal Explanations for Domain Reduction
A Combined Process Algebraic and Stochastic Approach to Bone Remodeling
A Domain-Theoretic Model Of Nominally-Typed Object-Oriented Programming
Propositional Logic as a Propositional Fuzzy Logic
An Exercise on Transition Systems
The Maude LTL Model Checker
Ontologies for Specifying and Reconciling Contexts of Web Services
Improving Translation of Live Sequence Charts to Temporal Logic
Requirements for a Practical Network Event Recognition Language
On the Unification of Process Semantics: Equational Semantics
Robin Milner's Work on Concurrency
Programming in Biomolecular Computation
Discovering Coordination Patterns