Reputation-based decisions for logic-based cognitive agents

Computational trust and reputation models have been recognized as one of the key technologies required to design and implement agent systems. These models manage and aggregate the information needed by agents to efficiently perform partner selection in uncertain situations. For simple applications, a game theoretical approach similar to that used in most models can suffice. However, if we want to undertake problems found in socially complex virtual societies, we need more sophisticated trust and reputation systems. In this context, reputation-based decisions that agents make take on special relevance and can be as important as the reputation model itself. In this paper, we propose a possible integration of a cognitive reputation model, Repage, into a cognitive BDI agent. First, we specify a belief logic capable to capture the semantics of Repage information, which encodes probabilities. This logic is defined by means of a two first-order languages hierarchy, allowing the specification of axioms as first-order theories. The belief logic integrates the information coming from Repage in terms if image and reputation, and combines them, defining a typology of agents depending of such combination. We use this logic to build a complete graded BDI model specified as a multi-context system where beliefs, desires, intentions and plans interact among each other to perform a BDI reasoning. We conclude the paper with an example and a related work section that compares our approach with current state-of-the-art models.     

A logic-based environment for reactive agents in intelligent CAD systems

This paper is an evolution of a previous article by the authors[1] (Bento, J. P., Feijó, B., Lloyd-Smith, D., Computers and Structures, 1977, 63(5), 1015–1032) motivated by the need to provide computational support to an agent-based implementation of design processes. It presents a new programming environment to support the development of CAD systems based on a hybrid agent architecture in which the symbolic reasoning is carried out by first-order logic. The reactive behaviour of the agents can be achieved through a number of characteristics proposed for the object-oriented environment. This environment is also a general proposal for representing engineering design knowledge in which logic is integrated into an object-oriented paradigm. © 1998 Published by Elsevier Science Limited. All rights reserved.     

Fuzzy logic-based forecasting model

In this paper a fuzzy logic-based software tool, fuzzy logic advisory tool (FLAT), for demand forecasting of signal transmission products is presented. The FLAT was developed for the prediction of demand of about 1000 different products in order to aid materials purchasing process of about 14,000 different components in the electronics manufacturing processes of Nokia Network Systems's Haukipudas factory. The prediction values of different products are inferred by starting from a set of eight input values. Each input value is fuzzied by the FLAT. Thereafter, fuzzy results are inferred in three sequential phases. In each phase the number of variables is split due to hierarchical structure of the inference module. A data base and a rule base are divided accordingly into three hierarchical levels. Rules are represented by linguistic relations changed into matrix equations form in order to apply linguistic equations framework technique (LE). Fuzzy membership functions for input values are determined on-line from earlier input values of the products. Fuzzy rules were inferred by analyzing behavior of the products together with market experts and product experts of the company. The model is able to produce more accurate decision-making support than more traditional approaches. This is probably due to the model-based approach and systematic data management.     

A logic-based transformation system

In spite of advances in various transformation systems the transformation of a nonmonotonic-logic-based requirements specification into a procedural (imperative) language program has not been investigated. This paper presents a logic-based transformation system that can transform a nonmonotonic-logic-based specification, the Frame-and-Rule Oriented Requirement Specification Language (FRORL), into procedural language programs. We discuss how to handle nonmonotonic inheritance in FRORL and then establish a matrix-based data flow and dependency analysis mechanism to find all the possible data transformation paths in a logic-based specification. Using a newly developed algorithm, we can adjust the execution sequence of a logic-based specification so that the functions included in the logic-based specification can be represented by a sequential procedural language program     

Hoare logic-based genetic programming

Almost all existing genetic programming systems deal with fitness evaluation solely by testing. In this paper, by contrast, we present an original approach that combines genetic programming with Hoare logic with the aid of model checking and finite state automata, henceby proposing a brand new verification-focused formal genetic programming system that makes it possible to evolve reliable programs with mathematically-verified properties.     

Non-determinism in logic-based languages

