Towards a Semantic Web Modeling Language
|
|
- Victor Watkins
- 5 years ago
- Views:
Transcription
1 Towards a Semantic Web Modeling Language Draft Christoph Wernhard Persist AG Rheinstr. 7c Teltow Tel: 03328/ wernhard@persistag.com May 25, Introduction The Semantic Web [2] requires that reference models, schemas specifying structuring and access methods of information, can be shared by consumers and providers of information. Every net user should be able to publish schemas: entirely new models, sophisticated refinements of given models and also simplifications of given models which are adapted to an application field or user community. The World Wide Web Consortium suggest with RDF and RDF-Schema [5] a rudimentary logic language for that purpose. RDF breaks knowledge into its atoms, property-object-value triples. We wish to complement this bottom-up approach by starting from a higher level of abstraction, with a language for distributed knowledge and data modeling: From primitive object types, that specify single messages, complex models can be built using Web links and a few operators. The modeling language should facilitate a number of requirements of modeling in the semantic web: providing human understandable structuring of knowledge, defining mappings between different schemas related to a common subject, incorporating well known techniques from knowledge based modeling such as object orientation, constraints and defaults, incorporating more recent techniques from the area of type systems of programming languages, defining extensions corresponding to particular knowledge representation approaches and defining mappings to different concrete representation and programming languages. 1
2 1.1 First Order Logic as Formalism In this paper we outline an abstract syntax and semantics of a simple type system suited for distributed modeling in the semantic web. To provide a common basis for extensions of several kinds, it should be as general as possible. We like to specify the type system using first order logic, following the knowledge representation tradition of artificial intelligence, for two reasons: First order logic is expected to provide a single language in which everything can be expressed, thereby allowing the combination of knowledge simply by conjunction of formulas. Secondly, first order logic provides a separation between declarative information and processing. Specifications have not to be obscured with entangled processing aspects, and, when it comes to processing, it can be done really efficient with tools like preprocessors and specialized theorem provers. 1.2 On Concrete Syntax Today there is an abundance of suggestions for XML based formats for exchanging structured information in the Web. In contrast to conventional legacy document processing, we start out with a completely formalized language, which already comes with an abstract syntax and can be easily mapped into XML, ISO Prolog, Common Lisp, a variant of Corba IDL and a meta object protocol. 1.3 Types Different schema level representation formalisms, like relational database schemas, object-oriented classes and object-oriented interfaces emphasize different aspects such as data structuring, code sharing, model based representation, and interfaces between providers and customers of information. Our approach starts from considering types in the sense of interfaces only. As familiar from the Java programming language, types (interfaces) are distinguished from classes. With types only method signatures and no implementation or concrete data structuring information is associated. Very flexible ways of combination, such as multiple inheritance, can be specified for types in simple ways. Since agreement on supplied and required interfaces is all that is needed for the exchange of data in a distributed environment, types already provide the glue for many useful applications. 1.4 Types as Objects The logic-of-frames approach in the past era of knowledge representation focused on showing how frames (types) and slots (fields, methods) can be expressed using first order logic as predicates and functions respectively. In these straightforward logic representations (see e.g. [3]) types are predicates 2
3 and therefore not objects of the first order language. The issues we are interested in, however require that types are considered as language objects: It must be possible for the specification of a type to include references to other types. It must be possible to match types provided and required in data exchange scenarios. It must be possible to specify, infer and verify mediators [7], mappings between types describing a common domain in different ways. In particular this involves characterizations of equality of types and the subtype relationship. Some concrete type systems specify those relationships based on the names by which types are referred to. For a general system it must be possible to compare types by their extensional or structural properties. In the literature both approaches are termed by-name equivalence and structural equivalence [4]. We adopt structural equivalence and provide a mechanism to simulate by-name equivalence. 2 Syntax We prepend the semantic description of the type system operators by an overview on the abstract syntax of Web documents containing type definitions. Some suggestions for the context in which it is used and extensions are described below in section 5. definition ::= define(uri, type) reference ::= refer(uri ) type ::= reference primitive type composed type primitive type ::= name : msg(type, type) name : tag void any composed type ::= type type type type URI is an identifier from the Web URI namespace. reference contains an URI referring to a type definition. : is a binary constructor function for primitive types. name is a string that is used as message name or tag name. N: msg(t a, T v ) denotes the type which implements just the message N on the sequence of arguments of types T a and with value type T v. Special cases are N : msg(t v ), which denotes the type which implements the single message N without argument and with value type T v, and N:msg(T a, void) which denotes a message that does not return a value. N: tag denotes the 3
4 type that implements just the so called tag N. Tags are used to simulate by-name type equivalence and subtyping. any is the most general type. and can be used to form intersection and union types. 3 Axioms We present axioms stating semantic properties of types. in(x, T ) denotes that object X has type (i.e. satisfies the interface) T. The role of this predicate is similar to in the common axiomatizations of set operators. 3.1 Primitive Types Axiom 1 (MSG) X, N, T a, T v in(x, N : msg(t a, T v )) A in(a, T a ) V send(n, X, A, V ) in(v, T v ) send(n, X, A, V ) states that V is the result of sending message N with argument A to object X. A message is represented by send(n, X, A, V ) as a partial function, that (for given N and X) is defined on each argument in its domain A. An additional axiom can state the uniqueness of send: N, X, A, V 1, V 2 send(n, X, A, V 1 ) send(n, X, A, V 2 ) V 1 = V 2. Although send is used here in the axiomatization of the type system, to prove properties of types such as subtype relationship or equivalence of given types, the full semantics of send (i.e. the semantics of actual programs) is not required. For messages with argument arity larger than one, analogous axioms can be given. For messages with arity zero, the corresponding axiom looks as follows: Axiom 2 (MSG-NOARG) X, N, T v in(x, N : msg(t v )) V send(n, X, V ) in(v, T v ) Messages which return no useful result, (which are called e.g. for side effects), have the predefined type void as result type. The tag type constructor is used to simulate by-name type equivalence. Two types, which otherwise implement the same messages, can be distinguished by the tags they implement. These tags are not linked with any further constraints, although a more specific type-system might associate constraints with them, for example to ensure that comparision of tags is sufficient for type checking. The following axiomatization of tag as message without argument and result is somewhat arbitrary, but fits into the general scheme: 4
5 Axiom 3 (TAG) X, N in(x, N : tag) V send(n, X, V ) in(v, void) 3.2 Properties Axiom 4 (SUBTYPE) T 1, T 2 subtype(t 1, T 2 ) X in(x, T 1 ) in(x, T 2 ) The subtype relationship. The following theorem illustrates that the formalization handles types in contravariant (anti-monotonic) [4] position as expected: Theorem 1 N, T a1, T v1, T a2, T v2 subtype(t a2, T a1 ) subtype(t v1, T v2 ) subtype(n:msg(t a1, T v1 ), N:msg(T a2, T v2 )) Axiom 5 (EQUIVALENCE) T 1, T 2 T 1 = T 2 X in(x, T 1 ) in(x, T 2 ) Type equivalence. 3.3 Intersection and Union Types Axiom 6 (INTERSECTION) X, T 1, T 2 in(x, T 1 T 2 ) in(x, T 1 ) in(x, T 2 ) Intersection of types is used to construct a type supporting different messages directly from primitive message types, as well as, in the manner of multiple inheritance, from given types and given additional primitve message types. For example the type point supports two messages, get x and, get y which return objects of type int. colored point extends point by supporting the get color message: point = get x:msg(int) get y:msg(int) colored point = point get color:msg(color) 5
6 Axiom 7 (UNION) X, T 1, T 2 in(x, T 1 T 2 ) in(x, T 1 ) in(x, T 2 ) Consider two types rgb color and hsv color: rgb color = get color name:msg(string) get red:msg(int) get green:msg(int) get blue:msg(int) hsv color = get color name:msg(string) get hue:msg(int) get saturation:msg(int) get value:msg(int) get color name:msg(string) is a supertype of their union type (rgb color hsv color). A variant type, the disjoint union of both color types, could be defined with the help of tags: (rgb color tag:tag rgb color) (hsv color tag:tag hsv color) The following equations hold for unary methods, analogous equations hold for methods of other arities: Theorem 2 N, T, T 1, T 2 N:msg(T, T 1 T 2 ) = N:msg(T, T 1 ) N:msg(T, T 2 ) N, T, T 1, T 2 N:msg(T, T 1 T 2 ) = N:msg(T, T 1 ) N:msg(T, T 2 ) N, T 1, T 2, T N:msg(T 1 T 2, T ) = N:msg(T 1, T ) N:msg(T 2, T ) N, T 1, T 2, T N:msg(T 1 T 2, T ) = N:msg(T 1, T ) N:msg(T 2, T ) Since, for example n:msg(int string, void) = n:msg(int, void) n:msg(string, void), implementing message n by a single method accepting (int string) and implementing it using overloading by two methods accepting int and string respectively, are equivalent. However, not every composed type expression containing primitive messages with the same name is equivalent to a single primitive message type: For example (n:msg(int, int) n:msg(real, real)) 1 is a supertype of n:msg(real,int), but not equivalent. 1 Assumed int is defined as subtype of real (e.g. by defining real = real tag:tag and int = real int tag:tag) 6
7 The following illustrates the subtype relationship of fields, considered as types composed from types implementing getter and setter methods. 2 The types on the third line implement a read- and writable field of type real and int respectively. Their supertype in the center implements a field, that can be written only with an int but might return a real when read. Their subtype at the bottom line can implements a field, that can be written with a real but returns an int. set n:msg(int,void) get n:msg(real) set n:msg(real,void) set n:msg(int,void) get n:msg(real) set n:msg(real,void) get n:msg(int) set n:msg(real,void) get n:msg(real) get n:msg(int) get n:msg(int) set n:msg(int,void) 4 Recursive and Polymorphic Types 4.1 Recursive Types Our axiomatization so far is too weak to provide notions for equality and subtype relationship between recursively defined types. Amadio and Cardelli [1] give algorithmic characterizations of subtype relationship between recursive types. In our type specification language, recursion is expressed via references by globally scoped names (URIs of type definitions) instead of an explicit µ operator. It should be possible to map these global definitions to µ expressions in the same ways as mutually recursive function definitions can be mapped to letrec expressions. 4.2 Polymorphic Types An unbounded polymorphic type can be specified by using a function instead of a constant as type name in the defining equation. The polymorphic type is then not available as an object (within first order logic), but a statement about all instances of the polymorphic type can be made. A value for the 2 This is similar to the relationship of expression, variable and acceptor types in the programming language Forsythe [6]. 7
8 type parameter has to supplied within an URI refering to an instantiation of a polymorphic type. T list(t ) = car:msg(t ) cdr:msg(list(t )) 5 Around the Types We outline some of the envisioned contexts of our type system for use as a Semantic Web modeling language. 5.1 Documents Defining Equations For the distributed modeling language, the primary unit which can be referred to by an URI is a type definition. It is an equation with a type name on its left side and a type expression on its right. Logically this can be viewed as a proposition, that states that a reference expression containing the URI can be rewritten to the semantically equivalent right side. A set of such propositions can be grouped into a single document, thereby inheriting common properties such as author, date or the prefix of the URI. 5.2 Functional Meta Language The constructor terms listed in section 2 can also be constructor terms of a functional programming or query language. This meta language can be used to implement specialized theorem provers, (e.g. for evaluating the subtype predicate) and arbitrary syntax related operations like validating or performing mappings between sets of type specifications. The URI namespace can be extended to include not only names of defined types but also expressions of the meta language. 5.3 References and Distributed Processing Since an URI contains the name of a server, it includes information about the location on which an expression (i.e. the rest of the URI after the server name) is evaluated. Together with the functional view of URI dereferencing, this suggests that optimization of a distributed functional query language can be expressed by rewriting refer(uri ) expressions appropriately. 5.4 Derivations Proofs The basic units of our language are defining equations, propositions as Web documents. Usually meta information such as author and publication date is associated with a Web document. The view of a Web document as a 8
9 proposition suggests to consider this meta information as part of a proof of that proposition. Such a proof can include subproofs the proofs of the defining equations, to which it (transitively) refers via URIs. Besides Web meta information, proofs will include records of the operations involved in constructing the type. Since different versions of types will be identified by different URIs 3, such a derivation provides a version history of a type. The inclusion of derivations extends the extensional view of a Web reference (dereferencing as a semantics preserving rewriting step) to an extension-intension pair, that also contains a representation of intensional aspects (a proof or derivation, including epistemic information such as authorship). The following example sketch illustrates this. # is the extensionderivation pairing operator, the displayed right sides of # can be considered as pretty printed derivation terms: point = get x:msg(int) get y:msg(int) # author=john colored point = point get color:msg(color) # author=mary The query get(colored point) to a web server then might return the following expression-derivation pair: get x:msg(int) get y:msg(int) get color:msg(color) # mary says: "colored point = (point get color:msg(color))" john says: "point = (get x:msg(int) get y:msg(int))" hence colored point = result 5.5 Extensions The type system as outlined above is very general. It should provide a basis for extensions such as more restrictive type systems. This includes data modeling approaches, such as entity-relationship modeling and concrete systems of modeling and programming languages, such as the Java or the ODMG type system. Constraints expressing the properties of theses systems have to be specified along with mappings from arbitrarily structured groups of types. 6 Conclusion and Further Research Issues We believe that some characteristics of the outlined modeling language are important features for distributed semantic expression in the Web, especially 3 This is also suggested for RDF-Schema [5]. 9
10 the composition of types from primitives and operations and the embedding of equational specification into the URI space. Straightforward logical property-object-value statements are only positive assertions about the extension of a property. Negative facts, that delimit the extension, are in horn clause programming and datalog implicit by restriction to minimal models with respect to the set of propositions of the program or database. For a logic program or a deductive database, this set of propositions is completely determined. In a distributed setting like the Semantic Web, however, it is a problem to determine, when the set of propositions that have to be considered for an inference task is complete. The use of equational specification avoids this problem, since an equation characterizes positive as well as negative aspects. Nevertheless there is a number of issues, that must be cleared by further research: Formalize the subtype relationship of recursive subtypes in the sense of [1]. Specify algorithms e.g. for deciding subtype relationship and equality. Show how algorithms can be derived from the axiomatization. Show how features of various type systems can be simulated. Show uses of union types. Explore notions of removal of information, such as the projection of a type to messages with names from a certain set, or a difference operator for types. References [1] Roberto M. Amadio and Luca Cardelli. Subtyping recursive types. ACM Transactions on Programming Languages and Systems, 15(4): , September [2] Tim Berners-Lee, Dan Connolly, Ralph R. Swick: Web Architecture: Describing and Exchanging Data, W3C Note 7 June 1999, [3] Wolfgang Bibel et al.: Wissensrepräsentation und Inferenz eine grundlegende Einführung, Braunschweig, [4] Luca Cardelli: Type Systems. In Handbook of Computer Science and Engineering. CRC Press [5] Resource Description Framework (RDF) Schema Specification, W3C Proposed Recommendation 03 March 1999, [6] John C. Reynolds: Design of the Programming Language Forsythe, Technical Report CMU-CS , Scool of Computer Science, Carnegie Mellon University, Pittsburgh, [7] Gio Wiederhold: Mediators in the Architecture of Future Information Systems. In IEEE Computer, March 1992, pp
Meta-programming with Names and Necessity p.1
Meta-programming with Names and Necessity Aleksandar Nanevski Carnegie Mellon University ICFP, Pittsburgh, 05 October 2002 Meta-programming with Names and Necessity p.1 Meta-programming Manipulation of
More informationOntological Modeling: Part 2
Ontological Modeling: Part 2 Terry Halpin LogicBlox This is the second in a series of articles on ontology-based approaches to modeling. The main focus is on popular ontology languages proposed for the
More informationAppendix 1. Description Logic Terminology
Appendix 1 Description Logic Terminology Franz Baader Abstract The purpose of this appendix is to introduce (in a compact manner) the syntax and semantics of the most prominent DLs occurring in this handbook.
More informationAppendix 1. Description Logic Terminology
Appendix 1 Description Logic Terminology Franz Baader Abstract The purpose of this appendix is to introduce (in a compact manner) the syntax and semantics of the most prominent DLs occurring in this handbook.
More informationChapter 11 Object and Object- Relational Databases
Chapter 11 Object and Object- Relational Databases Copyright 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley Chapter 11 Outline Overview of Object Database Concepts Object-Relational
More informationCopyright 2016 Ramez Elmasri and Shamkant B. Navathe
Chapter 12 Outline Overview of Object Database Concepts Object-Relational Features Object Database Extensions to SQL ODMG Object Model and the Object Definition Language ODL Object Database Conceptual
More informationCSCI.6962/4962 Software Verification Fundamental Proof Methods in Computer Science (Arkoudas and Musser) Chapter p. 1/27
CSCI.6962/4962 Software Verification Fundamental Proof Methods in Computer Science (Arkoudas and Musser) Chapter 2.1-2.7 p. 1/27 CSCI.6962/4962 Software Verification Fundamental Proof Methods in Computer
More informationSUMMARY: MODEL DRIVEN SECURITY
SUMMARY: MODEL DRIVEN SECURITY JAN-FILIP ZAGALAK, JZAGALAK@STUDENT.ETHZ.CH Model Driven Security: From UML Models to Access Control Infrastructres David Basin, Juergen Doser, ETH Zuerich Torsten lodderstedt,
More informationDependent Object Types - A foundation for Scala s type system
Dependent Object Types - A foundation for Scala s type system Draft of September 9, 2012 Do Not Distrubute Martin Odersky, Geoffrey Alan Washburn EPFL Abstract. 1 Introduction This paper presents a proposal
More information1. true / false By a compiler we mean a program that translates to code that will run natively on some machine.
1. true / false By a compiler we mean a program that translates to code that will run natively on some machine. 2. true / false ML can be compiled. 3. true / false FORTRAN can reasonably be considered
More informationFormal Systems and their Applications
Formal Systems and their Applications Dave Clarke (Dave.Clarke@cs.kuleuven.be) Acknowledgment: these slides are based in part on slides from Benjamin Pierce and Frank Piessens 1 Course Overview Introduction
More informationOperational Semantics
15-819K: Logic Programming Lecture 4 Operational Semantics Frank Pfenning September 7, 2006 In this lecture we begin in the quest to formally capture the operational semantics in order to prove properties
More informationThe Formal Syntax and Semantics of Web-PDDL
The Formal Syntax and Semantics of Web-PDDL Dejing Dou Computer and Information Science University of Oregon Eugene, OR 97403, USA dou@cs.uoregon.edu Abstract. This white paper formally define the syntax
More informationLOGIC AND DISCRETE MATHEMATICS
LOGIC AND DISCRETE MATHEMATICS A Computer Science Perspective WINFRIED KARL GRASSMANN Department of Computer Science University of Saskatchewan JEAN-PAUL TREMBLAY Department of Computer Science University
More informationOrchestrating Music Queries via the Semantic Web
Orchestrating Music Queries via the Semantic Web Milos Vukicevic, John Galletly American University in Bulgaria Blagoevgrad 2700 Bulgaria +359 73 888 466 milossmi@gmail.com, jgalletly@aubg.bg Abstract
More informationOverview. CS389L: Automated Logical Reasoning. Lecture 6: First Order Logic Syntax and Semantics. Constants in First-Order Logic.
Overview CS389L: Automated Logical Reasoning Lecture 6: First Order Logic Syntax and Semantics Işıl Dillig So far: Automated reasoning in propositional logic. Propositional logic is simple and easy to
More informationB.6 Types and Overloading
266 appendix b: alloy language reference B.6 Types and Overloading Alloy s type system was designed with a different aim from that of a programming language. There is no notion in a modeling language of
More informationProving Theorems with Athena
Proving Theorems with Athena David R. Musser Aytekin Vargun August 28, 2003, revised January 26, 2005 Contents 1 Introduction 1 2 Proofs about order relations 2 3 Proofs about natural numbers 7 3.1 Term
More informationXML ALONE IS NOT SUFFICIENT FOR EFFECTIVE WEBEDI
Chapter 18 XML ALONE IS NOT SUFFICIENT FOR EFFECTIVE WEBEDI Fábio Ghignatti Beckenkamp and Wolfgang Pree Abstract: Key words: WebEDI relies on the Internet infrastructure for exchanging documents among
More informationType Inference Systems. Type Judgments. Deriving a Type Judgment. Deriving a Judgment. Hypothetical Type Judgments CS412/CS413
Type Inference Systems CS412/CS413 Introduction to Compilers Tim Teitelbaum Type inference systems define types for all legal programs in a language Type inference systems are to type-checking: As regular
More informationDATABASE THEORY. Lecture 11: Introduction to Datalog. TU Dresden, 12th June Markus Krötzsch Knowledge-Based Systems
DATABASE THEORY Lecture 11: Introduction to Datalog Markus Krötzsch Knowledge-Based Systems TU Dresden, 12th June 2018 Announcement All lectures and the exercise on 19 June 2018 will be in room APB 1004
More informationCOMP 181. Agenda. Midterm topics. Today: type checking. Purpose of types. Type errors. Type checking
Agenda COMP 181 Type checking October 21, 2009 Next week OOPSLA: Object-oriented Programming Systems Languages and Applications One of the top PL conferences Monday (Oct 26 th ) In-class midterm Review
More informationTyped Scheme: Scheme with Static Types
Typed Scheme: Scheme with Static Types Version 4.1.1 Sam Tobin-Hochstadt October 5, 2008 Typed Scheme is a Scheme-like language, with a type system that supports common Scheme programming idioms. Explicit
More informationLogical reconstruction of RDF and ontology languages
Logical reconstruction of RDF and ontology languages Jos de Bruijn 1, Enrico Franconi 2, and Sergio Tessaris 2 1 Digital Enterprise Research Institute, University of Innsbruck, Austria jos.debruijn@deri.org
More information3.4 Deduction and Evaluation: Tools Conditional-Equational Logic
3.4 Deduction and Evaluation: Tools 3.4.1 Conditional-Equational Logic The general definition of a formal specification from above was based on the existence of a precisely defined semantics for the syntax
More informationKnowledge Representation and Reasoning Logics for Artificial Intelligence
Knowledge Representation and Reasoning Logics for Artificial Intelligence Stuart C. Shapiro Department of Computer Science and Engineering and Center for Cognitive Science University at Buffalo, The State
More information15-819M: Data, Code, Decisions
15-819M: Data, Code, Decisions 08: First-Order Logic André Platzer aplatzer@cs.cmu.edu Carnegie Mellon University, Pittsburgh, PA André Platzer (CMU) 15-819M/08: Data, Code, Decisions 1 / 40 Outline 1
More informationLecture 1: Conjunctive Queries
CS 784: Foundations of Data Management Spring 2017 Instructor: Paris Koutris Lecture 1: Conjunctive Queries A database schema R is a set of relations: we will typically use the symbols R, S, T,... to denote
More informationAn Approach to Behavioral Subtyping Based on Static Analysis
TACoS 04 Preliminary Version An Approach to Behavioral Subtyping Based on Static Analysis Francesco Logozzo 1 STIX - École Polytechnique F-91128 Palaiseau, France Abstract In mainstream object oriented
More informationContents. Chapter 1 SPECIFYING SYNTAX 1
Contents Chapter 1 SPECIFYING SYNTAX 1 1.1 GRAMMARS AND BNF 2 Context-Free Grammars 4 Context-Sensitive Grammars 8 Exercises 8 1.2 THE PROGRAMMING LANGUAGE WREN 10 Ambiguity 12 Context Constraints in Wren
More informationRange Restriction for General Formulas
Range Restriction for General Formulas 1 Range Restriction for General Formulas Stefan Brass Martin-Luther-Universität Halle-Wittenberg Germany Range Restriction for General Formulas 2 Motivation Deductive
More informationKnowledge Representation and Reasoning Logics for Artificial Intelligence
Knowledge Representation and Reasoning Logics for Artificial Intelligence Stuart C. Shapiro Department of Computer Science and Engineering and Center for Cognitive Science University at Buffalo, The State
More informationDCMI Abstract Model - DRAFT Update
1 of 7 9/19/2006 7:02 PM Architecture Working Group > AMDraftUpdate User UserPreferences Site Page Actions Search Title: Text: AttachFile DeletePage LikePages LocalSiteMap SpellCheck DCMI Abstract Model
More informationAn Evolution of Mathematical Tools
An Evolution of Mathematical Tools From Conceptualization to Formalization Here's what we do when we build a formal model (or do a computation): 0. Identify a collection of objects/events in the real world.
More informationCom S 541. Programming Languages I
Programming Languages I Lecturer: TA: Markus Lumpe Department of Computer Science 113 Atanasoff Hall http://www.cs.iastate.edu/~lumpe/coms541.html TR 12:40-2, W 5 Pramod Bhanu Rama Rao Office hours: TR
More informationJava Learning Object Ontology
Java Learning Object Ontology Ming-Che Lee, Ding Yen Ye & Tzone I Wang Laboratory of Intelligent Network Applications Department of Engineering Science National Chung Kung University Taiwan limingche@hotmail.com,
More informationDistributed Systems Programming (F21DS1) Formal Verification
Distributed Systems Programming (F21DS1) Formal Verification Andrew Ireland Department of Computer Science School of Mathematical and Computer Sciences Heriot-Watt University Edinburgh Overview Focus on
More informationFormal Predicate Calculus. Michael Meyling
Formal Predicate Calculus Michael Meyling May 24, 2013 2 The source for this document can be found here: http://www.qedeq.org/0_04_07/doc/math/qedeq_formal_logic_v1.xml Copyright by the authors. All rights
More informationWHY WE NEED AN XML STANDARD FOR REPRESENTING BUSINESS RULES. Introduction. Production rules. Christian de Sainte Marie ILOG
WHY WE NEED AN XML STANDARD FOR REPRESENTING BUSINESS RULES Christian de Sainte Marie ILOG Introduction We are interested in the topic of communicating policy decisions to other parties, and, more generally,
More informationI. Khalil Ibrahim, V. Dignum, W. Winiwarter, E. Weippl, Logic Based Approach to Semantic Query Transformation for Knowledge Management Applications,
I. Khalil Ibrahim, V. Dignum, W. Winiwarter, E. Weippl, Logic Based Approach to Semantic Query Transformation for Knowledge Management Applications, Proc. of the International Conference on Knowledge Management
More informationOntological Modeling: Part 7
Ontological Modeling: Part 7 Terry Halpin LogicBlox and INTI International University This is the seventh in a series of articles on ontology-based approaches to modeling. The main focus is on popular
More informationProgramming Languages Third Edition
Programming Languages Third Edition Chapter 12 Formal Semantics Objectives Become familiar with a sample small language for the purpose of semantic specification Understand operational semantics Understand
More informationPolymorphic lambda calculus Princ. of Progr. Languages (and Extended ) The University of Birmingham. c Uday Reddy
06-02552 Princ. of Progr. Languages (and Extended ) The University of Birmingham Spring Semester 2016-17 School of Computer Science c Uday Reddy2016-17 Handout 6: Polymorphic Type Systems 1. Polymorphic
More informationOMG Modeling Glossary B
OMG Modeling Glossary B This glossary defines the terms that are used to describe the Unified Modeling Language (UML) and the Meta Object Facility (MOF). In addition to UML and MOF specific terminology,
More informationTypes. Type checking. Why Do We Need Type Systems? Types and Operations. What is a type? Consensus
Types Type checking What is a type? The notion varies from language to language Consensus A set of values A set of operations on those values Classes are one instantiation of the modern notion of type
More informationObject Oriented Issues in VDM++
Object Oriented Issues in VDM++ Nick Battle, Fujitsu UK (nick.battle@uk.fujitsu.com) Background VDMJ implemented VDM-SL first (started late 2007) Formally defined. Very few semantic problems VDM++ support
More informationThis is already grossly inconvenient in present formalisms. Why do we want to make this convenient? GENERAL GOALS
1 THE FORMALIZATION OF MATHEMATICS by Harvey M. Friedman Ohio State University Department of Mathematics friedman@math.ohio-state.edu www.math.ohio-state.edu/~friedman/ May 21, 1997 Can mathematics be
More informationH1 Spring B. Programmers need to learn the SOAP schema so as to offer and use Web services.
1. (24 points) Identify all of the following statements that are true about the basics of services. A. If you know that two parties implement SOAP, then you can safely conclude they will interoperate at
More informationCover Page. The handle holds various files of this Leiden University dissertation
Cover Page The handle http://hdl.handle.net/1887/22891 holds various files of this Leiden University dissertation Author: Gouw, Stijn de Title: Combining monitoring with run-time assertion checking Issue
More informationLecture Overview. [Scott, chapter 7] [Sebesta, chapter 6]
1 Lecture Overview Types 1. Type systems 2. How to think about types 3. The classification of types 4. Type equivalence structural equivalence name equivalence 5. Type compatibility 6. Type inference [Scott,
More informationConstraint Solving. Systems and Internet Infrastructure Security
Systems and Internet Infrastructure Security Network and Security Research Center Department of Computer Science and Engineering Pennsylvania State University, University Park PA Constraint Solving Systems
More informationKnowledge representation Semantic networks and frames
Knowledge representation Semantic networks and frames CmSc310 Artificial Intelligence 1. Introduction: What is knowledge? The science that studies various issues about knowledge is called epistemology.
More informationShared Subtypes. Subtyping Recursive Parameterized Algebraic Data Types
Shared Subtypes Subtyping Recursive Parameterized Algebraic Data Types Ki Yung Ahn kya@cs.pdx.edu Tim Sheard sheard@cs.pdx.edu Department of Computer Science Maseeh College of Engineering & Computer Science
More informationtype classes & locales
Content Rough timeline Intro & motivation, getting started [1] COMP 4161 NICTA Advanced Course Advanced Topics in Software Verification Gerwin Klein, June Andronick, Toby Murray type classes & locales
More informationmodel (ontology) and every DRS and CMS server has a well-known address (IP and port).
7 Implementation In this chapter we describe the Decentralized Reasoning Service (DRS), a prototype service implementation that performs the cooperative reasoning process presented before. We present also
More informationSEMANTIC WEB LANGUAGES STRENGTHS AND WEAKNESS
SEMANTIC WEB LANGUAGES STRENGTHS AND WEAKNESS Sinuhé Arroyo, Rubén Lara, Ying Ding, Michael Stollberg, Dieter Fensel Universität Innsbruck Institut für Informatik Technikerstraße 13 6020 Innsbruck, Austria
More informationStructural characterizations of schema mapping languages
Structural characterizations of schema mapping languages Balder ten Cate INRIA and ENS Cachan (research done while visiting IBM Almaden and UC Santa Cruz) Joint work with Phokion Kolaitis (ICDT 09) Schema
More informationOWL DL / Full Compatability
Peter F. Patel-Schneider, Bell Labs Research Copyright 2007 Bell Labs Model-Theoretic Semantics OWL DL and OWL Full Model Theories Differences Betwen the Two Semantics Forward to OWL 1.1 Model-Theoretic
More informationThe Logic Paradigm. Joseph Spring. 7COM1023 Programming Paradigms
The Logic Paradigm Joseph Spring 7COM1023 Programming Paradigms 1 Discussion The Logic Paradigm Propositional and Predicate Logic See also notes and slides on PP website Horn Clauses Definition, Examples
More informationCSCI-GA Scripting Languages
CSCI-GA.3033.003 Scripting Languages 12/02/2013 OCaml 1 Acknowledgement The material on these slides is based on notes provided by Dexter Kozen. 2 About OCaml A functional programming language All computation
More informationTerm Algebras with Length Function and Bounded Quantifier Elimination
with Length Function and Bounded Ting Zhang, Henny B Sipma, Zohar Manna Stanford University tingz,sipma,zm@csstanfordedu STeP Group, September 3, 2004 TPHOLs 2004 - p 1/37 Motivation: Program Verification
More informationFoundations of AI. 9. Predicate Logic. Syntax and Semantics, Normal Forms, Herbrand Expansion, Resolution
Foundations of AI 9. Predicate Logic Syntax and Semantics, Normal Forms, Herbrand Expansion, Resolution Wolfram Burgard, Andreas Karwath, Bernhard Nebel, and Martin Riedmiller 09/1 Contents Motivation
More informationRECODER - The Architecture of a Refactoring System
RECODER - The Architecture of a Refactoring System Andreas Ludwig Prof. U. Aßmann http://recoder.sf.net Overview ➊Programming in the Large Problems, Concepts, The Approach ➋The Architecture of RECODER
More informationFOUNDATIONS OF SEMANTIC WEB TECHNOLOGIES
FOUNDATIONS OF SEMANTIC WEB TECHNOLOGIES RDFS Rule-based Reasoning Sebastian Rudolph Dresden, 16 April 2013 Content Overview & XML 9 APR DS2 Hypertableau II 7 JUN DS5 Introduction into RDF 9 APR DS3 Tutorial
More informationarxiv: v2 [cs.ai] 18 Sep 2013
Lambda Dependency-Based Compositional Semantics Percy Liang September 19, 2013 arxiv:1309.4408v2 [cs.ai] 18 Sep 2013 Abstract This short note presents a new formal language, lambda dependency-based compositional
More informationNegations in Refinement Type Systems
Negations in Refinement Type Systems T. Tsukada (U. Tokyo) 14th March 2016 Shonan, JAPAN This Talk About refinement intersection type systems that refute judgements of other type systems. Background Refinement
More informationPart I Logic programming paradigm
Part I Logic programming paradigm 1 Logic programming and pure Prolog 1.1 Introduction 3 1.2 Syntax 4 1.3 The meaning of a program 7 1.4 Computing with equations 9 1.5 Prolog: the first steps 15 1.6 Two
More informationDesign of an inference engine for the semantic web
Design of an inference engine for the semantic web This document is the proposal for the Master Thesis made as a part of my Master Degree in Computer Science Education (Software Systems) at the Open University
More informationA Language for Access Control in CORBA Security
A Language for Access Control in CORBA Security Polar Humenn Adiron, LLC Syracuse University CASE Center Syracuse, NY 13244-4100 polar@adiron.com polar@syr.edu ABSTRACT In this brief paper, I present the
More informationCMSC 331 Final Exam Section 0201 December 18, 2000
CMSC 331 Final Exam Section 0201 December 18, 2000 Name: Student ID#: You will have two hours to complete this closed book exam. We reserve the right to assign partial credit, and to deduct points for
More informationProgram analysis parameterized by the semantics in Maude
Program analysis parameterized by the semantics in Maude A. Riesco (joint work with I. M. Asăvoae and M. Asăvoae) Universidad Complutense de Madrid, Madrid, Spain Workshop on Logic, Algebra and Category
More informationTyped Racket: Racket with Static Types
Typed Racket: Racket with Static Types Version 5.0.2 Sam Tobin-Hochstadt November 6, 2010 Typed Racket is a family of languages, each of which enforce that programs written in the language obey a type
More informationModule 8. Other representation formalisms. Version 2 CSE IIT, Kharagpur
Module 8 Other representation formalisms 8.1 Instructional Objective The students should understand the syntax and semantic of semantic networks Students should learn about different constructs and relations
More informationA Tool for Storing OWL Using Database Technology
A Tool for Storing OWL Using Database Technology Maria del Mar Roldan-Garcia and Jose F. Aldana-Montes University of Malaga, Computer Languages and Computing Science Department Malaga 29071, Spain, (mmar,jfam)@lcc.uma.es,
More informationPart III. Chapter 15: Subtyping
Part III Chapter 15: Subtyping Subsumption Subtype relation Properties of subtyping and typing Subtyping and other features Intersection and union types Subtyping Motivation With the usual typing rule
More informationFinal-Term Papers Solved MCQS with Reference
Solved MCQ(S) From FinalTerm Papers BY Arslan Jan 14, 2018 V-U For Updated Files Visit Our Site : Www.VirtualUstaad.blogspot.com Updated. Final-Term Papers Solved MCQS with Reference 1. The syntax of PHP
More informationX-KIF New Knowledge Modeling Language
Proceedings of I-MEDIA 07 and I-SEMANTICS 07 Graz, Austria, September 5-7, 2007 X-KIF New Knowledge Modeling Language Michal Ševčenko (Czech Technical University in Prague sevcenko@vc.cvut.cz) Abstract:
More informationProgrammiersprachen (Programming Languages)
2016-05-13 Preface Programmiersprachen (Programming Languages) coordinates: lecturer: web: usable for: requirements: No. 185.208, VU, 3 ECTS Franz Puntigam http://www.complang.tuwien.ac.at/franz/ps.html
More informationData Types. (with Examples In Haskell) COMP 524: Programming Languages Srinivas Krishnan March 22, 2011
Data Types (with Examples In Haskell) COMP 524: Programming Languages Srinivas Krishnan March 22, 2011 Based in part on slides and notes by Bjoern 1 Brandenburg, S. Olivier and A. Block. 1 Data Types Hardware-level:
More informationXQuery Optimization Based on Rewriting
XQuery Optimization Based on Rewriting Maxim Grinev Moscow State University Vorob evy Gory, Moscow 119992, Russia maxim@grinev.net Abstract This paper briefly describes major results of the author s dissertation
More informationThe Design of Core C++ (Notes)
The Design of Core C++ (Notes) Uday Reddy May 13, 1994 This note is to define a small formal language called Core C++ which reflects the essential structure of C++. As the name implies, the design only
More informationThe design of a programming language for provably correct programs: success and failure
The design of a programming language for provably correct programs: success and failure Don Sannella Laboratory for Foundations of Computer Science School of Informatics, University of Edinburgh http://homepages.inf.ed.ac.uk/dts
More informationLinked Open Data: a short introduction
International Workshop Linked Open Data & the Jewish Cultural Heritage Rome, 20 th January 2015 Linked Open Data: a short introduction Oreste Signore (W3C Italy) Slides at: http://www.w3c.it/talks/2015/lodjch/
More informationExtracting knowledge from Ontology using Jena for Semantic Web
Extracting knowledge from Ontology using Jena for Semantic Web Ayesha Ameen I.T Department Deccan College of Engineering and Technology Hyderabad A.P, India ameenayesha@gmail.com Khaleel Ur Rahman Khan
More informationOWL a glimpse. OWL a glimpse (2) requirements for ontology languages. requirements for ontology languages
OWL a glimpse OWL Web Ontology Language describes classes, properties and relations among conceptual objects lecture 7: owl - introduction of#27# ece#720,#winter# 12# 2# of#27# OWL a glimpse (2) requirements
More informationChapter 2 & 3: Representations & Reasoning Systems (2.2)
Chapter 2 & 3: A Representation & Reasoning System & Using Definite Knowledge Representations & Reasoning Systems (RRS) (2.2) Simplifying Assumptions of the Initial RRS (2.3) Datalog (2.4) Semantics (2.5)
More informationA Short Summary of Javali
A Short Summary of Javali October 15, 2015 1 Introduction Javali is a simple language based on ideas found in languages like C++ or Java. Its purpose is to serve as the source language for a simple compiler
More informationImperative Functional Programming
Imperative Functional Programming Uday S. Reddy Department of Computer Science The University of Illinois at Urbana-Champaign Urbana, Illinois 61801 reddy@cs.uiuc.edu Our intuitive idea of a function is
More informationJENA: A Java API for Ontology Management
JENA: A Java API for Ontology Management Hari Rajagopal IBM Corporation Page Agenda Background Intro to JENA Case study Tools and methods Questions Page The State of the Web Today The web is more Syntactic
More informationCS508-Modern Programming Solved MCQ(S) From Midterm Papers (1 TO 22 Lectures) BY Arslan
CS508-Modern Programming Solved MCQ(S) From Midterm Papers (1 TO 22 Lectures) BY Arslan April 18,2017 V-U For Updated Files Visit Our Site : Www.VirtualUstaad.blogspot.com Updated. MidTerm Papers Solved
More informationHandout 9: Imperative Programs and State
06-02552 Princ. of Progr. Languages (and Extended ) The University of Birmingham Spring Semester 2016-17 School of Computer Science c Uday Reddy2016-17 Handout 9: Imperative Programs and State Imperative
More informationPdOd Kev Events I Re-world war I1 rwa
I PdOd Kev Events I Re-world war I rwa LECTURE: Knowledge Representation Overview 0 'Qpes of knowledge: objects, events, meta-knowledge, etc. 0 Characteristics of representation: expressive adequacy vs.
More informationLinking Data with RDF
Linking Data with RDF Wiltrud Kessler Institut für Maschinelle Sprachverarbeitung Universität Stuttgart Semantic Web Winter 2014/15 This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike
More informationPart III Chapter 15: Subtyping
Part III Chapter 15: Subtyping Subsumption Subtype relation Properties of subtyping and typing Subtyping and other features Intersection and union types Subtyping Motivation With the usual typing rule
More informationCONVENTIONAL EXECUTABLE SEMANTICS. Grigore Rosu CS522 Programming Language Semantics
CONVENTIONAL EXECUTABLE SEMANTICS Grigore Rosu CS522 Programming Language Semantics Conventional Semantic Approaches A language designer should understand the existing design approaches, techniques and
More informationKnowledge Representation
Knowledge Representation References Rich and Knight, Artificial Intelligence, 2nd ed. McGraw-Hill, 1991 Russell and Norvig, Artificial Intelligence: A modern approach, 2nd ed. Prentice Hall, 2003 Outline
More informationLogical Grammar: Introduction to Hyperintensional S
Logical Grammar: Introduction to Hyperintensional Semantics Department of Linguistics Ohio State University July 8, 2011 What was Wrong with Montague Semantics? (1/2) Montague (late 1960s) was first to
More informationHandling time in RDF
Time in RDF p. 1/15 Handling time in RDF Claudio Gutierrez (Joint work with C. Hurtado and A. Vaisman) Department of Computer Science Universidad de Chile UPM, Madrid, January 2009 Time in RDF p. 2/15
More informationSOFTWARE ENGINEERING DESIGN I
2 SOFTWARE ENGINEERING DESIGN I 3. Schemas and Theories The aim of this course is to learn how to write formal specifications of computer systems, using classical logic. The key descriptional technique
More informationTowards Typed Prolog
Towards Typed Prolog Tom Schrijvers 1, Vitor Santos Costa 2, Jan Wielemaker 3, and Bart Demoen 1 1 Department of Computer Science, K.U.Leuven, Belgium 2 CRACS & FCUP, Universidade do Porto, Portugal 3
More information