Prolog Facts Research Articles

Specification of schedulability assumptions to leverage multiprocessor Analysis

In order to ease the early verification of uniprocessor real-time systems, the tool Cheddar provides a service that guarantees the applicability of a schedulability analysis method for a given architecture model. This verification service uses a catalog of design patterns.In this article, we propose to extend these patterns to multiprocessor architectures. Designing such extension is a challenge because the knowledge of both the software and the hardware architectures are essential to decide on the schedulability of a task set in that context. Indeed, parallel execution of tasks involves hardware resource sharing, that has in turn an effect on the task execution times. Currently, no general method is able to assess the schedulability of a high-performance multicore system with a limited level of pessimism, except if assumptions or usage restrictions are set to simplify the system analysis.So, the research community is developing multiple schedulability tests based on various assumptions which constrain the task models and their execution platforms. In this article, we propose a framework based on Prolog that allows engineers to verify the conditions to apply a test are met. Prolog facts model the software and hardware architecture, and the inference engine checks whether these facts conform to a design pattern associated to a given verification method.The design pattern compliance framework is integrated with the Cheddar tool. Three examples of multiprocessor analyses illustrate the proposal. A scalability analysis shows the tool is able to verify the compliance of architectures composed of 600 tasks and 60 cores, in less than 140s on a desktop computer.

Interactive Text Graph Mining with a Prolog-Based Dialog Engine

AbstractOn top of a neural network-based dependency parser and a graph-based natural language processing module, we design a Prolog-based dialog engine that explores interactively a ranked fact database extracted from a text document. We reorganize dependency graphs to focus on the most relevant content elements of a sentence and integrate sentence identifiers as graph nodes. Additionally, after ranking the graph, we take advantage of the implicit semantic information that dependency links and WordNet bring in the form of subject–verb–object, “is-a” and “part-of” relations. Working on the Prolog facts and their inferred consequences, the dialog engine specializes the text graph with respect to a query and reveals interactively the document’s most relevant content elements. The open-source code of the integrated system is available at https://github.com/ptarau/DeepRank.

Advances in Big Data Bio Analytics

Delivering effective data analytics is of crucial importance to the interpretation of the multitude of biological datasets currently generated by an ever increasing number of high throughput techniques. Logic programming has much to offer in this area. Here, we detail advances that highlight two of the strengths of logical formalisms in developing data analytic solutions in biological settings: access to large relational databases and building analytical pipelines collecting graph information from multiple sources. We present significant advances on the bio_db package which serves biological databases as Prolog facts that can be served either by in-memory loading or via database backends. These advances include modularising the underlying architecture and the incorporation of datasets from a second organism (mouse). In addition, we introduce a number of data analytics tools that operate on these datasets and are bundled in the analysis package: bio_analytics. Emphasis in both packages is on ease of installation and use. We highlight the general architecture of our components based approach. An experimental graphical user interface via SWISH for local installation is also available. Finally, we advocate that biological data analytics is a fertile area which can drive further innovation in applied logic programming.

Querying XML documents using Prolog engines: When is this a good idea?

XML has become a universal standard for information exchange over the Web due to features such as simple syntax and extensibility. Processing queries over these documents has been the focus of several research groups. In fact, there is broad literature in efficient XML query processing which explore indexes, fragmentation techniques, etc. However, for answering complex queries, existing approaches mainly analyze information that is explicitly defined in the XML document. A few work investigate the use of Prolog to increase the query possibilities, allowing inference over the data content. This can cause a significant increase in the query possibilities and expressive power, allowing access to non-obvious information. However, this requires translating the XML documents into Prolog facts. But for regular queries (which do not require inference), is this a good alternative? What kind of queries could benefit from the Prolog translation? Can we always use Prolog engines to execute XML queries in an efficient way? There are many questions involved in adopting an alternative approach to run XML queries. In this work, we investigate this matter by translating XML queries into Prolog queries and comparing the query processing times using Prolog and native XML engines. Our work contributes by providing a set of heuristics that helps users to decide when to use Prolog engines to process a given XML query. In summary, our results show that queries that search elements by a key value or by its position (simple search) are more efficient when run in Prolog than in native XML engines. Also, queries over large datasets, or that searches for substrings perform better when run by native XML engines.

Source Code Verification for Embedded Systems using Prolog

System relevant embedded software needs to be reliable and, therefore, well tested, especially for aerospace systems. A common technique to verify programs is the analysis of their abstract syntax tree (AST). Tree structures can be elegantly analyzed with the logic programming language Prolog. Moreover, Prolog offers further advantages for a thorough analysis: On the one hand, it natively provides versatile options to efficiently process tree or graph data structures. On the other hand, Prolog's non-determinism and backtracking eases tests of different variations of the program flow without big effort. A rule-based approach with Prolog allows to characterize the verification goals in a concise and declarative way. In this paper, we describe our approach to verify the source code of a flash file system with the help of Prolog. The flash file system is written in C++ and has been developed particularly for the use in satellites. We transform a given abstract syntax tree of C++ source code into Prolog facts and derive the call graph and the execution sequence (tree), which then are further tested against verification goals. The different program flow branching due to control structures is derived by backtracking as subtrees of the full execution sequence. Finally, these subtrees are verified in Prolog. We illustrate our approach with a case study, where we search for incorrect applications of semaphores in embedded software using the real-time operating system RODOS. We rely on computation tree logic (CTL) and have designed an embedded domain specific language (DSL) in Prolog to express the verification goals.

A heuristic method for detecting problems in business process models

