yusuke1997/dblp-id-title huggingface dataset:
Towards Continuous Latency Monitoring through Open RAN Interfaces
5G-MANTRA: Multi-Access Network Testbed for Research on ATSSS
Enabling TCP Communication over Terahertz Links: An Extension to ns-3's TeraSim Module
Towards Application Level Energy Monitoring for Green 6G Networks
CARL-W: a Testbed for Empirical Analyses of 5G and Starlink Performance
An Abstract Processing Model for the Quality of Context Data
The Quality of Geospatial Context
A Probabilistic Filter Protocol for Continuous Queries
Bringing Quality of Context into Wearable Human Activity Recognition Systems
Context Quality and Privacy - Friends or Rivals?
Querying and Cleaning Uncertain Data
Quality Dependent Reconstruction of Building Façades
A Context Quality Model to Support Transparent Reasoning with Uncertain Context
On a Generic Uncertainty Model for Position Information
A Framework for Quality of Context Management
Spatial Embedding and Spatial Context
UDS: Sustaining Quality of Context Using Uninterruptible Data Supply System
Presentation and Evaluation of Inconsistencies in Multiply Represented 3D Building Models
Interacting with Context
Quality of Context, First International Workshop, QuaCon 2009, Stuttgart, Germany, June 25-26, 2009. Revised Papers
Establishing Similarity across Multi-granular Topological-Relation Ontologies
Using Quality of Context to Resolve Conflicts in Context-Aware Systems
Forecasting the hourly Ontario energy price by local linear wavelet neural network and ARMA models
Integrated design space exploration based on power-performance trade-off using genetic algorithm
Performance evaluation on segmentation methods for medical images
Efficient fault tolerant consensus using preemptive token
MGC middleware for grid computing: the Globus Toolkit
Intrusion detection system using honeypots and swarm intelligence
Crank-Nicolson scheme to transient MHD free convective flow through semi-infinite vertical porous plate with constant suction and temperature dependent heat source
Artificial intelligent firewall
Architecture for intelligent transport system for automated vehicle
An efficient job scheduling algorithm for grid computing
Automatic human activity recognition in video using background modeling and spatio-temporal template matching based technique
Security in real time multimedia data based on generalized keys
Security policy implementation using connection and event log to achieve network access control
Elliptic curve cryptography: survey and its security applications
Fuzzy logic based decision support system for loan risk assessment
Automated taxi/cab system using A* algorithm
Application specific processor vs. microblaze soft core RISC processor: FPGA based performance and CPR analysis
RFID enabled cards skimming: enhanced technology
Topic tracking techniques for natural language processing
A model for estimating efforts required to make changes in a software development project
AI based supervised classifiers: an analysis for intrusion detection
Semantic web services in clouds for semantic computing
DMX in MANETs: major research trends since 2004
Development of traffic light control system based on fuzzy logic
Analysis of various swarm-based & ant-based algorithms
International Conference on Advances in Computing and Artificial Intelligence, ACAI '11, Rajpura/Punjab, India - July 21 - 22, 2011
Adapting intelligence in robot using fuzzy logic
Complexity study on "Carry-along Sort" algorithm
Fuzzy rule-based controller for binary distillation column
Ontology based semantic similarly ranking of documents
Scene flow estimation from stereo video source
Modeling and designing of machine learning procedures as applied to game playing using artificial intelligence
Security threats to mobile agents
A comparative study of UML tools
Secured routing over MANET with power management
Study of text based mining
Distributed smart camera network and mobile devices
A robust multi-objective optimization to workflow scheduling for dynamic grid
A hybrid method for 3D face localization
Feature extraction based IP traffic classification using machine learning
Frontal view gait based recognition using PCA
Educational web sites accessibility design model
Trivial solution for a non-trivial problem in MANETs
Contemporary study of cloud computing environment
RR based grid scheduling algorithm
Error correction in function point estimation using soft computing technique
Wireless machine monitoring embodiment using mobile computing
Refjav: tool for automated verification by generating CCS of multithreaded Java system in distributed environment
A comparative study of ICA algorithms for ECG signal processing
An efficient broker cloud management system
Proceedings of the 1st AIxIA Workshop on Green-Aware Artificial Intelligence co-located with the 23rd International Conference of the Italian Association for Artificial Intelligence (AIxIA 2024), Bolzano, Italy, November 27-28, 2024
On the Environmental Impact of the Algorithm LatentOut for Unsupervised Anomaly Detection (SHORT PAPER)
Optimizing Photosensor Placement for Energy-Efficient Lighting in Sustainable Building Design based on Multivariate Long Short-Term Memory Models
Enhancing the Evaluation of Fault Detection Models in Smart Agriculture Using LLM Agents for Rule-Based Anomaly Generation
Exploiting Outlier Explanation to Unveil Key-aspects of High Green Comparative Advantage Nations
A Lightweight Meta-Feature Extraction Strategy for Deep Reinforcement Anomaly Detection (SHORT PAPER)
A Declarative Framework for Temporal Reasoning in Green-Aware Applications
DPET: A Data and Parameter Efficient Training Framework for Green AI (SHORT PAPER)
Optimal Instruction Scheduling using Constraint Logic Programming
Using Cached Functions and Constructors for Incremental Attribute Evaluation
From Term Rewriting to Generalised Interaction Nets
Why Multi-SLD Beats SLD (Even on a Uniprocessor)
Strictness Analysis for Attribute Grammars
Using Higher-Order Control Flow Analysis When Compiling Functional Languages
Using Logic Databases in Software Development Environments
An Experiment in Domain Refinement: Type Domains and Type Representations for Logic Programs
The MAS Specification Component
Implementation of Term Rewritings with the Evaluation Strategy
Programming Language Specification and Prototyping Using the MAX System
LaToKi: A Language Toolkit for Bottom-Up Evaluation of Functional Programs
Embedding Declarative Subprograms into Imperative Constructs
A Compiler Written in Prolog: The Véda Experience
Towards Independent And-Parallelism in CLP
ProQuery: Logical Access to an OODB
An Editor for Helping Novices to Learn Standard ML
Avoiding Dynamic Delays in Functional Logic Programs
Dynamic Detection of Determinism in Functional Languages
A Portable Implementation of Memoing Evaluation
An Implementation of Retargetable Code Generators in Prolog
Performance of A Data-Parallel Concurrent Constraint Programming System
The Notion of Floundering for SLDNF-Resolution Revisited
Constructive Negation Using Typed Existence Properties
Annotated Structure Shape Graphs for Abstract Analysis of Prolog
Lazy Evaluation in Logic
A Reactive Implementation of Pos Using ROBDDs
Path Analysis for Lazy Data Structures
The System FLR (Fast Laboratory for Recomposition)
Stack Management of Runtime Structures in Distributed Implementations
Efficient Bottom-up Abstract Interpretation of Prolog by Means of Constraint Solving over Symbolic Finite Domains
A Functional Framework for Deterministically Interleaved Interactive Programs
Programming with Constructor Classes (Abstract)
An Efficient and Precise Sharing Domain for Logic Programs
A Debugging Model for Lazy Narrowing
Narrowing as an Incremental Constraint Satisfaction Algorithm
A WAM-Based Implementation of a Logical Language with Sets
Beyond Depth-First: Improving Tabled Logic Programs through Alternative Scheduling Strategies
A Relational Programming System with Inferred Representations
A New Strategy for Semantic Matching
Unlimp, Uniqueness as a Leitmotiv for Implementation
Static Type Analysis of Prolog Procedures for Ensuring Correctness
Compiling Erlang to Scheme
Shared Memory System for Babel: a VHDL Specification
Formal Specification of Interactive Languages Using Definite Clause Grammars
Flang and its Implementation
Fast Prolog with VAM1p based Prolog Compiler
The ALF System
Interprocedural Abstract Interpretation of Block Structured Languages with Nested Procedures, Aliasing and Recursivity
Implementing Higher-Order Functions in an Algebraic Specification Language with Narrowing
Transformations for Efficient Evaluations in Functional Programming
Generating Efficient Code From Data-Flow Programs
Logic-Based Specification of Visibility Rules
Development of Rewriting Strategies
Efficient Lazy Narrowing using Demandedness Analysis
Semantics-Directed Generation of a Prolog Compiler
A Simple and Efficient Copying Garbage Collector for Prolog
Semantics-Based Compiling: A Case Study in Type-Directed Partial Evaluation
A Game Semantics Foundation for Logic Programming (Extended Abstract)
An Open-Ended Finite Domain Constraint Solver
Flang System: A new Version
Towards a Characterization of Termination of Logic Programs
Selective Recomputation for Handling Side-Effects in Parallel Logic Programs
Generalized beta-Reduction and Explicit Substitution
Extraction of Functional from Logic Program
A Lattice of Abstract Graphs
Short Overview of the CLPS System
Dynamic Dependence in Term rewriting Systems and its Application to Program Slicing
Pattern Matching in a Functional Transformation Language using Treeparsing
Lightweight GUIs for Functional Programming
Binding Techniques and Garbage Collection for OR-Parallel CLP Systems
clp(B): Combining Simplicity and Efficiency in Boolean Constraint Solving
A technique for Transforming Logic Programs by Fold-Unfold Transformations
An Implementation of Action Semantics (Summaray)
The LOL Deductive Database Programming Language (Extended Abstract)
Towards a Taxonomy of Functional Languages Implementations
An Approach to Verifiable Compiling Specification and Prototyping
Attributed Models of Executable Specifications
Programming Language Implementation and Logic Programming, 6th International Symposium, PLILP'94, Madrid, Spain, September 14-16, 1994, Proceedings
Abstract Interpretation: A Kind of Magic
A Hidden Herbrand Theorem
Efficient Data Representation in Polymorphic Languages
Semantic-Based Static Program Transformations for Memory Space and Run Time Optimization in Hybrid Languages
PAGODE: a Back End Generator
Unfolding - Definition - Folding, in this Order, for Avaoiding Unnecessary Variables in Logic Programs
A Bottom-Up Adaption of Earley's Parsing Algorithm
Program Sharing: A New Implementation Approach for Prolog
Logic Implemented Functionally
Efficient Register Allocation for Large Basic Blocks
Parsing Visual Languages with Constraint Multiset Grammars
S-SLD-resolution - An Operational Semantics for Logic Programs with External Procedures
A Complete Indexing Scheme for WAM-based Abstract Machines
Fully Declarative Logic Programming
Approaches to the Incremental Detection of Implicit Equalities with the Revised Simplex Method
Calculate Polytypically!
A Randomized Heuristic Approach to Register Allocation
A Complete Narrowing Calculus for Higher-Order Functional Logic Programming
Logic Programming within a Functional Framework
Formal Specification of a Prolog Compiler
PROMAL - Programming in Modal Action Logic
Executable Specifications for Language Implementation
Towards Integrating Functional and Logic Styles Using Relation
A Dataflow Semantics for Constraint Logic Programs
A New Presburger Arithmetic Decision Procedure Based on Extended Prolog Execution
Derivation of Proof Methods by Abstract Interpretation
A Verified Implementation of Narrowing
Teaching Functional and Logic Programming with a Single Computational Model
Executing Bounded Quantifications on Shared Memory Multiprocessors
On the Borderline Between Grammars and Programs
Scheduling Expression DAGs for Minimal Register Need
From Parlog to Polka in two easy Steps
Programming Languages: Implementations, Logics, and Programs, 8th International Symposium, PLILP'96, Aachen, Germany, September 24-27, 1996, Proceedings
Efficient Incremental Evaluation of Higher order Attribute Grammars
Compilation of Non-Linear, Second Order Patterns on S-Expressions
A New Data Structure for Implementing Extensions to Prolog
Evaluation Under Lambda Abstraction
The Versatility of Handling Disjunctions as Constraints
An Expression-Or-Parallel Implementation for a Functional Logic Language
Transforming Lazy Functions Using Comportment Properties
Efficient Multi-level Generating Extensions for Program Specialization
Logic Programming and Model Checking
Implementing the Synthesis of Properties in Unfold/Fold Transformations
Integrating Efficient Records into Concurrent Constraint Programming
A Compiler for Rewrite Programs in Associative-Commutative Theories
Why the Occur-Check is Not a Problem
An Application of Abstract Interpretation in Source Level Program Transformation
Gadgets: Lazy Functional Components for Graphical User Interfaces
Compiling Logic Programs with Equality
Deriving of Linear Size Relations by Abstract Interpretation
Programming Language Implementation and Logic Programming, 5th International Symposium, PLILP'93, Tallinn, Estonia, August 25-27, 1993, Proceedings
CAT: The Copying Approach to Tabling
Combining Lazy Narrowing and Simplification
Uniform PERs and Comportment Analysis
Functional Programming and Geometry
Metastructures versus Attributed Variables in the Context of Extensible Unification
UCG-E: An Equational Logic Programming System
Towards a Meaning of LIFE
Generation of Synchronization Code for Parallel Compilers
A Lambda-Calculus à la de Bruijn with Explicit Substitutions
Programming Language Implementation and Logic Programming, 4th International Symposium, PLILP'92, Leuven, Belgium, August 26-28, 1992, Proceedings
On the Automatic Generation of Events in Delta Prolog
Program Analysis in Lambda-Prolog
Integrating Strict and Lazy Evaluation: The lambda-sl-Calculus
The Vienna Abstract Machine
Automatic Run-Time Code Generation in Object-Oriented Languages
Embedding Multiset Constraints into a Lazy Functional Logic Language
Dynamic Attribute Grammars
Where Do I Begin? A Problem Solving Approach in teaching Functional Programming
Semantics and Compilation of Recursive Sequential Streams in 8½
Uniqueness Type Inference
A Logic-Based Approach to Data Flow Analysis Problem
Combining Lazy Narrowing with Disequality Constraints
On the Interaction of Lazy Evaluation and Backtracking
Inference of Inheritance Relationships from Prolog Programs: a System Developed with PrologIII
Comparing the Galois Connection and Widening/Narrowing Approaches to Abstract Interpretation
PIDGETS - Unifying Pictures and Widgets in a Constraint-Based Framework for Concurrent Functional GUI Programming
Limits of ML-Definability
Unfold/fold Transformations Preserving Termination Properties
Domesticating Imperative Constructs So That They Can Live in a Functional World
Interprocedural Dynamic Slicing
Using an Attribute Grammar as a Logic Program
A Tool to Check the Non-Floundering Logic Programs and Goals
Context-Sensitive Computations in Confluent Programs
Inference-Based Overloading Resolution for ADA
U-Log, An Ordered Sorted Logic with Typed Attributes
Modes of Comprehension: Mode Analysis of Arrays and Array Comprehensions
Design and Implementation of Jump Tables for Fast Indexing of Logic Programs
Compiling TYPOL with Attribute Grammars
Improving Arithmetic Performance using Fine-Grain Unfolding
Our LIPS Are Sealed: Interfacing Functional and Logic Programming Systems
Generic Abstract Interpretation Algorithms For Prolog: Tow Optimization Techniques and Their Experimental Evaluation
Systematic Extraction and Implementation of Divide-and-Conquer Parallelism
Mechanically Verifying the Correctness of an Offline Partial Evaluator
A Grammatical View of Logic Programming
An Architectural Model for OR-Parallelism on Distributed Memory Systems
Objects with State in Contextual Logic Programming
Optimal Reduction of Functional Expressions
Constraints for Synchronizing Logic Coarse-grained Sequential Logic Processes
The Implementation of Lazy Narrowing
Tracing Lazy Functional Computations Using Redex Trails
Higher-Order Chaotic Iteration Sequences
A Novel Term Compression Scheme and Data Representation in the BinWAM
A Bottom-Up Interpreter for a Higher-Order Logic Programming Language
Implementing Memoization for Partial Evaluation
Termination of Logic Programs with block Declarations Running in Several Modes
Implementing Parallel Rewriting
On Safe Folding
Incremental Evaluation of Natural Semantics Specification
Functorial ML
Functional Skeletons Generate Process Topologies in Eden
Abstract Complexity of Prolog Based on WAM
Efficient Integration of Simplifications into Prolog
A Framework to Specify Database Update Views for Prolog
The Boolean Logic of Set Sharing Analysis
Compilation of Predicate Abstractions in Higher-Order Logic Programming
Implementing Attribute Grammars by Computational Models
An Abstract Machine for Oz
Viewing A Program Transformation System At Work
Functional Programming Languages with Logical Variables: A Linear Logic View
Evaluation of Expressions in a Multiparadigm Framework
Efficient Compile-Time Garbage Collection for Arbitrary Data Structures
A General Trace Query Mechanism Based on Prolog
Elementary Logic Programs
On Object Calculus with Algebraic Rewriting
A Parallel Implementation for AKL
A Constraint Logic Programming Shell
GOTA Algebras: A Specification Formalism for Inheritance and Object Hierarchies
Extending Execution Trees for Debugging and Animation in Logic Programming
Proving the Correctness of Compiler Optimizations Based on Strictness Analysis
PROFIT: A System Integrating Logic Programming and Attribute Grammars
A Demand Driven Computation Strategy for Lazy Narrowing
Decidability of Logic Program Semantics and Applications to Testing
Narrowing Approximations as an Optimization for Equational Logic Programs
A Portable and Efficient Implementation of KL1
Principles of Declarative Programming, 10th International Symposium, PLILP'98 Held Jointly with the 7th International Conference, ALP'98, Pisa, Italy, September 16-18, 1998, Proceedings
Implementing a Meta-Logical Scheme
Precedences in Specifications and Implementations of Programming Languages
A Generic Program for Sequential Decision Processes
Integrating Constraint Propagation in Complete Solving of Linear Diophantine Systems
Deriving Residual Reference Count Garbage Collectors
A Logic for Encapsulation in Object Oriented Languages
Concepts for a Modular and Distributed Prolog Language
FRATS: A Parallel Reduction Strategy for Shared Memory
A Debugging Model for Functional Logic Programs
The Complexity of Late-Binding in Dynamic Object-Oriented Languages
Better Consumers for Deforestation (Extended Abstract)
Type Isomorphisms for Module Signatures
Towards a Framework for the Abstract Interpretation of Logic Programs
Needed Narrowing in Prolog (Extended Abstract)
A System to Visualize and Interact with Prolog Programs
A Semantic Model of Binding Times for Safe Partial Evaluation
Improvements in Compile-Time Analysis for Ground Prolog
A Pragmatic Approach to Compilation of Erlang
Reasoning About Programs with Effects
Subsumption-oriented Push-Down Automata
CAMEL: An Extension of the Categorial Abstract Machine to Compile Functional/Logic Programs
FOLON: An Environment for Declarative Construction of Logic Programs
Intuitionistic Implication in Abstract Interpretation
Unfold/Fold Transformations For Definite Clause Programs
A Novel Method for Parallel Implementation of findall
Abstracting s-semantincs Using A Model-Theoretic Approach
Inline Expansion: When and How?
Explicit Substitutions for Objects and Functions
Logic Program Specialisation: How To Be More Specific
A Declarative Approach to Concurrent Programming
Inheritance and Selective Methods Dispatching in Concurrent Haskell
Programming Languages: Implementations, Logics and Programs, 7th International Symposium, PLILP'95, Utrecht, The Netherlands, September 20-22, 1995, Proceedings
Structure Sharing in Attribute Grammars
Partial Deduction and Driving are Equivalent
Improving Control of Logic Programs by Using Functional Logic Languages
Programming Languages: Implementations, Logics, and Programs, 9th International Symposium, PLILP'97, Including a Special Trach on Declarative Programming Languages in Education, Southampton, UK, September 3-5, 1997, Proceedings
SICStus MT - A Multithreaded Execution Environment for SICStus Prolog
Minimal Set Unification
Approximating Constraint Logic Programs Using Polymorphic Types and Regular Descriptions
Implementations of Program Composition Operations
Transformation of Divide & Conquer to Nested Parallel Loops
Architecture Software Using: A Methodology for Language Development
Cheap Tupling in Calculational Form
Multilanguage Interoperability
A Technique for Recursive Invariance Detection and Selective Program Specification
Finding the Least Fixed Point Using Wait-Declarations in Prolog
Modifying the Simplex Algorithm to a Constraint Solver
Higher Order Deforestation
BinProlog: a Continuation Passing Style Prolog Engine
Compilation of Narrowing
Operational Versus Denotational Methods in the Semantics of Higher Order Languages
Specification and Implementation of Grammar Couplings using Attribute Grammars
Readable, Runnable Requirements Specifications in SPILL-2
CLP(PB), A Meta-Interpreter in CLP(R)
Encapsulating Data in Logic Programming via Categorial Constraints
Modeling Sharing and Recursion for Weak Reduction Strategies Using Explicit Substitution
Goal-Directed Query Processing in Disjunctive Logic Databases
Programming Language Implementation and Logic Programming, 1st International Workshop PLILP'88, Orléans, France, May 16-18, 1988, Proceedings
Formal Translations Described by Translation Grammars with LR(k) Input Grammars
Experiences with Gentle: Efficient Compiler Construction Based On Logic Programming
Parametric Polymorphism for Typed Prolog and lambda-Prolog
Annotated Constraint Logic Programming Applied to Temporal Reasoning
Partial Continuations as the Difference of Continuations - A Duumvirate of Control Operators
ProFun - A Language for Executable Specifications
DrScheme: A Pedagogic Programming Environment for Scheme
Sleepers: A Versatile High-Level Control Mechanism
Static Analysis Of Functional Programs With Logic Variables
An Implementation Technique for a Class of Bottom-Up Procedures
Hand-Writing Program Generator Generators
Inlining to Reduce Stack Space
Automatic Optimization of Dynamic Scheduling in Logic Programs
Controlling Conjunctive Partial Deduction
Abstract Interpretation for Type Checking
Local Linear Logic for Locality Consciousness in Multiset Transformation
Controlling Search in Declarative Programs
An OR Parallel Prolog Model for Distributed Memory Systems
RML - A New Language and Implementation for Natural Semantics
A Framework for Bottom Up Specialisation of Logic Programs
Resolution for Logic Programming with Universal Quantifiers
Unfold/Fold Transformations of Concurrent Processes
Introducing the Declarative Dungeon
Checking and Debugging of Two-level Grammars
Higher-Order Value Flow Graphs
Improving Search for Job-Shop Scheduling with CLP(FD)
Handling Preferences in Constraint Logic Programming with Relational Optimization
Algorithmic Debugging for Lazy Functional Languages
A New Top-Down Parsing Algorithm for Left-Recursive DCGs
Narrowing the Narrowing Space
Overriding Operators in a Mixin-Based Framework
A General Framework for R-Unification Problems
Towards a Provably Correct Compiler for OBJ3
Abstracting Numerical Values in CLP(H, N)
A Semantic Evaluator Generating System in Prolog
Coupled Contex-Free Grammar As a Programming Paradigm
Bug Localization by Algorithmic Debugging and Program Slicing
Programming Language Implementation and Logic Programming, 3rd International Symposium, PLILP'91, Passau, Germany, August 26-28, 1991, Proceedings
Detecting Unsolvable Queries for Definite Logic Programs
Independent AND-Parallel Implementation of Narrowing
Towards a "Middle Road" Methodology for Writing Code Generators
I/O Trees and Interactive Lazy Functional Programming