Style Of Semantics Research Articles

A semantic style driving method for products’ appearance design

Considering that industrial design (ID) processes are full of fuzzy, uncertain, dynamic and changing information, the traditional computer aided methods cannot work well. Based on ID, fuzzy theory, and aesthetics principles, the authors discuss the idea of driving the design process by semantics words. In the process, they attain customers’ performance in term of semantics words, built some fuzzy evaluation models covering shape and color aesthetics rules, and associated aesthetics rules, to analysis the products’ appearance design style. Semantic words drive the design process and carry through the whole process to reinforce the design objective. In the paper, the authors place emphasis on how to formalize products’ shape features and how to process semantic words; also, they discuss the whole design process by the designed style driving method. The method has already been implemented in a machine tools CAID software system.

Technical Aspects of the Digital Library of Mathematical Functions

The NIST Digital Library of Mathematical Functions (DLMF) Project, begun in 1997, is preparing a handbook and Web site intended for wide communities of users. The contents are primarily mathematical formulas, graphs, methods of computation, references, and links to software. The task of developing a Web handbook of this nature presents several technical challenges. We describe the goals of the Digital Library of Mathematical Functions Project and the realities that constrain those goals. We propose practical initial solutions, in order to ease the authoring of adaptable content: a LaTeX class which encourages a modestly semantic markup style; and a mathematical search engine that adapts a text search engine to the task.

The programming model of ASSIST, an environment for parallel and distributed portable applications

A software development system based upon integrated skeleton technology (ASSIST) is a proposal of a new programming environment oriented to the development of parallel and distributed high-performance applications according to a unified approach. The main goals are: high-level programmability and software productivity for complex multidisciplinary applications, including data-intensive and interactive software; performance portability across different platforms, in particular large-scale platforms and grids; effective reuse of parallel software; efficient evolution of applications through versions that scale according to the underlying technologies. The purpose of this paper is to show the principles of the proposed approach in terms of the programming model (successive papers will deal with the environment implementation and with performance evaluation). The features and the characteristics of the ASSIST programming model are described according to an operational semantics style and using examples to drive the presentation, to show the expressive power and to discuss the research issues. According to our previous experience in structured parallel programming, in ASSIST we wish to overcome some limitations of the classical skeletons approach to improve generality and flexibility, expressive power and efficiency for irregular, dynamic and interactive applications, as well as for complex combinations of task and data parallelism. A new paradigm, called “parallel module” ( parmod), is defined which, in addition to expressing the semantics of several skeletons as particular cases, is able to express more general parallel and distributed program structures, including both data-flow and nondeterministic reactive computations. ASSIST allows the programmer to design the applications in the form of generic graphs of parallel components. Another distinguishing feature is that ASSIST modules are able to utilize external objects, including shared data structures and abstract objects (e.g. CORBA), with standard interfacing mechanisms. In turn, an ASSIST application can be reused and exported as a component for other applications, possibly expressed in different formalisms.

Agent cooperation based control integration by activity-sharing and joint intention

In this paper, a control integration method based on agent cooperation, called ASOJI, is proposed, which designs the architecture of integrated application systems in distributed computation environments as an agent community composed of nested agent federations in three aspects: architecture style, agent cooperation, and composition semantics. Through defining activity-sharing-oriented joint intention in the way of stepwise refinement, ASOJI can not only support the transparent specification of the architecture for software composition, but also eliminate the gap between agent theory and the engineering realization of control integration.

Resource traces: a domain for processes sharing exclusive resources

The domain of partially terminated finite and infinite words is commonly used to give denotational semantics for process algebras such as CSP. In this well-known framework the denotational semantics of concurrency is derived via power-domains from that of non-deterministic choice and interleaving to the effect that the denotational semantics of a concurrent process is equal to the set of all its possible finite and infinite sequential behaviours. In this paper, we define a more versatile domain of the so-called finite and infinite resource traces which allows to capture the concurrent behaviour of a process and encode the static concurrency of a system directly into the domains definition. The approach we present refines the previous work of Diekert and Gastin (Lecture Notes in Computer Science, vol. 944, Springer, Berlin, pp. 15–26) on α- and δ-traces. We start with an alphabet of atomic actions, a set of resources, and a resource map assigning to each action the non-empty subset of resources it uses. Actions that do not share common resources are called independent and considered to be able to execute concurrently. A partially terminated concurrent process is specified by a resource trace which consists of two components: an already observed part represented as an action-labeled partial order (Mazurkiewicz trace), and a guard set containing the resources granted to the process for its further development. A process concatenation is then defined, which allows independent actions to execute concurrently. Specification refinement leads to a natural approximation ordering between processes. It confers to the set of all processes the structure of a coherently complete prime algebraic Scott domain, whereby, process concatenation is Scott-continuous in both arguments. Furthermore, we define a natural ultrametric on processes based on prefix information. The induced topology is shown to be equivalent to the compact Lawson topology induced by the approximation ordering. Process concatenation is moreover shown to be uniformly continuous with respect to the defined ultrametric. The mathematical theory we develop thus extends the central order and metric properties of the domain of partially terminated finite and infinite words which are needed in order to devise truly concurrent semantics for process algebras much in the style of classical CSP semantics.