PurposeThe purpose of this paper is to present a new heuristic approach for finding errors and possible improvements in business process models.Design/methodology/approachFirst, the paper translates the information that is included in a model into a set of Prolog facts. It then searches for patterns which are related to a violation of the soundness property or bad modeling style or otherwise gives rise to the assumption that the model should be improved. To validate this approach, the paper analyzes a repository of almost 1,000 business process models. For this purpose, three different model‐checkers that explore the state space of all possible executions of a model are used. The result of these tools are compared with the results given by this heuristic approach.FindingsThe paper finds that the heuristic approach identifies violations of the soundness property almost as accurate as model‐checkers. However, other than these tools, the approach never ran into state space explosion problems. Furthermore, this heuristic approach can also detect patterns for bad modeling style which can help to improve the quality of models.Practical implicationsHeuristic checks can run in the background while the modeler works on the model. In this way, feedback about possible modeling errors can be provided instantly. This feedback can be used to correct possible problems immediately.Originality/valueCurrent Prolog‐based validation tools check mainly for syntactical correctness and consistency requirements. This approach adds one more perspective by also detecting control‐flow errors (like deadlocks) and even pragmatic issues.

A rule-based video database system architecture

We propose a novel architecture for a video database system incorporating both spatio-temporal and semantic (keyword, event/activity and category-based) query facilities. The originality of our approach stems from the fact that we intend to provide full support for spatio-temporal, relative object-motion and similarity-based objecttrajectory queries by a rule-based system utilizing a knowledge-base while using an object-relational database to answer semantic-based queries. Our method of extracting and modeling spatio-temporal relations is also a unique one such that we segment video clips into shots using spatial relationships between objects in video frames rather than applying a traditional scene detection algorithm. The technique we use is simple, yet novel and powerful in terms of effectiveness and user query satisfaction: video clips are segmented into shots whenever the current set of relations between objects changes and the video frames, where these changes occur, are chosen as keyframes. The directional, topological and third-dimension relations used for shots are those of the keyframes selected to represent the shots and this information is kept, along with frame numbers of the keyframes, in a knowledge-base as Prolog facts. The system has a comprehensive set of inference rules to reduce the number of facts stored in the knowledge-base because a considerable number of facts, which otherwise would have to be stored explicitly, can be derived by rules with some extra effort.

Integration of CAD and a cutting tool selection system

This paper describes a novel concept for the integration of a CAD system and a knowledge based system of the selection of cutting tools and conditions for turning operations (EXCATS). This integrated system (CADEXCATS) is capable of processing CAD data and automatically generating the component representation file for EXCATS using the IGES neutral format and a feature recognition approach. The workpiece representation model is capable to describe sophisticated turned components using Prolog facts and other operational linked keywords. In addition, CAPP related features are effectively incorporated into the CADEXCATS system. A set of rules is established for the automatic determination of set-up, detection of complex geometries, recognition of grooves and other important features. Illustrative examples are presented to test and validate the developed system.

An integrated environment for reuse reengineering C code

The paper presents an integrated environment implemented in Prolog for reuse reengineering existing C systems. Different tools developed in the RE 2 project are integrated in the environment through sharing a fine-grained representation for C programs, the Combined C Graph (CCG). Different views of a system can be abstracted and visualised from the data-base of Prolog facts implementing its CCG representation. Software metric tools evaluate the reengineering costs, while reengineering operations are expressed as transformation rules and a symbolic executor allows the production of the reusable module's specification.

An IGES post-processor for interfacing CAD and CAPP of 2 1/2D prismatic parts

An IGES post-processor is presented, written in FORTRAN-77, to extract from an IGES file all information that an automatic process planning program needs, derive new information when necessary and formalise it as PROLOG facts. The processor deals with wire frame models and drawings. Its various modules are described and considerations about its design are discussed, associated with the IGES specification philosophy and pre-processor implementations. Analogous approaches from other processor designs are reviewed.

A Prolog simulation for combustion control

This paper describes the simulation of the effect on overall carbon monoxide and oxygen readings of alterations to the air inlet valve of each of a number of burners sharing a common flue. Built as part of the development program of a rule-based system for combustion control in a multiple burner furnace in the steel industry it has proved to be an invaluable tool. It is now being used to aid the adaptation of the rule-based system for use on other multiple burner furnaces and on boiler plants. Every burner in the installation is represented by a number of perfect burners which in turn are represented by Prolog facts in a relational database. Changes to the burners and readings of carbon monoxide and oxygen from the common flue are accomplished by Prolog predicates operating on the database as are changes in firing level and degeneration of the burners over time. Prolog was initially chosen for ease of interfacing with the rule-based system but was found to be an ideal language for writing the simulation although elegance of expression often had to be sacrificed to brute force for it to run effi ciently on a micro computer. The output of the functional simulation of a two burner installation under the control of the rule-based system is compared with that of a two burner boiler under the control of the same system. The response of the two is shown to be similar under a broad range of operating conditions.

Prolog program for subgraph enumeration and calculation of molecular connectivity indexes

AbstractProlog is applied to calculate the zero‐ through the sixth‐order molecular connectivity indexes. A description of the program is given. Enumeration of substructure fragments, which is the most time‐consuming part for this calculation, can be executed quite compactly by Prolog. For this execution, molecular structures and substructures are represented by Prolog facts and rules. An example of calculation is presented for a polycyclic structure. In addition, the method to increase the calculation speed is demonstrated.

Efficient database access from Prolog

In designing the interface between a relational database and a Prolog interpreter, efficiency is a major issue. The authors present a method for loading into the memory-resident database of Prolog facts permanently stored in secondary storage. The rationale of the method is to save access to the database by never repeating the same query and by storing in main memory, in a compact and efficient way, information about the past interaction with the database. The authors discuss how to reduce subsumption rests required by the method to pattern matching in many relevant cases. They also describe a simulator of the method, which validates their approach, and they discuss the results of the simulation. >