Static analysis of a parallel logic language based on the blackboard model

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.     

A parallel logic language for transaction specification in multidatabase systems

The realization of truly heterogeneous database systems is hampered by two principal obstacles. One is the unsuitability of traditional transaction models; this has led to the proposal of a number of new, advanced transaction models. The second is the lack of appropriate programming support for these advanced concepts. This paper addresses these two issues by pointing out the advantages of using a logic-based approach for the integration of autonomous software systems.The work is supported by the Austrian FWF (Fonds zur Förderung der wissenschaftlichen Forschung), project Multidatabase Transaction Processing, contract number P09020-MAT.     

A logic programming language based on the Andorra model

The Andorra model is a parallel execution model of logic programs which exploits the dependent and-parallelism and or-parallelism inherent in logic programming. We present a flat subset of a language based on the Andorra model, henceforth called Andorra Prolog, that is intended to subsume both Prolog and the committed choice languages. Flat Andorra, in addition todon’t know anddon’t care nondeterminism, supports control of or-parallel split, synchronisation on variables, and selection of clauses. We show the operational semantics of the language, and its applicability in the domain of committed choice languages. As an examples of the expressiveness of the language, we describe a method for communication between objects by time-stamped messages, which is suitable for expressing distributed discrete event simulation applications. This method depends critically on the ability to expressdon’t know nondeterminism and thus cannot easily be expressed in a committed choice language.     

: A distributed real-time logic language

This paper presents a new language that integrates the real-time and distributed paradigms within the framework of a concurrent logic language. Concurrent logic languages (CLLs) are capable of expressing concurrence, communication and nondeterminism in a natural way. That is, the intrinsic parallel semantics of the concurrent logic languages makes them well-suited for distributed programming. The proposed language is particularly suitable for loosely coupled systems and it contains mechanisms for distributed and real-time process control. A new execution model for concurrent logic languages is presented, which enables efficient distributed execution and real-time control. The model is introduced by giving an operational semantics for the language and the new model's implementation is discussed, including the definition of a new abstract machine and its implementation on a network of Unix workstations. Although the sequential core is not optimized, some previous results are discussed, showing the feasibility of the language's execution model for distributed real-time systems. The language is currently being used as the kernel language for a distributed simulation and validation tool for communication protocols.     

The BLAZE language: A parallel language for scientific programming

Programming multiprocessor parallel architectures is a complex task. This paper describes a block-structured scientific programming language, BLAZE, designed to simplify this task. BLAZE contains array arithmetic, ‘forall’ loops, and APL-style accumulation operators, which allow natural expression of fine grained parallelism. It also employs an applicative or functional procedure invocation mechanism, which makes it easy for compilers to extract coarse grained parallelism using machine specific program restructuring. Thus BLAZE should allow one to achieve highly parallel execution on multiprocessor architectures, while still providing the user with conceptually sequential control flow.

A central goal in the design of BLAZE is portability across a broad range of parallel architectures. The multiple levels of parallelism present in BLAZE code, in principle, allow a compiler to extract the types of parallelism appropriate for the given architecture, while neglecting the remainder. This paper describes the features of BLAZE, and show how this language would be used in typical scientific programming.     

A parallel logic system on a multicomputer architecture

This paper describes the implementation of a logic programming language on a massively parallel architecture. This implementation is based on the AND/OR Process Model which allows the exploitation of both AND and OR parallelism in logic programs. A distributed memory model is used, and a decentralized control mechanism has been designed. The multicomputer, which the system has been implemented on, consists of a network of Inmos Transputers. The AND/OR processes are implemented as Occam processes mapped onto the Transputer nodes. After the presentation of the system architecture and a deep discussion of the distributed memory management, some preliminary performance results are discussed.     

A framed temporal logic programming language

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.     

A Structured Temporal Logic Language:XYZ/SE

In order to enhance the readability and to simplify the verification of temporal logic programs in the XYZ system,we propose a structured temporal logic language called XYZ/SE,based on XYZ/BE which is the basis language of the XYZ system.A set of proof rules are given and proved to be sound and adequate for proving the partial correctness of XYZ/SE programs in a compositional way.Moreover,we show that every XYZ/BE program can be transformed into an equivalent XYZ/SE program.So we have developed a general conpositional verification method in the XYZ system concerning the sequential case.     

A parallel execution model of logic programs

A parallel-execution model that can concurrently exploit AND and OR parallelism in logic programs is presented. This model employs a combination of techniques in an approach to executing logic problems in parallel, making tradeoffs among number of processes, degree of parallelism, and combination bandwidth. For interpreting a nondeterministic logic program, this model (1) performs frame inheritance for newly created goals, (2) creates data-dependency graphs (DDGs) that represent relationships among the goals, and (3) constructs appropriate process structures based on the DDGs. (1) The use of frame inheritance serves to increase modularity. In contrast to most previous parallel models that have a large single process structure, frame inheritance facilitates the dynamic construction of multiple independent process structures, and thus permits further manipulation of each process structure. (2) The dynamic determination of data dependency serves to reduce computational complexity. In comparison to models that exploit brute-force parallelism and models that have fixed execution sequences, this model can reduce the number of unification and/or merging steps substantially. In comparison to models that exploit only AND parallelism, this model can selectively exploit demand-driven computation, according to the binding of the query and optional annotations. (3) The construction of appropriate process structures serves to reduce communication complexity. Unlike other methods that map DDGs directly onto process structures, this model can significantly reduce the number of data sent to a process and/or the number of communication channels connected to a process     

2DT-FP: A parallel functional programming language on two-dimensional data

