Simplified Common Logic A flexible framework for information interchange based on first-order logic

Simplified Common Logic SCL ad-hoc working group (formed Dec 2002): Pat Hayes IHMC, US Christopher Menzel Texas A&M U., US John Sowa VivoMind, US Tanel Tammet U. Goteborg, Sweden Bill Anderson OntologyWorks, US Murray Altheim Open University, UK Harry Delugach U. of Alabama, US

conventional First-Order Logic Lexicon fixed by signature Lexicon is pre-sorted into relation/function/individual names One context-free syntax for expressing logical forms Only pure logical forms allowed No relations in the universe of discourse No global naming scheme

conventional First-Order Logic (GOFOL) Lexicon fixed by signature Lexicon is pre-sorted into relation/function/individual names One context-free syntax for expressing logical forms Only pure logical forms allowed No relations in the universe of discourse No global naming scheme All of this causes problems for interoperability and information exchange None of it is actually required by the FO semantics

conventional First-Order Logic (SCL) Lexicon fixed by signature No signature required Lexicon is pre-sorted into relation/function/individual names Lexical categories implicit One context-free syntax for expressing logical forms Syntactic options may be user-defined Only pure logical forms allowed SCL can be intermixed with other content, including XML markup No relations in the universe of discourse No restrictions on universe of quantification No global naming scheme Uses WWW standard URI conventions SCL is first-order logic with syntactic limitations removed and network use in mind.

SCL Overview The Kernel is a minimal language on which the semantics is defined. SCL syntax forms are defined as skins which wrap the kernel

SCL Overview:surface syntax Different surface syntax forms all map to the kernel, which provides a common central notation for processing and combining information. (forall (?x)(implies (and (P ?x) (R ?x)) (PR ?x)))) *x] [If: [P(?x) R(?x)] [Then: PR(?x)]] ( x)(P(x)&R(x) PR(x)) (x)not(P(x) R(x) not PR(x))

SCL Overview:ontology body::header name = Header specifies lexical categories, special assumptions, name classes Body contains asserted sentences (axioms) Both expressed as sets of SCL sentences Ontology name is URI