Provability logics with quantifiers on proofs

We study here extensions of the Artemov's logic of proofs in the language with quantifiers on proof variables. Since the provability operator □ A could be expressed in this language by the formula ∃u[u]A, the corresponding logic naturally extends the well-known modal provability logic GL. Besides, the presence of quantifiers on proofs allows us to study some properties of provability not covered by the propositional logics. In this paper we study the arithmetical complexity of the provability logic with quantifiers on proofs q LP K (T) for a given arithmetical theory T and a class K of proof predicates. In the last section we define Kripke style semantics for the logics corresponding to the standard Gödel proof predicate and its multiple conclusion version.

Modularity in Meta-Languages

A meta-language for semantics has a high degree of modularity<br />when descriptions of individual language constructs can be formulated independently using it, and do not require reformulation when new constructs are added to the described language. The quest for modularity in semantic meta-languages has been going on for more than two decades. Here, most of the main meta-languages for operational, denotational, and hybrid styles of semantics are compared regarding their modularity. A simple bench-mark is used: describing the semantics of a pure functional language, then extending the described language with references, exceptions, and concurrency constructs. For each style of semantics, at least one of the considered meta-languages appears to provide a high degree of modularity.

Kaynak Keşif Yeteneğinin Artırılması için İnternet Kaynaklarının İçeriklerinin Standart Biçimde Tanımlanması

İnternet kaynaklarının makinaca anlaşılabilir olmamasından dolayı, kullanıcıların bilgi ihtiyacını karşılamada sorunlar yaşanmaktadır. Kaynakların yapısal olarak gösterilmemesi ve nasıl yorumlanması ge­rektiğinin ilgili kaynağa özgün çözümlerle hal/edilmeye çalışılması, ilk göze çarpan nedenleri oluşturmaktadır. lnternet kaynaklarının gerek sa­yısal ve gerekse de hacimsel olarak çok hızlı artışı göz önünde bu­lundurıJlduğunda, içerik sözcüklere dayalı arama makinalarına ilaveten, otomatik kaynak keşfine ve bilginin harmanlanmasına olanak veren ya­zılım araçlarının gerekliliği ortaya çıkmaktadır. Bu tür yazılım araçlarının başarısı ise, işlenecek kaynakların modellenmesinin standart bir biçimde yapılmasına çok yakından bağlıdır. RDF (Resource Description Fra­mework), böyle bir çabadan doğan anlamsal bir modellemedir ve bu model üzerinde yapılan çalışmalar WWW (World Wide Web) Kon­sorsiyumu tarafından kontrol edilmektedir. DC (Dublin Core) üstveri ele­manları, elektronik katalog bilgilerini tutmak için, RDF"in genişletilebilirlik özelliği kullanılarak tanımlanmıştır. Bu makalede, RDFIDC modeli kul­lanılarak Türkçe elektronik kaynakların içeriklerinin tanımlanmasını sağ­layan H-DCEdit adlı editör aracı tanıtılacaktır. RDF modelinin seri/eştirme sözdizimi olarak SGML (Standard Generalized Markup Language) kul­lanılmıştır. Bu çalışmaya ek olarak, RDF/DC belgelerinin, DSSSL (Do­cument Style Semantics and Specification Language) standardı yar­dımıyla farklı belge biçimlerinde yeniden biçimlenmesi de sağlanmıştır.

Deriving Proof Rules from Continuation Semantics

Abstract. We claim that a continuation style semantics of a programming language can provide a starting point for constructing its proof system. The basic idea is to see weakest preconditions as a particular instance of continuation style semantics, hence to interpret correctness assertions (e.g. Hoare triples { p } C { r }) as inequalities over continuations. This approach also shows a correspondence between labels in a program and annotations.