The use of non-determinism in logic-based languages is motivated using pragmatic and theoretical considerations. Non-deterministic database queries and updates occur naturally, and there exist non-deterministic implementations of various languages. It is shown that non-determinism resolves some difficulties concerning the expressive power of deterministic languages: there are non-deterministic languages expressing low complexity classes of queries/updates, whereas no such deterministic languages are known. Various mechanisms yielding non-determinism are reviewed. The focus is on two closely related families of non-deterministic languages. The first consists of extensions of Datalog with negations in bodies and/or heads of rules, with non-deterministic fixpoint semantics. The second consists of non-deterministic extensions of first-order logic and fixpoint logics, using thewitness operator. The expressive power of the languages is characterized. In particular, languages expressing exactly the (deterministic and non-deterministic) queries/updates computable in polynomial time are exhibited, whereas it is conjectured that no analogous deterministic language exists. The connection between non-deterministic languages and determinism is also explored. Several problems of practical interest are examined, such as checking (statically or dynamically) if a given program is deterministic, detecting coincidence of deterministic and non-deterministic semantics, and verifying termination for non-deterministic programs.Work supported by the Projet de Recherche Coordonnée BD3.Work supported in part by the National Science Foundation under grants IRI-8816078 and INT-8817874. The work was done in part while the author was visiting INRIA.     

A logic-based calculus of events

We outline an approach for reasoning about events and time within a logic programming framework. The notion of event is taken to be more primitive than that of time and both are represented explicitly by means of Horn clauses augmented with negation by failure. The main intended applications are the updating of databases and narrative understanding. In contrast with conventional databases which assume that updates are made in the same order as the corresponding events occur in the real world, the explicit treatment of events allows us to deal with updates which provide new information about the past. Default reasoning on the basis of incomplete information is obtained as a consequence of using negation by failure. Default conclusions are automatically withdrawn if the addition of new information renders them inconsistent. Because events are differentiated from times, we can represent events with unknown times, as well as events which are partially ordered and concurrent.     

Sensitivity analysis in logic-based models

An important feature of the causal models used in most DSS is that they allow their users to perform sensitivity analyses. Most of these analyses are performed on continuous variables, which are the principal types of variables found in causal models. However, some of the models derived from artificial intelligence that are increasingly being used in DSS contain logic (or Boolean) variables. In this paper we exploit the notion of a ‘Boolean derivative’ developed for circuit design and apply it to the calculation of sensitivity measures in logic-based models.     

Fuzzy logic-based induction motor protection system

The protection is very important to detect abnormal motor running conditions such as over current, over voltage, overload, over temperature, and so on. When a failure is sensed by the protection system, a time delay should be specified to trip the motor. In the classical systems, motors are stopped with the time delay, which is adjusted constantly without considering the fault level. This paper presents a fuzzy logic-based protection system covering six different fault parameters for induction motors. This paper focuses on a new time-delay calculation for stopping induction motor and improves the overall detection performance. The time delay is computed by fuzzy logic method according to various fault parameters when one of the failures occurs on the motor. This system is successfully tested in real-time faults on the motor, and it shows that it provides sensitive protection by fuzzy rules.     

A logic-based information modelling language

A user-friendly language INFOMOD, intended for information modelling and information systems specification, is described. The language, based on predicate logic, fulfills the role of an implementation-independent Conceptual Schema Language. Both static and dynamic aspects of information systems are specifiable in the language. The language has been in practical use for three years, and has been found suitable for many different kinds of systems, such as conventional database systems, computer-aided manufacturing systems, special purpose information systems, and some expert systems.     

Temporal logic-based deadlock analysis for Ada

A temporal logic-based specification language and deadlock analyzer for Ada is described. The deadlock analyzer is intended for use within Timebench, a concurrent system-design environment with support for Ada. The specification language, COL, uses linear-time temporal logic to provide a formal basis for axiomatic reasoning. The deadlock analysis tool uses the reasoning power of COL to demonstrate that Ada designs specified in COL are systemwide deadlock-free: in essence, it uses a specialized theorem prover to deduce the absence of deadlock. The deadlock algorithm is shown to be decidable for finite systems and acceptable otherwise. It is also shown to have a worst-case computational complexity that is exponential with the number of tasks. The analyzer has been implemented in Prolog. Numerous examples are evaluated using the analyzer, including readers and writers, gas station, five dining philosophers, and a layered communications system. The results indicate that analysis time is reasonable for moderate designs in spite of the worst-case complexity of the algorithm     