SCL Overview:ontology headers (( (?x)not(scl:Rel(?x) scl:Ind(?x)) ;;GOFOL syntax scl:Rel(Married Kissed Boy Girl) ;;relation names scl:Ind(Jack Jill) ;; individual names scl:Arity(2 Kissed) ;; Kissed can take 2 arguments 2 =scl:Arity(Married) ;;Married must take 2 arguments 1 =scl:Arity(Boy) ;;end of header )::( Boy(Jack);;beginning of body (?x)not(Boy(?x) (?y)not (Kissed(?x ?y) Girl(?y) ) ;;every boy kissed a girl Married(Jack Jill) )) Header defines syntactic conditions on sentences in body Body contains asserted sentences expressing ontology content

SCL Overview:naming and importing (scl:ontology = (()::(?x)not(scl:Rel(?x) scl:Ind(?x)) ;;GOFOL syntax)) ) (( scl:import( ) scl:Rel(Married Kissed Boy Girl) ;;relation names scl:Ind(Jack Jill) ;; individual names scl:Arity(2 Kissed) ;; Kissed can take 2 arguments 2 =scl:Arity(Married) ;;Married must take 2 arguments 1 =scl:Arity(Boy) ;;end of header )::( Boy(Jack);;beginning of body (?x)not(Boy(?x) (?y)not (Kissed(?x ?y) Girl(?y) ) ;;every boy kissed a girl Married(Jack Jill) ))

SCL Overview:ontology headers One can put it all in the body, and always have an empty header: (( )::( scl:import( ) scl:Rel(Married Kissed Boy Girl) scl:Ind(Jack Jill) scl:Arity(2 Kissed) 2 =scl:Arity(Married) 1 =scl:Arity(Boy) Boy(Jack) (?x)not(Boy(?x) (?y)not (Kissed(?x ?y) Girl(?y) ) Married(Jack Jill) )) This is satisfiable iff the original is, but now one cannot distinguish semantic from syntactic errors: they both appear as logical inconsistencies. The same semantics handles headers and bodies in a uniform way.

SCL semantics One universe of discourse; all quantifiers range over it. Relations may be in the universe, or may not. Functions are treated as a special class of relations. To allow a fully general syntax, we distinguish relations from their extensions. This also allows intensional theories of relations, providing extra flexibility. (Similar to treatment in RDF.)

SCL semantics:FIT A lexicon is just a set of names, all with the same status. Interpretations are required to provide a meaning for any term which can be constructed from these names (i.e., in effect, for the Herbrand universe): this is called the fitting condition. They are also required to be extendable so as to satisfy the header (relations mentioned in the header are not required to be in the ontology universe). Interpretations which do not satisfy the header are considered to be illegal. All of this allows the signature to be determined by the semantic interpretation, and so described in a uniform way in SCL itself.

The SCL Kernel Intended for metamathematical use in writing specifications and processing by software. Minimal syntax, not very readable, but easy to define syntactic mappings into and to define semantics clearly and transparently. Completely defines the semantics of all SCL surface syntax forms.

The SCL Kernel: terms and atoms No lexical distinction between relation names, individual names or variables: all referring expressions are treated uniformly. Terms and atoms formed by applying a term to a sequence of terms; no syntactic restrictions on what symbols appear where. married(Jack Jill) when(married(Jack Jill))=3pm(thursday(week(12 year(1997)))) married(x) wife(x)=Jill ConjugalStatus(married Jack) ConjugalStatus(Jill)(Jack)

The SCL Kernel: terms and atoms No lexical distinction between relation names, individual names or variables: all referring expressions are treated uniformly. The same name may play many roles at the same time: married(Jack Jill) binary relation when(married(Jack Jill))=3pm(thursday(week(12 year(1997)))) binary function married(x) wife(x)=Jill unary predicate ConjugalStatus(married Jack) individual entity ConjugalStatus(Jill)(Jack) value of a function and also a unary predicate, but not mentioned explicitly. All of these can be used in the same ontology, preserving their intended meanings.

The SCL Kernel: sequence vars seqVars can be used to indicate an arbitrary sequence of any finite length. stands for the infinite set a(x) (z) a(x z) (z z) a(x z z) (z z z) a(x z z z) …

The SCL Kernel: sequence vars This axiom scheme convention allows a form of inductive definition to be used at the top level in SCL, e.g. list()=nil entails all sentences like: list(a b c d)=cons(a cons(b cons(c cons(d nil)))) So together with iff can be used to render all argument sequences as explicit lists and hence defines the standard trick (used in RDF and OWL, for example) for mapping n-ary relations into unary predicates.

The SCL Kernel: logic and not forall (a b c … ) not a (a) b That is all.

The SCL Kernel: headers, etc. Headers ((header)::(body)) Definitions (ontology = (( header)::(body)) Importations import( ) Special forms: numerals, quoted strings Special names: scl:Arity scl:Ind scl:Rel scl:Fun intended for use in headers

The SCL Core role-set syntax for atomic sentences eg Married{wife=Jill husband=Jack} restricted (sorted) quantifiers eg forall (x:human) exists (y:dog) Intended as a canonical SCL syntax for human-oriented readability. Can be viewed as an SCL skin. Completely reducible to the kernel syntax. Extends Kernel to full FO notation with several convenient features, including:

SCL skin 1: KIF Most of KIF 3.0 syntax can be immediately transcribed into the SCL kernel as a simple skin. ( Exceptions: definitions; quantified sequence variables (free are OK); function/relation convention is modified )

SCL skin 2: Concept Graphs CG syntax represented as can be immediately transcribed into the SCL kernel as a skin, and indeed vice versa. ( sequence variables map into applications of relations to lists, which are described in an SCL header. )

SCL skin 3: RDF/OWL RDF(S) maps directly to the conjunctive/existential case of SCL ( Datatyped literals are handled by functions. ) OWL-DL maps to the first-order subcase of SCL using a conventional embedding of description logics to FOL.

SCL: work still to do 1.Finish specification of XML-based interchange syntax 2.Write up detailed account of skin-fitting algorithm 3.Provide general criteria for conformance of alternative syntaxes 4.Establish clear guidelines for embedding SCL into conventional FO syntax using holds/app translation, with equality, to provide for SCL inference using conventional reasoning engines. Projected date for draft document is mid-January 2004