On Logics with Coimplication

This paper investigates (modal) extensions of Heyting–Brouwer logic, i.e., the logic which results when the dual of implication (alias coimplication) is added to the language of intuitionistic logic. We first develop matrix as well as Kripke style semantics for those logics. Then, by extending the Godel-embedding of intuitionistic logic into S4 , it is shown that all (modal) extensions of Heyting–Brouwer logic can be embedded into tense logics (with additional modal operators). An extension of the Blok–Esakia-Theorem is proved for this embedding.

Two extensions of the structurally free logic LC

The paper considers certain extensions of the system LC introduced in Dunn & Meyer 1997. LC is a structurally free system (it has no structural rules), but it has combinators as formulas in the place of structural rules. We consider two ways to extend LC with conjunction and disjunction depending on whether they distribute over each other or not. We prove the elimination theorem for the systems. At the end of the paper we give a Routley-Meyer style semantics for the distributive extension, including some new definitions and an algorithm which are used in proving a representation theorem in general, i.e., for arbitrary combinators. Keywords:Gentzen system, substructural logic, combinators, cut elimination, algebraic semantics

Program constructions that are safe for bisimulation

It has been known since the seventies that the formulas of modal logic are invariant for bisimulations between possible worlds models — while conversely, all bisimulation-invariant first-order formulas are modally definable. In this paper, we extend this semantic style of analysis from modal formulas to dynamic program operations. We show that the usual regular operations are safe for bisimulation, in the sense that the transition relations of their values respect any given bisimulation for their arguments. Our main result is a complete syntactic characterization of all first-order definable program operations that are safe for bisimulation. This is a semantic functional completeness result for programming, which may be contrasted with the more usual analysis in terms of computational power. The 'Safety Theorem' can be modulated in several ways. We conclude with a list of variants, extensions, and further developments.

The ?ABCs? of DSSSL

DSSSL, the Document Style Semantics and Specification Language, is ISO/IEC 10179, an International Standard for the formatting and other processing of SGML documents. DSSSL was completed in January 1996 after 8 years of development. From its inception, DSSSL was conceived as a companion standard to SGML, where SGML is a language for standardizing the way we represent document structures without regard to its form or presentation. It is possible to use SGML markup to represent formatting information, but this is discouraged, since doing so makes a document more difficult to reuse and reprocess. Reuse is generally a significant requirement for SGML data so it is not a good idea to pollute your document with presentational markup. Yet formatting of some nature is still desirable, and sometimes critical, for all documents, and in some cases users want to interchange this formatting information (informally known in the industry as style sheets) in a standardized, non-proprietary format. DSSSL is key to enabling this interchange.

A Uniform Framework for Concept Definitions in Description Logics

Most modern formalisms used in Databases and Artificial Intelligence for describing an application domain are based on the notions of class (or concept) and relationship among classes. One interesting feature of such formalisms is the possibility of defining a class, i.e., providing a set of properties that precisely characterize the instances of the class. Many recent articles point out that there are several ways of assigning a meaning to a class definition containing some sort of recursion. In this paper, we argue that, instead of choosing a single style of semantics, we achieve better results by adopting a formalism that allows for different semantics to coexist. We demonstrate the feasibility of our argument, by presenting a knowledge representation formalism, the description logic muALCQ, with the above characteristics. In addition to the constructs for conjunction, disjunction, negation, quantifiers, and qualified number restrictions, muALCQ includes special fixpoint constructs to express (suitably interpreted) recursive definitions. These constructs enable the usual frame-based descriptions to be combined with definitions of recursive data structures such as directed acyclic graphs, lists, streams, etc. We establish several properties of muALCQ, including the decidability and the computational complexity of reasoning, by formulating a correspondence with a particular modal logic of programs called the modal mu-calculus.

Incoherence and subsumption for recursive views and queries in object-oriented data models

Object-oriented data models are being extended with recursion to gain expressive power. This complicates both the incoherence detection problem which has to deal with recursive classes descriptions and the optimization problem which has to deal with recursive queries on complex objects. In this paper, we propose a theoretical framework able to face the above problems. In particular, it is able to validate and automatically classify in a database schema, (recursive) classes, views and queries, organized in an inheritance taxonomy. The framework adopts the odl formalism (an extension of the Description Logics developed in the area of Artificial Intelligence) which is able to express the semantics of complex object data models and to deal with cyclic references at the schema and instance level. It includes subsumption algorithms, which perform automatic placement in a specialization hierarchy of (recursive) views and queries, and incoherence algorithms, which detect incoherent (i.e., always empty) (recursive) classes, views and queries. As different styles of semantics: greatest fixed-point, least fixed-point and descriptive can be adopted to interpret recursive views and queries, first of all we analyze and discuss the choice of one or another of the semantics and, secondly, we give the subsumption and incoherence algorithms for the three different semantics. We show that subsumption computation and incoherence detection appear to be feasible since in almost all practical cases they can be solved in polynomial time algorithms.

