Prolog Clauses Research Articles

Towards System-Level Security Analysis of IoT Using Attack Graphs

Most IoT systems involve IoT devices, communication protocols, remote cloud, IoT applications, mobile apps, and the physical environment. However, existing IoT security analyses only focus on a subset of all the essential components, such as device firmware or communication protocols, and ignore IoT systems' interactive nature, resulting in limited attack detection capabilities. In this work, we propose <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Iota</small> , a logic programming-based framework to perform system-level security analysis for IoT systems. <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Iota</small> generates attack graphs for IoT systems, showing all of the system resources that can be compromised and enumerating potential attack traces. In building <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Iota</small> , we design novel techniques to scan IoT systems for individual vulnerabilities and further create generic exploit models for IoT vulnerabilities. We also identify and model physical dependencies between different devices as they are unique to IoT systems and are employed by adversaries to launch complicated attacks. In addition, we utilize NLP techniques to extract IoT app semantics based on app descriptions. <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Iota</small> automatically translates vulnerabilities, exploits, and device dependencies to Prolog clauses and invokes MulVAL to construct attack graphs. To evaluate vulnerabilities' system-wide impact, we propose three metrics based on the attack graph, which provide guidance on hardening IoT systems. Evaluation on 127 IoT CVEs (Common Vulnerabilities and Exposures) shows that <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Iota</small> 's exploit modeling module achieves over 80% accuracy in predicting vulnerabilities' preconditions and effects. We apply <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Iota</small> to 37 synthetic smart home IoT systems based on real-world IoT apps and devices. Experimental results show that our framework is effective and highly efficient. Among 27 shortest attack traces revealed by the attack graphs, 62.8% are not anticipated by the system administrator. It only takes 1.2 seconds to generate and analyze the attack graph for an IoT system consisting of 50 devices.

Bousi~Prolog: a Prolog Extension Language for Flexible Query Answering

Abstract In this paper we present the main features and implementation details of a programming language that we call Bousi~Prolog . It can be seen as an extension of Prolog able to deal with similarity-based fuzzy unification (“Bousi” is the Spanish acronym for “fuzzy unification by similarity”). The main goal is the implementation of a declarative programming language well suited for flexible query answering. The operational semantics of Bousi~Prolog is an adaptation of the SLD resolution principle where classical unification has been replaced by an algorithm based on similarity relations defined on a syntactic domain. A similarity relation is an extension of the standard notion of equivalence relation and it can be useful in any context where the concept of equality must be weakened. Hence, the syntax of Bousi~Prolog is an extension of the Prolog's language: in general, a Bousi~Prolog program is a set of Prolog clauses plus a set of similarity equations.

Circuit grammar: knowledge representation for structure and function of electronic circuits

As a step toward the automatic understanding of electronic circuits, we present a logic grammar as a new method of knowledge representation for structure and function of electronic circuits. In this work, we view a circuit as a sentence and its elements as words. Circuit structures are then defined by grammar rules. A set of grammar rules, when converted into Prolog clauses, forms a logic program winch performs top-down parsing. A circuit is designed to perform specific functions to achieve its goal. We see these functions as the meaning of the circuit. This new circuit grammar defines not only the syntactic structures of circuits, but also their relations to the functions. When a given circuit is parsed as a grammatical sentence, not only its syntactic structure but also its functions are derived. A simple English interface generates explanations on the circuit structure and functions.

NED-2: an agent-based decision support system for forest ecosystem management

Decision making for forest ecosystem management can include the use of a wide variety of modeling tools. These tools include vegetation growth models, wildlife models, silvicultural models, GIS, and visualization tools. NED-2 is a robust, intelligent, goal-driven decision support system that integrates tools in each of these categories. NED-2 uses a blackboard architecture and a set of semi-autonomous agents to manage these tools for the user. The blackboard integrates a Microsoft Access database and Prolog clauses, and the agents are implemented in Prolog. A graphical user interface written in Visual C++ provides powerful inventory analysis tools, dialogs for selecting timber, water, ecological, wildlife, and visual goals, and dialogs for defining treatments and building prescriptive management plans. Users can simulate management plans and perform goal analysis on different views of the management unit, where a view is determined by a management plan and a point in time. Prolog agents use growth and yield models to simulate management plans, perform goal analyses on user-specified views of the management unit, display results of plan simulation using GIS tools, and generate hypertext documents containing the results of such analysis. Individual agents use metaknowledge to set up and run external simulation models, to load rule-based models and perform inference, to set up and execute external GIS and visualization systems, and to generate hypertext reports as needed, relieving the user from performing all these tasks.

A prolog constraint handling rules compiler and runtime system