Fuzzy logic-based optimization for redundant manipulators

Redundant manipulators have more degrees of freedom (DOF) than the DOF of the task space. This implies that the number of joint position variables is greater than the number of variables specifying the task. The problem of solving the kinematic equations for the joint variables is underspecified unless additional equations/constraints are introduced to obtain a well-posed problem. A dynamic level redundancy resolution is proposed. The joint space model is transformed to a reduced-order model in the pseudovelocity space. The elements of the foregoing transformation matrix indirectly determine the contribution of each joint to the total motion. These elements are selected using two fuzzy logic-based methods so as to minimize the instantaneous manipulator power: (1) in the velocity method, a space vector in the velocity relationship between the two spaces is determined by imposing a constraint on the continuity of the joint velocities at the time instant when the elements of the transformation matrix experience a discontinuity and (2) in the torque method, an alternative approach introduced to reduce the computational complexity, the changes in the transformation matrix are made continuous with respect to time by the appropriate choice of a space vector in the joint torque expression. Simulations are given.     

Adaptive disturbance attenuation via logic-based switching

The problem of attenuating unknown and possibly time-varying disturbances acting on a linear time-invariant dynamical system is addressed by means of an adaptive switching control approach. Given a family of pre-designed stabilizing controllers, a supervisory unit infers in real-time the potential behavior of each candidate controller and selects the one providing the best potential performance. To this aim, a set of test functionals is defined, which is shown to enjoy favorable inference properties under certain assumptions on the nature of the disturbances. Both persistent-memory and finite-memory test functionals are analyzed. Further, an implementation of the switching controller is proposed which always guarantees stability of the feedback loop, even if the disturbance characteristics are such that the switching is persistent. Simulation results are provided to show the effectiveness of the proposed method.     

Finite-tree analysis for constraint logic-based languages

Logic languages based on the theory of rational, possibly infinite, trees have much appeal in that rational trees allow for faster unification (due to the safe omission of the occurs-check) and increased expressivity (cyclic terms can provide very efficient representations of grammars and other useful objects). Unfortunately, the use of infinite rational trees has problems. For instance, many of the built-in and library predicates are ill-defined for such trees and need to be supplemented by run-time checks whose cost may be significant. Moreover, some widely used program analysis and manipulation techniques are correct only for those parts of programs working over finite trees. It is thus important to obtain, automatically, a knowledge of the program variables (the finite variables) that, at the program points of interest, will always be bound to finite terms. For these reasons, we propose here a new data-flow analysis, based on abstract interpretation, that captures such information. We present a parametric domain where a simple component for recording finite variables is coupled, in the style of the open product construction of Cortesi et al., with a generic domain (the parameter of the construction) providing sharing information. The sharing domain is abstractly specified so as to guarantee the correctness of the combined domain and the generality of the approach. This finite-tree analysis domain is further enhanced by coupling it with a domain of Boolean functions, called finite-tree dependencies, that precisely captures how the finiteness of some variables influences the finiteness of other variables. We also summarize our experimental results showing how finite-tree analysis, enhanced with finite-tree dependencies, is a practical means of obtaining precise finiteness information.     

A logic-based axiomatic model of bargaining

This paper introduces an axiomatic model for bargaining analysis. We describe a bargaining situation in propositional logic and represent bargainers' preferences in total pre-orders. Based on the concept of minimal simultaneous concessions, we propose a solution to n-person bargaining problems and prove that the solution is uniquely characterized by five logical axioms: Consistency, Comprehensiveness, Collective rationality, Disagreement, and Contraction independence. This framework provides a naive solution to multi-person, multi-issue bargaining problems in discrete domains. Although the solution is purely qualitative, it can also be applied to continuous bargaining problems through a procedure of discretization, in which case the solution coincides with the Kalai–Smorodinsky solution.