A theoretical foundation of the DSSSL location model

In the location model of Document Style Semantics and Specification Language (DSSSL), one can use tree patterns to locate nodes in logical structures of documents. A tree pattern consists of conditions on nodes and those on their hierarchical relationships. As a first step towards efficient implementations, this paper shows a theoretical foundation of the location model. Tree patterns are first expressed by sentences of branching-time temporal logic. These sentences are then converted to well-formed attribute grammars. Thus, the library of attribute grammar evaluation techniques can be used to implement the location model. It is our belief that this observation is significant for future implementors of DSSSL. Furthermore, the converted attribute grammars can be evaluated by traversing logical structures several times. The number of required traversals can be found by examining the original sentences.

Extending negation as failure by abduction: A three-valued stable model semantics

In this paper, we propose a semantics for logic programs with negation as failure, the Finite Failure Stable Model semantics (FF-SM semantics), which is a three-valued extension of Gelfond and Lifschitz' Stable Model semantics. FF-SM semantics is defined in the style of Gelfond and Lifschitz Stable Model semantics, but it builds on an underlying Kripke/Kleene semantics, in which loops causing nonterminating computations are modeled by means of the truth-value undefined. It is different from the eXtended Stable Model (XSM) semantics defined by Przymusinski, since it does not capture infinite failure. We also introduce an abductive proof procedure which is an abductive extension of SLDNF-resolution based on the ideas underlying Eshghi and Kowalski's abductive procedure. We prove that our procedure is sound and complete with respect to FF-SM semantics. We compare the FF-SM semantics with the XSM semantics, and provide a reconstruction for it within the bilattice-based framework proposed by Fitting. In the paper, we deal with the propositional case.

Logical object as a basis of knowledge based systems

This paper presents a framework called logical knowledge object (LKO), which is taken as a basis of the dependable development of knowledge based systems(KBSs). LKO combines logic programming and object-oriented programming paradigms, where objects are viewed as abstractions with states, constraints, behaviors and inheritance. The operational semantics defined in the style of natural semantics is simple and clear. A hybrid knowledge representation amalgamating rule, frame, semantic network and blackboard is available for both most structured and flat knowledge. The management of knowledge bases has been formally specified. Accordingly, LKO is well suited for the formal representation of knowledge and requirements of KBSs. Based on the framework, verification techniques are also explored to enhance the analysis of requirement specifications and the validation of KBSs. In addition, LKO provides a methodology for the development of KBSs, applying the concepts of rapid prototyping and top-down design to deal with changing and incomplete requirements, and to provide multiple abstract models of the domain, where formal methods might be used at each abstract level.

Logical objects with constraints

This paper presents a novel programming language called LOC (Logical Objects with Constraints), which combines logic programming and object-oriented programming paradigms. In LOC, logical objects are viewed as abstractions with state, constraints, behaviors and inheritance. It therefore supports such notions as inheritance, modularity and reusability, which have turned out to be extremely useful for large scale software systems. The operational interpretation defined in the style of natural semantics is simple and clear. The transformation of LOC into Prolog is also explored to indirectly illustrate the descriptive semantics.

Conditional rewriting logic as a unified model of concurrency

Rewriting with conditional rewrite rules modulo a set E of structural axioms provides a general framework for unifying a wide variety of models of concurrency. Concurrent rewriting coincides with logical deduction in conditional rewriting logic, a logic of actions whose models are concurrent systems. This logic is sound and complete and has initial models. In addition to general models interpreted as concurrent systems which provide a more operational style of semantics, more restricted semantics with an incresingly denotational flavor such as preorder, poset, cpo, and standard algebraic models appear as special cases of the model theory. This permits dealing with operational and denotational issues within the same model theory and logic. A programming language called Maude whose modules are rewriting logic theories is defined and given denotational and operational semantics. Maude provides a simple unification of concurrent programming with functional and object-oriented programming and supports high level declarative programming of concurrent systems.