The most recent and advanced implementation of constraint handling rules (CHR) is introduced in a logic programming language. The Prolog implementation consists of a runtime system and a compiler. The runtime system utilizes attributed variables for the realization of the constraint store with efficient retrieval and update mechanisms. Rules describing the interactions between constraints are compiled into Prolog clauses by a compiler, the core of which comprises a small number of compact code generating templates in the form of definite clause grammar rules.

Verification of accuracy of rules in a rule based system

Verification of Rule Based Systems has largely concentrated on checking the consistency, conciseness and completeness of the rulebase. However, the accuracy of rules vis-à-vis the knowledge that they represent, is not addressed, with the result that a large amount of testing has to be done to validate the system. For any reasonably-sized rulebase it becomes difficult to know the adequacy and completeness of the test-cases. In case a particular test-case is omitted the chances of an inaccurate rule remaining undetected increases. We discuss this issue and define a notion of accuracy of rules. We take the view that a rule represents a concept of the domain and in the scenario of Formal Concept Analysis, works on objects and attribute-value space. We then present a mechanism to measure the level of accuracy using the Rough Set Theory. In this framework, accuracy can be computed as a ratio of the objects definitely selected by the rule (the lower approximation) to the objects possibly selected by the rule (the upper approximation) with respect to the concept that it encodes. Our algorithm and its implementation for PROLOG clauses is discussed.

Hardness Results for Learning First-Order Representations and Programming by Demonstration

Learning from “structured examples” is necessary in a number of settings, including inductive logic programming. Here we analyze a simple learning problem in which examples have non-trivial structure: specifically, a learning problem in which concepts are strings over a fixed alphabet, examples are deterministic finite automata (DFAs), and a string represents the set of all DFAs that accept it. We show that solving this “dual” DFA learning problem is hard, under cryptographic assumptions. This result implies the hardness of several other more natural learning problems, including learning the description logic CLASSSIC from subconcepts, and learning arity-two “determinate” function-free Prolog clauses from ground clauses. The result also implies the hardness of two formal problems related to the area of “programming by demonstration”: learning straightline programs over a fixed operator set from input-output pairs, and learning straightline programs from input-output pairs and “partial traces”.

Parallel Evolutionary Computing with the Random PROLOG Processor

The Random PROLOG Processor (RPP) is an abstract model for logical computations based on the concept ofinformation_moleculesquasi-randomly traveling and inferring in abstractcomputational_space. The simulated process or problem is defined in terms of PROLOG clauses (or sets of clauses encapsulated by membranes) seeded into the RPP by the programmer as a program. During the computational process,information_moleculesmove about, rendezvous, exchange internal information, modify themselves, assert otherinformation_molecules(or are retracted), disintegrate, or expire. Computations are unification-based logical inferences. In the RPP, the computations are parallel, randomly evolving processes. The RPP exhibits some properties of the DNA-computer, but can be considered for any computational environment. The RPP is proposed as a promising tool for parallel evolutionary computing, because PROLOG is a widely known, powerful language; because prices of multiprocessor architectures are falling sharply; and because parallel RPP implementation is easy. Since they are declarative and nondeterministic, RPP programs are extremely short. This paper presents the structure of the RPP application for parallel Evolutionary Computations with different types of problems.

Pac-learning non-recursive prolog clauses

Recently there has been an increasing amount of research on learning concepts expressed in subsets of Prolog; the term inductive logic programming (ILP) has been used to describe this growing body of research. This paper seeks to expand the theoretical foundations of ILP by investigating the pac-learnability of logic programs. We focus on programs consisting of a single function-free non-recursive clause, and focus on generalizations of a language known to be pac-learnable: namely, the language of determinate function-free clauses of constant depth. We demonstrate that a number of syntactic generalizations of this language are hard to learn, but that the language can be generalized to clauses of constant locality while still allowing pac-learnability. More specifically, we first show that determinate clauses of log depth are not pac-learnable, regardless of the language used to represent hypotheses. We then investigate the effect of allowing indeterminacy in a clause, and show that clauses with k indeterminate variables are as hard to learn as DNF. We next show that a more restricted language of clauses with bounded indeterminacy is learnable using k-CNF to represent hypotheses, and that restricting the “locality” of a clause to a constant allows pac-learnability even if an arbitrary amount of indeterminacy is allowed. This last result is also shown to be a strict generalization of the previous result for determinate function-free clauses of constant depth. Finally, we present some extensions of these results to logic programs with multiple clauses.

Automata-driven indexing of prolog clauses