We propose a new paradigm for programming multiprocessor systems, 2DT (two-dimensional transformations). 2DT programs are composed of local computations on linear data (columns) and global transformations on 2-dimensional combinations of columns (2D-arrays). Local computations can be expressed in a functional or imperative base language; a typed variant of Backus' FP is chosen for 2DT-FP. The level of abstraction of 2DT makes it suitable for programming a relevant set of algorithms, in general any algorithms, whose data can be easily mapped to 2-dimensional representations. A set of examples tries to prove this claim. An interleaving semantics for 2DT-FP is given, exposing the potential for parallel execution of 2DT-FP programs. The claim is proved that any sequential and thus any parallel execution will deliver the same result. The implementation realized on the Intel Hypercube is described. Supported by the Deutsche Forschungsgemeinschaft, DFG     

A requirements modeling language and its logic

This paper describes some aspects of a Requirements Modeling Language (RML) which can be used in the initial phases of software development. RML is based on the idea that a requirements specification should embody a conceptual world model and that the language for expressing it should provide facilities for organizing and abstracting details, yet at the same time have qualities such as precision, consistency and clarity.RML has a number of novel features including assertion classes, the treatment of time and various abbreviation techniques, all integrated into one uniform object-oriented framework. The precise semantics of these and other features are provided in this paper by relating RML to a logic involving time. This demonstrates that a language can offer highly structured and convenient mechanisms for requirements specifications while having solid mathematical underpinnings.     

基于平行语料库的双语协同中文关系抽取

针对在中文资源的关系抽取中,由于中文长句句式复杂,句法特征提取难度大、准确度低等问题,提出了一种基于平行语料库的双语协同中文关系抽取方法。首先在中英双语平行语料库中的英文语料上利用英文成熟的句法分析工具,将得到依存句法特征用于英文关系抽取分类器的训练,然后与利用适合中文的n-gram特征在中文语料上训练的中文关系抽取分类器构成双语视图,最后再依靠标注映射后的平行语料库,将彼此高可靠性的语料加入对方训练语料进行双语协同训练,最终得到一个性能更好的中文关系抽取分类模型。通过对中文测试语料进行实验,结果表明该方法提高了基于弱监督方法的中文关系抽取性能,其F值提高了3.9个百分点。     

Adaptive parallel logic networks

This paper presents a novel class of special purpose processors referred to as ASOCS (adaptive self-organizing concurrent systems). Intended applications include adaptive logic devices, robotics, process control, system malfunction management, and in general, applications of logic reasoning. ASOCS combines massive parallelism with self-organization to attain a distributed mechanism for adaptation. The ASOCS approach is based on an adaptive network composed of many simple computing elements (nodes) which operate in a combinational and asynchronous fashion. Problem specification (programming) is obtained by presenting to the system if-then rules expressed as Boolean conjunctions. New rules are added incrementally. In the current model, when conflicts occur, precedence is given to the most recent inputs. With each rule, desired network response is simply presented to the system, following which the network adjusts itself to maintain consistency and parsimony of representation. Data processing and adaptation form two separate phases of operation. During processing, the network acts as a parallel hardware circuit. Control of the adaptive process is distributed among the network nodes and efficiently exploits parallelism.     

Consul: a parallel constraint language

The author describes a constraint-based language, Consul, that can exploit implicit parallelism. The results are reported of the first stage of the Consul project, which was designed to produce empirical evidence for or against Consul as a parallel language. To produce the evidence, a parallel-execution model is developed that is based on local propagation and uses some important generalizations of earlier work on local propagation. A set of tools was developed to measure the execution of several Consul programs. The results suggest that considerable parallelism is available in Consul programs and that local propagation is a viable mechanism for solving most real-world constraints. The Consul programs demonstrate that programmers can control performance through the proper choice of algorithms, despite Consul's declarative nature     

A parallel implementation of the SCAN language

SCAN is a special purpose context-free language which describes and generates a wide range of array accessing algorithms from a short set of simple ones. These algorithms may represent scan techniques for image processing, but at the same time they stand as generic data accessing strategies. In this paper we present two schemes (one sequential and one parallel) which implement the SCAN language and compare their memory requirements and execution time.     

Multi-layer logic — A predicate logic including data structure as knowledge representation language

A new generation computer is expected to be the knowledge processing system of the future. However, many aspects are yet unknown regarding this technology, and a number of fundamental concepts, directly concerning knowledge processing system design need investigation, such as knowledge, data, inference, communication, information management, learning, and human interface. These concepts are closely related to knowledge representation. In particular, methodology to materialize such concepts as above in computers are completely dependent upon them. Thus, knowledge representation is a key concept in the design of knowledge processing systems and, consequently, of new generation computer systems. Knowledge representation design is a very important task affecting the performance of new generation computer systems to be developed. We should first investigate the requirements for precise knowledge representation, considering its effects on system performance, then design knowledge representations to satisfy these requirements. This paper discusses (1) a new style of information processing, (2) requirements for knowledge representation and (3) a knowledge representation satisfying these requirements, a knowledge processing system designed on this basis and a new style of problem solving using this system.     

互斥关系模式挖掘算法研究

序列模式挖掘是数据挖掘的一个重要领域,结构关系模式挖掘是在序列模式挖掘基础上提出的一种新的挖掘任务.重点对结构关系模式的一个重要分支--互斥关系模式进行了研究,在给出与互斥关系模式相关概念的基础上讨论了互斥关系模式挖掘的两种算法,即基本检测法和分类检测法.实验结果表明,两种算法都是有效的,在序列模式数量很大时,分类检测法的挖掘效率高于基本检测法.结构关系模式挖掘和序列模式挖掘一样在实际应用中有着重要的价值,一些在序列模式挖掘过程中不能发现的隐藏模式将在结构关系模式中被发现,互斥关系模式的研究将进一步为结构关系模式挖掘理论的完善提供支持.