共查询到20条相似文献,搜索用时 15 毫秒
1.
Zhen-HuaDuan MaciejKoutny 《计算机科学技术学报》2004,19(3):0-0
We discuss the projection temporal logic (PTL), based on a primitive projection operator, prj. A framing technique is also presented, using which a synchronization operator, await, is defined within the underlying logic. A framed temporal logic programming language (FTLL) is presented. To illustrate how to use both the language and framing technique, some examples are given. 相似文献
2.
3.
4.
5.
Xiaoxiao YANG ;Yu ZHANG ;Ming FU ;Xinyu FENG 《Frontiers of Computer Science in China》2014,(6):958-976
Atomic blocks, a high-level language construct that allows programmers to explicitly specify the atomicity of operations without worrying about the implementations, are a promising approach that simplifies concurrent programming. On the other hand, temporal logic is a successful model in logic programming and concurrency verification, but none of existing temporal programming models supports concurrent programming with atomic blocks yet. In this paper, we propose a temporal programming model (αPTL) which extends the projection temporal logic (PTL) to support concurrent programming with atomic blocks. The novel construct that formulates atomic execution of code blocks, which we call atomic interval formulas, is always interpreted over two consecutive states, with the internal states of the block being abstracted away. We show that the framing mechanism in projection temporal logic also works in the new model, which consequently supports our development of an executive language. The language supports concurrency by introducing a loose interleaving semantics which tracks only the mutual exclusion between atomic blocks. We demonstrate the usage of αPTL by modeling and verifying both the fine-grained and coarse-grained concurrency. 相似文献
6.
Atomic blocks, a high-level language construct that allows programmers to explicitly specify the atomicity of operations without worrying about the implementations, are a promising approach that simplifies concurrent programming. On the other hand, temporal logic is a successful model in logic programming and concurrency verification, but none of existing temporal programming models supports concurrent programming with atomic blocks yet. In this paper, we propose a temporal programming model (αPTL) which extends the projection temporal logic (PTL) to support concurrent programming with atomic blocks. The novel construct that formulates atomic execution of code blocks, which we call atomic interval formulas, is always interpreted over two consecutive states, with the internal states of the block being abstracted away. We show that the framing mechanism in projection temporal logic also works in the new model, which consequently supports our development of an executive language. The language supports concurrency by introducing a loose interleaving semantics which tracks only the mutual exclusion between atomic blocks. We demonstrate the usage of αPTL by modeling and verifying both the fine-grained and coarse-grained concurrency. 相似文献
7.
LMNtal (pronounced “elemental”) is a simple language model based on hierarchical graph rewriting that uses logical variables to represent connectivity and membranes to represent hierarchy. LMNtal is an outcome of the attempt to unify constraint-based concurrency and Constraint Handling Rules (CHR), the two notable extensions to concurrent logic programming. LMNtal is intended to be a substrate language of various computational models, especially those addressing concurrency, mobility and multiset rewriting. Although the principal objective of LMNtal was to provide a unifying computational model, it is of interest to equip the formalism with a precise logical interpretation. In this paper, we show that it is possible to give LMNtal a simple logical interpretation based on intuitionistic linear logic and a flattening technique. This enables us to call LMNtal a hierarchical, concurrent linear logic language. 相似文献
8.
Michael A. Covington 《Applied Artificial Intelligence》2013,27(3):219-234
This article presents a representation for natural language plurals in knowledge base queries, implementing collective, distributive, cumulative, and multiply distributive senses of the plural by means of higher predicates. The underlying semantics is based on Franconi's theory of collections. The collective reading of a plural applies the predicate to the whole collection; the distributive reading applies the predicate to all of the elements; and the cumulative reading says that each element either satisfies the predicate or belongs to some collection that does so. Implicit in the cumulative reading is the notion of element-property, the property of belonging to some collection that satisfies a given predicate. Another reading of the plural, here termed the multiply distributive, requires a straightforward extension of the system to allow simultaneous distribution over more than one variable at a time, with none of the distributions having scope over any other. Simultaneous distribution is implemented as a metalogical predicate that transforms queries before executing them. 相似文献
9.
H. A. Blair V. W. Marek J. B. Remmel 《Annals of Mathematics and Artificial Intelligence》2008,52(1):81-105
In a previous paper (Blair et al. 2001), the authors showed that the mechanism underlying Logic Programming can be extended to handle the situation where the atoms
are interpreted as subsets of a given space X. The view of a logic program as a one-step consequence operator along with the concepts of supported and stable model can
be transferred to such situations. In this paper, we show that we can further extend this paradigm by creating a new one-step
consequence operator by composing the old one-step consequence operator with a monotonic idempotent operator (miop) in the
space of all subsets of X, 2
X
. We call this extension set based logic programming. We show that such a set based formalism for logic programming naturally supports a variety of options. For example, if the
underlying space has a topology, one can insist that the new one-step consequence operator always produces a closed set or
always produces an open set. The flexibility inherent in the semantics of set based logic programs is due to both the range
of natural choices available for specifying the semantics of negation, as well as the role of monotonic idempotent operators
(miops) as parameters in the semantics. This leads to a natural type of polymorphism for logic programming, i.e. the same
logic program can produce a variety of outcomes depending on the miop associated with the semantics. We develop a general
framework for set based programming involving miops. Among the applications, we obtain integer-based representations of real
continuous functions as stable models of a set based logic program.
相似文献
10.
Shared Prolog is a parallel logic language based on the blackboard interpretation of logic programming. In such an interpretation a logic program is seen as a set of rules executed by a set of agents cooperating via a shared working memory called the blackboard. A distributed interpreter for Shared Prolog was implemented and described in another paper, where the blackboard was a centralized data structure. In this paper we show how the blackboard can be distributed using some static analysis techniques. The basic idea is to perform an abstract interpretation starting from the Shared Prolog operational semantics to generate data structures which represent possible interactions and links among agents. The resulting data structures are used to reduce the number of run time communication operations in an implementation distributed over a network of workstations. 相似文献
11.
12.
Yen-Tseng Hsu Chien-Ming Chen 《Fuzzy Systems, IEEE Transactions on》2000,8(2):155-170
For the consideration of different application systems, modeling the fuzzy logic rule, and deciding the shape of membership functions are very critical issues due to they play key roles in the design of fuzzy logic control system. This paper proposes a novel design methodology of fuzzy logic control system using the neural network and fault-tolerant approaches. The connectionist architecture with the learning capability of neural network and N-version programming development of a fault-tolerant technique are implemented in the proposed fuzzy logic control system. In other words, this research involves the modeling of parameterized membership functions and the partition of fuzzy linguistic variables using neural networks trained by the unsupervised learning algorithms. Based on the self-organizing algorithm, the membership function and partition of fuzzy class are not only derived automatically, but also the preconditions of fuzzy IF-THEN rules are organized. We also provide two examples, pattern recognition and tendency prediction, to demonstrate that the proposed system has a higher computational performance and its parallel architecture supports noise-tolerant capability. This generalized scheme is very satisfactory for pattern recognition and tendency prediction problems 相似文献
13.
Advances in robotics has led to the cooperation of multiple robots among themselves and with their industrial automation environment. Efficient interaction with industrial robots thus becomes one of the key factors in the successful utilization of this modern equipment. When multiple manipulators have to be coordinated, there is a need for a new programming approach that facilitates and encompasses the needs of concurrency, synchronization, timing, and communication. Most robot languages have been developed with little attention being given to the integration of the robot with its environment. Currently, there is a gap between the robot capabilities, the task definition environment, and language facilities supplied to use robots.This paper analyzes the needs and then establishes that a concurrent logic programming approach is a step towards achieving a multi-robot knowledgeable task programming. In particular, the FCP dialect of concurrent Prolog is demonstrated, and analyzed.This research is partially supported by the Paul Ivanier Center for research in robots and production management. 相似文献
14.
This paper proposes a sequential model of bargaining specifying reasoning processes of an agent behind bargaining procedures. We encode agents’ background knowledge, demands, and bargaining constraints in logic programs and represent bargaining outcomes in answer sets. We assume that in each bargaining situation, each agent has a set of goals to achieve, which are normally unachievable without an agreement among all the agents who are involved in the bargaining. Through an alternating-offers procedure, an agreement among bargaining agents may be reached by abductive reasoning. We show that the procedure converges to a Nash equilibrium if each agent makes rational offers/counteroffers in each round. In addition, the sequential model also has a number of desirable properties, such as mutual commitments, individual rationality, satisfactoriness, and honesty. 相似文献
15.
The development of types is an important but challenging issue in temporal logic programming. In this paper, we investigate how to formalize and implement types in the temporal logic programming language MSVL, which is an executable subset of projection temporal logic (PTL). Specifically, we extendMSVL with a few groups of types including basic data types, pointer types and struct types. On each type, we specify the domain of values and define some standard operations in terms of logic functions and predicates. Then, it is feasible to formalize statements of type declaration of program variables and statements of struct definitions as logic formulas. As the implementation of the theory, we extend theMSV toolkit with the support of modeling, simulation and verification of typedMSVL programs. Applications to the construction of AVL tree and ordered list show the practicality of the language. 相似文献
16.
《The Journal of Logic Programming》1986,3(3):185-215
An elaboration of the PROLOG language is described in which the notion of first-order term is replaced by a more general one. This extended form of terms allows the integration of inheritance—an IS-A taxonomy—directly into the unification process rather than indirectly through the resolution-based inference mechanism of PROLOG. This results in more efficient computations and enhanced language expressiveness. The language thus obtained, called LOGIN, subsumes PROLOG, in the sense that conventional PROLOG programs are equally well executed by LOGIN. 相似文献
17.
This paper presents a parallel logic programming language named P-Prolog which is being developed as a logic programming language featuring both and- and or-parallelism. Compared with the other parallel logic programming languages, syntactic constructs such as read-only annotation,6) mode declaration2) and communication constraints7) are not used in P-Prolog. A new concept introduced in P-Prolog is the exclusive relation of guarded Horn clauses. Advances included in P-prolog. are:
- The synchronization mechanism can determine the direction of data flow dynamically.
- Guarded Horn clauses can be interpreted as eitherdon’t care nondeterminism ordon’t know non-determinism.
18.
Y. J. Jiang 《New Generation Computing》1990,8(1):33-59
If we view an ordinary logic program as a set of beliefs of animplicit agent about a world, then acompletely epistemic logical view of logic programming would yield a further extension that allows us to reasonexplicitly about beliefs and non-beliefs of any agents. In particular, such a view will accommodate nested beliefs, introspective reasoning of self-beliefs and meta-reasoning of others’ beliefs. In this paper, we present the logical foundation of such a view by developing acomputational logic ofquantified epistemic notions. The semantics of the logic is an extension of Kripke’spossible-worlds semantics with variable domains to capture theintensional imputation problem in epistemic notions. A syntactical characterization of this semantics is developed to yield a clausal form of the logic. An efficient resolution mechanisation of this form is described. It is achieved by augmenting Konolige’sB-resolution with a semi-set-of-support strategy with linear resolution. Further refinements on a Horn clausal form of the logic with negation as failure are also discussed. 相似文献
19.
We present a programming language for robots which we have implemented based on the Ada language. It is an interpreted language which permits dynamic configuration of software. It manipulates Ada tasks and subroutines. One of the Ada tasks is an inference engine of a logic programming language adapted to real-time constraints. We show how the conjunction of Ada tasks, to perform perception and action functions on the robot, to logic programs, for the control of these tasks, both manipulated by the IAda language, gives a powerful environment for robot programming. 相似文献
20.
A logical system of inference rules intended to give the foundation of logic programs is presented. The distinguished point of the approach taken here is the application of the theory of inductive definitions, which allows us to uniformly treat various kinds of induction schema and also allows us to regardnegation as failure as a kind of induction schema. This approach corresponds to the so-called least fixpoint semantics. Moreover, in our formalism, logic programs are extended so that a condition of a clause may be any first-order formula. This makes it possible to write a quantified specification as a logic program. It also makes the class of induction schemata much larger to include the usual course-of-values inductions. 相似文献