Indexing Prolog clauses is an important optimization step that reduces the number of clauses on which unification will be performed and can avoid the pushing of a choice point. It is quite desirable to increase the number of functors used in indexing as this can considerably reduce the size of the filtered set. However, doing so can cause an enormous increase in code size and running time if indexing is done naively. This paper describes new and efficient indexing techniques that utilize all the functors in the clause heads and the goal. The salient feature of these techniques is that the selected clause head unifies (modulo nonlinearity) with the goal. In unification (modulo nonlinearity) all the variables in the terms being unified are assumed to be unique, so the only operation performed is of matching their constant portions. So use of our indexing techniques can result in sharper discrimination, fewer choice points, and reduced backtracking. These techniques have been incorporated into a Prolog compiler and using this compiler the run-time performance of a broad spectrum of Prolog programs has been improved.

A Prolog technology theorem prover: a new exposition and implementation in Prolog

A Prolog technology theorem prover (PTTP) is an extension of Prolog that is complete for the full first-order predicate calculus. It differs from Prolog in its use of unification with the occurs check for soundness, depth-first iterative-deepening search instead of unbounded depth-first search to make the search strategy complete, and the model elimination reduction rule that is added to Prolog inferences to make the inference system complete. This paper describes a new Prolog-based implementation of PTTP. It uses three compile-time transformations to translate formulas into Prolog clauses that directly execute, with the support of a few run-time predicates, the model elimination procedure with depth-first iterative-deepening search and unification with the occurs check. Its high performance exceeds that of Prolog-based PTTP interpreters, and it is more concise and readable than the earlier Lisp-based compiler, which makes it superior for expository purposes. Examples of inputs and outputs of the compile-time transformations provide an easy and precise way to explain how PTTP works. This Prolog-based version makes it easier to incorporate PTTP theorem-proving ideas into Prolog programs. Some suggestions are made on extensions to Prolog that could be used to improve PTTP's performance.

An object-oriented inference engine for PROLOG

This article describes an object-oriented inference engine for PROLOG. The inference engine is part of the Graphically Oriented Development Environment for Logic (Gödel) programming. Gödel incrementally translates source clauses to a persistent clause base in which each clause is an object. The inference engine is a distributed one in which each clause object knows how to unify and execute itself. This means that Gödel supports multiple queries at various points of execution. That is, although multiple queries cannot actually execute concurrently, they can be suspended at any point in their execution and reactivated at any time. This is a major advantage during debugging and exploratory programming. In addition, the inference engine supports primitive clauses written in the implementation language, SMALLTALK-80. This provides a simple interface between PROLOG clauses and SMALLTALK objects that puts the entire SMALLTALK-80 class hierarchy in the hands of PROLOG programmers. Despite these advantages, an object-oriented interface engine has one drawback. In its most general form, the object granularity is too small, so that too many objects must be created and destroyed during program execution. This reduces execution speed. For this reason, several optimizations have been performed in implementation to consolidate objects to a more reasonable size. With these optimizations, Gödel's interpreter has execution speeds that are still significantly slower than compiled PROLOG but acceptable for exploration, development, and debugging. In exchange, this approach provides integration with the object-oriented paradigm, including all the power that comes from object-oriented programming environments, including browsers, incremental translation, inspectors, debuggers, and multiple query execution, as well as the ability to easily experiment with both the environment and the PROLOG language itself.

Static analysis of logic programs for independent and parallelism

This paper presents a general-purpose framework for the abstract interpretation of logic programs and applies it to the problem of automatically extracting independent AND parallelism from PROLOG. In this model of parallelism, goals may be executed concurrently only if they cannot access common variables. We present an abstract domain that captures such variable aliasing information with a high degree of accuracy. We then show how this analysis can be used in the compilation of PROLOG clauses into control statements that schedule goals under independent AND parallelism. Our abstract interpretation framework is novel in that it directly addresses the generally acknowledged problem that naive abstract execution is too ineffecient for a practical compiler. Our solution is to precompute a fixed approximation to the meaning of clauses, a process called condensing, allowing specific calls to be abstractly executed without computation of a fixpoint. We show that condensing does not result in a loss of accuracy if the abstract unification operation satisfies certain algebraic properties. We argue that these properties are important even if a more conventional form of abstract execution is employed.

A join algorithm for combining AND parallel solutions in AND/OR parallel systems

When two or more literals in the body of a Prolog clause are solved in (AND) parallel, their solutions need to bejoined to compute solutions for the clause. This is often a difficult problem in parallel Prolog systems that exploit OR and independent AND parallelism in Prolog programs. In several AND/OR parallel systems proposed recently, this problem is side-stepped at the cost of unexploited OR parallelism in the program, in part due to the complexity of the backtracking algorithm beneath AND parallel branches. In some cases, the data dependency graphs used by these systems cannot represent all the exploitable indenpendent AND parallelism known at compile time.

Transpro: natural language to Prolog translation of genealogy statements in USDVA file manager

The interface between expert knowledge written in natural language and larger hospital information systems is a major challenge in the routine implementation of medical expert systems. Transpro (TRANSlation into PROlog) is an expert system which interfaces USDVA File Manager as the database management system, Prolog as the logic programming language, and Transoft as a natural-language-to-Prolog translator. A genealogy of 200 members of the Habsburg royal family from the tenth through twentieth centuries, entered as structured natural language, is translated into Prolog as a demonstration of the system. Transpro can translate a variety of short medical statements, and return them as Prolog clauses to the hospital information system. Transpro can enhance the physician's ability to review quality assurance monitors in a clinical information system.

Integrating prolog and CADAM to produce an intelligent CAD system

AbstractA discussion is presented of system issues in integrating an artificial intelligence system with a conventional computer‐aided design system. Two different schemes for integration, and experience in implementing a combined VM/PROLOG and CADAM, are described.Both Prolog and CADAM are separately interactively systems, and it was necessary to provide an interactive interface to each, and to be able to move between them. Since CADAM is not reentrant, a coroutining relationship was required. It was necessary to specify a Prolog form for drawings and to be able to transform drawings in the CADAM workspace in Fortran array form into Prolog clauses, representing the same information and residing in the Prolog workspace, and vice versa. The problems of linking to CADAM, and of storage management in a VM virtual machine had to be dealt with. Finally, error recovery had to be considered.Examples of the use of the system are presented, including examples of CAD graphics, and the setting of goals, with the corresponding system responses.The main practical application area was the design and manufacture of assemblies made of sheet metal and extrusions, such as components of aircraft. Several application programs, implemented using the intelligent CAD system, are described.

Metadata-based generation and management of knowledgebases from molecular biological databases

Present-day knowledge-based systems (or expert systems) and databases constitute ‘islands of computing’ with little or no connection to each other. The use of software to provide a communication channel between the two, and to integrate their separate functions, is particularly attractive in certain data-rich domains where there are already pre-existing database systems containing the data required by the relevant knowledge-based system. Our evolving program, GENPRO, provides such a communication channel. The original methodology has been extended to provide interactive Prolog clause input with syntactic and semantic verification. This enables automatic generation of clauses from the source database, together with complete management of subsequent interfacing to the specified knowledge-based system. The particular data-rich domain used in this paper is protein structure, where processes which require reasoning (modelled by knowledge-based systems), such as the inference of protein topology, protein model-building and protein structure prediction, often require large amounts of raw data (i.e., facts about particular proteins) in the form of logic programming ground clauses. These are generated in the proper format by use of the concept of metadata.

A subject bibliography of logic programming applications in control and decision support systems

A bibliography on applications of logic programming in decisions and control is presented. The bibliography contains 330 entries, an authors index, a classification by 18 subjects, and a classification of descriptors. The entire bibliography is created by first downloading the entries from several Dialog files, then transforming the obtained material into a set of Prolog clauses, and, finally, by operating a few second-order Prolog predicates on the aforementioned set.

An effective representation of complex clauses in a relational database

A mechanism for storing and retrieving arbitrary complex PROLOG clauses from a relational database is presented. This mechanism can be used to implement a filter module that sits on top of the database management system (DBMS) and offers clause retrieval functions to the PROLOG interpreter. The filter module accepts arbitrary complex goal literals as input and returns all clauses (potentially) matching the goal. The presented mechanism is able to handle ground and non-ground facts as well as rules. For clause retrieval it derives search predicates from the constants of goal literals as well as multiple occurrences of goal variables. The presented method is flexible enough to support a wide range of filter selectivity, i.e. it can be used to implement highly-selective as well as arbitrary coarse filters. The structures needed to represent clauses in the DBMS are simple: each clause is entirely stored in a single tuple, which also contains all information needed for selection purposes. To retrieve the clauses matching a given goal, one DBMS query operating on a single table is to be executed, independent of the complexity of the stored clauses and the degree of selectivity provided by the filter.

A type driven hardware engine for Prolog clause retrieval over a large knowledge base

Whereas existing Prolog systems are very effective at handling small knowledge bases, they are not very efficient at and often incapable of handling large sets of clauses. Large knowledge bases which may comprise millions of clauses and are shared by a number of users, may need to reside in secondary memory. In such cases exhaustive search is inordinately slow. Various approaches have been put forward for handling the problem, most of which involve coupled systems (loosely or tightly coupled). A Prolog data/knowledge based system which provides an integrated solution to the problem is being developed. An essential element in this system is the CLAuse Retrieval Engine, CLARE, which is a special purpose hardware engine designed to perform selective retrieval of data from disk in order to identify all potential clauses which will be required for full unification during a query. The engine consists of two separate hardware components, which together form a two-stage filtering configuration. This paper concentrates on the second stage filter which is concerned with partial test unification.