1.0.1. Terminology

The following terms are used in this specification. These terms extend the definitions in [RFC2119] in ways based upon similar definitions in ISO/IEC 9945-1:1990 [POSIX.1]. When these terms appear in the text in bold face, they are to be interpreted as follows:

May

With respect to implementations, the word "may" is to be interpreted as an optional feature that is not required in this specification but can be provided. With respect to Conformance, the word "may" means that the optional feature must not be used. The term "optional" has the same definition as "may".

Must

In this specification, the word "must" is to be interpreted as a mandatory requirement on an XCL application or on XCL documents, depending upon the context. The terms "require" and "shall" have the same definition as "must".

Should

With respect to implementations, the word "should" is to be interpreted as an implementation recommendation, but not a requirement. With respect to documents, the word "should" is to be interpreted as recommended authoring practice for documents and a requirement for XCL documents.

Reserved

A value or syntactical expression defined (or undefined but declared) by this specification, and not allowed to be altered in meaning, use, or interpretation.

Supported

Certain facilities in this specification are optional. If a facility is supported, it behaves as specified by this specification.

Unspecified

When a value or behavior is unspecified, the specification defines no requirements for a facility on an implementation even when faced with a document that uses the facility. A document that requires specific behavior or interpretation in such an instance, rather than tolerating any behavior or interpretation when using that facility, is not a conforming XCL document.

Implementation-defined

A value or behavior is implementation-defined when it is left to the implementation to define [and document] the corresponding requirements for correct document construction.

1.1. Document Structures

Internal structures within XML documents are called content models; these describe the various possible ways that elements can be nested within a valid XCL document. XCL has a few basic sentence-level content models declared within the XCL DTD as "classes", as shown below. Though common in SGML and XML DTDs, this use of "class" is not a formal term of art.

An XCL sentence (i.e., %Sentence.class; within the XCL DTD) is composed of one element from either the Quantified, Boolean or Atomic sentence classes, as shown below:

  Quantified.class  ::=  quantified | forall | exists

  Boolean.class  ::=  boolean | and | or | implies | iff | not

  Atomic.class  ::=  atomic | relation | equal

  Sentence.class  ::= Quantified.class | Boolean.class | Atomic.class

[Section incomplete]

1.2. XCL Attributes

The 'xmlns' and 'id' attributes are declared on all XCL element types (though they are not included in the documentation for each element type).

The 'dialect' attribute is used to indicate the dialect of its element's content. 'dialect' is a linking attribute whose value (a URI reference) contains a reference to one of the fixed set of CL dialect identifiers:

  http://purl.org/xcl/1.0/#dialect-xcl
  http://purl.org/xcl/1.0/#dialect-clif  
  http://purl.org/xcl/1.0/#dialect-cgif 

For other concrete syntax representations, a suitable URI indicating the dialect should be used. In all XCL elements for which the 'dialect' attribute is declared, its absence indicates the default: the XCL dialect defined by the XCL 1.0 DTD.

Note that the presence of a 'dialect' attribute overrides any 'dialect' attributes on parent elements; however, such parent-child dialect clashes are deprecated.

This attribute is declared on the <text>, <module>, <import>, and <phrase> elements.

Example

    <?xml version="1.0"?>
    <text xmlns="http://purl.org/xcl/1.0/"
          dialect="http://purl.org/xcl/1.0/#dialect-clif">
      (forall ex:romanceNovel ((x man)) (exists ((y woman))
      (and (loves x y) (not (loves y x))) ))
    </text>

1.3. Comments

When well-formed XML processing is acceptable (see the section on XCL conformance), <comment> elements can comprise any text, can be mixed content, and can have any user-defined attributes; they are ignored by logical processors, but conforming XCL applications are required to preserve them and their position relative to other elements. Comments inside other comments are considered to be comments on the comment. In most cases, XCL content models include comments as the last children of the parent element.

Note that XCL markup inside a comment is not considered to be part of the XCL containing element, and must also be suitably escaped.

For situations where rich comment markup is desired but valid XCL is required, comments may contain a link to an external documentation source using the 'href' attribute:

  <comment href="http://www.acme.com/docs/sec7.html"/>

If both element content and the 'href' attribute are present, the latter is considered optional, i.e., traversing the link is not considered essential to ascertain the contents of the comment.

With appropriate XML Namespace declarations, the %Comment.class; parameter entity can be redeclared to contain alternative XML content, e.g., XHTML or DocBook.

Ed.Note:  It's been noted that the draft recently submitted to ISO did not include a 'xml:lang' attribute on the <comment> element. This was an oversight on my part, and Harry Delugach (the ISO draft editor) has indicated that he will include this suggestion as a US comment.

2.1. XCL Document Element

An XCL document may use an <text> element as the document (or "root") element. This specification does not require XCL documents to use the <text> as a document element, but XML documents must have a single document element, hence it may be used when needed, as a semantic-free wrapper.

The optional xml:base attribute is also declared for optionally defining the base URI of the XCL document.

Using the available "prefixed" DTD (as described in the Use of XCL with Other XML Markup), XCL may be used with or without XML namespace prefixes, enabling intermixing with other XML markup languages.

Example

    <?xml version="1.0"?>
    <text xmlns="http://purl.org/xcl/1.0/">
      <module href="http://www.acme.com/vocab/#agent-vocab">
        ...
      </module>
    </text>

For examples of namespace-prefixed XCL documents, see Appendix E.

    http://purl.org/xcl/1.0/

    <?xml version="1.0"?>
    <!DOCTYPE text PUBLIC "-//purl.org/xcl//DTD XML Common Logic (XCL) 1.0//EN"
                          "http://purl.org/xcl/1.0/xcl1.dtd">
    <text xmlns="http://purl.org/xcl/1.0/">
      
    </text>

2.2. Module Element

An XCL module is a fragment of XCL markup which has special attributes and satisfies certain extra constraints. An XCL document may comprise a single module, so this element, if present, will be the single child element of the <text> document element; in this case the module wrapper is not required.

The <module> element's 'href' attribute serves as one means of identifying the module, the other being use of the 'id' attribute used with the base URI of the document to form an identifier. This specification does not recommend one method over the other, as this is considered application-dependent. The latter has the advantage of tying the module URI to the base URI of the document (which may be considered a feature or a bug) but then relies upon the presence of the 'xml:base' attribute on the <text> element. In its absence the base URI is considered arbitrary.

Example

    <?xml version="1.0"?>
    <text xmlns="http://purl.org/xcl/1.0/">
      <module href="http://www.acme.com/vocab/#agent-vocab">
        ...
      </module>
    </text>

2.3. Phrase Element

Example

    <?xml version="1.0"?>
    <text xmlns="http://purl.org/xcl/1.0/">
      <phrase>
        ...
      </phrase>
    </text>

2.4. Import Element

Example

    <?xml version="1.0"?>
    <text xmlns="http://purl.org/xcl/1.0/">
      <import href="http://www.acme.com/vocab/agent-vocab.xcl"/>
    </text>

2.5. Exclude Element

This element is used to indicate that these terms do not denote "things" in the current ontology, i.e. that they are nondenoting operators not included in the local domain of quantification. This allows an ontology to have strict control over the size of its intended domain of discourse.Names not listed in such a header are treated as denoting terms in the ontology.

Nondenoting terms can be used only in the relation or function position of atoms and terms in this module. They cannot be used as arguments or be bound by quantifiers in this module. Note however that a term may be nondenoting in one ontology but denoting in another ontology: the assignment of nondenoting status is local to this module.

Example

    <?xml version="1.0"?>
    <text xmlns="http://purl.org/xcl/1.0/">
      <exclude>
        <term name="cow"/>
        <term name="pig"/>
        <term name="moose"/>
      </exclude>
    </text>

3. Sentence Elements

    <forall>
      ...
    </forall>

    <quantified syntaxType="http://purl.org/xcl/1.0/#forall">
      ...
    </quantified>

    <text xmlns="http://purl.org/xcl/1.0/">
      <forall logicalFormOf="http://acme.com/rulespec/#hornrule">
        ...
      </forall>
    <text>

    <?xml version="1.0"?>
    <text xmlns="http://purl.org/xcl/1.0/">
      TBD
    </text>

    <?xml version="1.0"?>
    <text xmlns="http://purl.org/xcl/1.0/">
      TBD
    </text>

    <?xml version="1.0"?>
    <text xmlns="http://purl.org/xcl/1.0/">
      TBD
    </text>

    <?xml version="1.0"?>
    <text xmlns="http://purl.org/xcl/1.0/">
      <forall>
        <guard>
          <term name="cow"/>
        </guard>
        TBD
      </forall>
    </text>

    <?xml version="1.0"?>
    <text xmlns="http://purl.org/xcl/1.0/">
      TBD
      ...
      <var name="person"/>
      ...
    </text>

    <and> </and>
    <or> </or>
    <not> </not>
    <implies> </implies>
    <iff> </iff>

    <?xml version="1.0"?>
    <text xmlns="http://purl.org/xcl/1.0/">
      <boolean syntaxType="http://purl.org/xcl/1.0/#and">
        ...
      </boolean>
    </text>

    <?xml version="1.0"?>
    <text xmlns="http://purl.org/xcl/1.0/">
      TBD
    </text>

    <?xml version="1.0"?>
    <text xmlns="http://purl.org/xcl/1.0/">
      TBD
    </text>

    <?xml version="1.0"?>
    <text xmlns="http://purl.org/xcl/1.0/">
      TBD
    </text>

    <?xml version="1.0"?>
    <text xmlns="http://purl.org/xcl/1.0/">
      TBD
    </text>

    <?xml version="1.0"?>
    <text xmlns="http://purl.org/xcl/1.0/">
      TBD
    </text>

    <?xml version="1.0"?>
    <text xmlns="http://purl.org/xcl/1.0/">
      TBD
    </text>

    <?xml version="1.0"?>
    <text xmlns="http://purl.org/xcl/1.0/">
      <atomic>
        TBD
      </atomic>
    </text>

    <?xml version="1.0"?>
    <text xmlns="http://purl.org/xcl/1.0/">
      TBD
    </text>

    <?xml version="1.0"?>
    <text xmlns="http://purl.org/xcl/1.0/">
      <relation>
        TBD
      </relation>
    </text>

    <?xml version="1.0"?>
    <text xmlns="http://purl.org/xcl/1.0/">
      <equal>
        <term name="Robert Dobbs"/>
        <term name="Bob Dobbs"/>
      </equal>
    </text>

    <?xml version="1.0"?>
    <text xmlns="http://purl.org/xcl/1.0/">
      <atomic href="http://purl.org/xcl/1.0/#roleset">
        <relation>married</relation>
        <role name="wife">
          <term name="Jill"/>
        </role>
        <role name="husband">
          <term name="Jack"/>
        </role>
      </atomic>
    </text>

    <?xml version="1.0"?>
    <text xmlns="http://purl.org/xcl/1.0/">
      TBD
      <term>
        <function>
          <term name="pig"/>
          <term name="cow"/>
        </function>
        <term name="barnyard"/>
      </term>

    </text>

    <?xml version="1.0"?>
    <text xmlns="http://purl.org/xcl/1.0/">
      TBD
      <term name="cow"/>

    </text>

    <?xml version="1.0"?>
    <text xmlns="http://purl.org/xcl/1.0/">
      <function>
        TBD
      </function>
    </text>

4. XCL Semantics

Common Logic can be rendered into XCL directly, in a form which displays the Common Logic syntax directly in the XML markup. This is analogous to "content markup" in MathML [9]... [Section incomplete]

5. XCL Conformance

[Section incomplete]

Appendix A. Acknowledgments

Nothing exists in a vacuum, and this specification did not arise out of thin air. The author wishes to acknowledge the existing CL and SCL documents posted publicly (as found in the References section below), as well as public and private discussions over the past few years with various individuals, including Jon Awbrey, Harry Delugaph, Patrick Hayes, Chris Menzel, John Sowa, and Tanel Tammet.

The basic XML syntax of the earlier version of this specification was derived from XML concrete syntax early internal draft [SCL-TT] by Tanel Tammet. The syntax of the XCL 1.0 version submitted to ISO is derived from ideas found in the earlier syntax and some very helpful notes from Pat Hayes.

Appendix B. Published Subjects for XML Common Logic

PSI Metadata

Following is the Published Subject Indicator (PSI) metadata for the XCL 1.0 Specification:

Index Of Published Subjects

This is the complete list of Published Subjects established by the XCL 1.0 specification. Not noted previously is that the PURL (permanent URL) for this specification is both the XML Namespace URI for and may be used as the PSI to refer to the XCL 1.0 Specification.

Note that each subject in the first column above is a link to its documentation herein.

Appendix C. XML Common Logic (XCL) 1.0 DTD

The XCL 1.0 DTD is shown below, and is also available as a separate file, xcl1.dtd. The XCL 1.0 DTD is available in three versions. In addition to the default version, it is also available in a commented, unprefixed version xcl1c.dtd and an uncommented, "xcl:"-prefixed version xcl1p.dtd.

A package of files, including the XCL 1.0 DTDs, XML catalog file, SGML declarations for XML (one compatible with James Clark's nsgmls), and some short sample XCL test files, [will be] available as a zip file xcl1-dtd.zip (11K). A complete distribution of the XCL 1.0 Specification and all DTD files is also available upon request.

    <!-- ....................................................................... -->
    <!-- XML Common Logic 1.0 DTD  ............................................. -->
    <!-- file: xcl1.dtd
    -->
    
    <!-- XML Common Logic 1.0 DTD
    
         This is XCL, a formulation of Common Logic as an XML application.
         Copyright 2005 ISO/IEC All Rights Reserved.
    
         Permission to use, copy, modify and distribute the XCL DTD and its
         accompanying documentation for any purpose and without fee is hereby
         granted in perpetuity, provided that the above copyright notice and
         this paragraph appear in all copies.  The copyright holders make no
         representation about the suitability of the DTD for any purpose.
    
         It is provided "as is" without expressed or implied warranty.
    
            Authors:    Murray M. Altheim <m.altheim@open.ac.uk>
                        Pat Hayes <phayes@ihmc.us>
            Status:     Draft
            Revision:   $Id: index.html,v 1.11 2005/12/16 10:47:36 altheim Exp $
    
         This DTD has the following formal public identifiers:
    
             "ISO/IEC 24707:2006//DTD XML Common Logic (XCL) 1.0//EN"
    
             "-//purl.org/xcl//DTD XML Common Logic (XCL) 1.0//EN"
    
         The DTD may be invoked by one of the following declarations:
    
             <!DOCTYPE text PUBLIC
                 "ISO/IEC 24707:2006//DTD XCL Markup Language//EN">
                 "xcl1.dtd">
    
             <!DOCTYPE text PUBLIC
                 "-//purl.org/xcl//DTD XML Common Logic (XCL) 1.0//EN"
                 "xcl1.dtd">
    
         where the system identifier ("xcl1.dtd") may be customized as
         necessary to specify the location of the DTD.
    
         If there is any perceived difference between the prose of the
         ISO standard and the XCL DTD, the former should be considered
         authoritive.
    -->
    
    <!-- a Uniform Resource Identifier, see clause 3.24 and [7]
    -->
    <!ENTITY % URI.datatype "CDATA" >
    
    <!-- XML namespace support ....................................... -->
    
    <!-- The XML Namespace URI for XCL 1.0 is
    
           "http://purl.org/xcl/1.0/"
    -->
    
    <!ENTITY XCL1.xmlns "http://purl.org/xcl/1.0/" >
    
    <!-- C.1. General Syntax ................................................... -->
    
    <!-- C.1.1 Content Models .............................. -->
    
    <!ENTITY % Quantified.class
        "( quantified | forall | exists )"
    >
    
    <!ENTITY % Boolean.class
        "( boolean | and | or | implies | iff | not )"
    >
    
    <!ENTITY % Atomic.class
        "( atomic | relation | equal )"
    >
    
    <!ENTITY % Sentence.class
        "( %Quantified.class; | %Boolean.class; | %Atomic.class; )"
    >
    
    <!ENTITY % Comment.class
       "comment"
    >
    
    <!-- C.1.2 Attributes .................................. -->
    
    <!ENTITY % XCL.xmlns.attrib
        "xmlns         %URI.datatype;      #FIXED '&XCL1.xmlns;'"
    >
    
    <!ENTITY % id.attrib
        "id            ID                  #IMPLIED"
    >
    
    <!ENTITY % Common.attrib
        "%XCL.xmlns.attrib;
         %id.attrib;"
    >
    
    <!-- C.1.2.2 CL Dialect Attribute ............ -->
    
    <!-- Name:         dialect
         URI:          http://purl.org/xcl/1.0/#dialect
         Declares:     http://purl.org/xcl/1.0/#dialect-xcl
                       http://purl.org/xcl/1.0/#dialect-clif
                       http://purl.org/xcl/1.0/#dialect-cgif
         Label:        CL Dialect
         Description:  see clauses 3.8, 7.1
    -->
    
    <!ENTITY XCL.dialect  "http://purl.org/xcl/1.0/#dialect-xcl"  >
    <!ENTITY CLIF.dialect "http://purl.org/xcl/1.0/#dialect-clif" >
    <!ENTITY CGIF.dialect "http://purl.org/xcl/1.0/#dialect-cgif" >
    
    <!ENTITY % dialect.attrib
      "dialect         %URI.datatype;      '&XCL.dialect;'"
    >
    
    <!-- C.1.3 Comments .................................... -->
    
    <!-- Name:         comment
         URI:          http://purl.org/xcl/1.0/#comment
         Label:        Comments
         Description:  see clause 6.1.1.3
    -->
    
    <!ENTITY % Comment.content
       "( #PCDATA | %Comment.class; )*"
    >
    <!ELEMENT comment  %Comment.content; >
    <!ATTLIST comment
       %Common.attrib;
       href            %URI.datatype;      #IMPLIED
    >
    
    <!-- C.2. Top Level Elements ............................................... -->
    
    <!-- C.2.1 XCL Document Element ........................ -->
    
    <!-- Name:         text
         URI:          http://purl.org/xcl/1.0/#text
         Label:        XCL document element
         Description:  see clause 6.1.1.1
    -->
    
    <!ENTITY % Text.content
       "( module | phrase | %Comment.class; )*"
    >
    <!ELEMENT text  %Text.content; >
    <!ATTLIST text
       %Common.attrib;
       xml:base        %URI.datatype;      #IMPLIED
       %dialect.attrib;
    >
    
    <!-- C.2.2 XCL Modules ................................. -->
    
    <!-- Name:         module
         URI:          http://purl.org/xcl/1.0/#module
         Label:        XCL Module
         Description:  see clause 6.1.1.4
    -->
    
    <!ENTITY % Module.content
       "( import | exclude | phrase | %Comment.class; )*"
    >
    <!ELEMENT module  %Module.content; >
    <!ATTLIST module
       %Common.attrib;
       href            %URI.datatype;      #REQUIRED
       %dialect.attrib;
    >
    
    <!-- C.2.3 Phrase Element .............................. -->
    
    <!-- Name:         phrase
         URI:          http://purl.org/xcl/1.0/#phrase
         Label:        Phrase
         Description:  see clause 6.1.1.2
    -->
    
    <!ENTITY % Phrase.content
       "( %Sentence.class;, %Comment.class;* )"
    >
    <!ELEMENT phrase  %Phrase.content; >
    <!ATTLIST phrase
       %Common.attrib;
       %dialect.attrib;
    >
    
    <!-- C.2.4 Import Element .............................. -->
    
    <!-- Name:         import
         URI:          http://purl.org/xcl/1.0/#import
         Label:        Import
         Description:  see clause 6.1.1.5
    -->
    
    <!ENTITY % Import.content
       "( %Comment.class;* )"
    >
    <!ELEMENT import  %Import.content; >
    <!ATTLIST import
       %Common.attrib;
       href            %URI.datatype;      #REQUIRED
       %dialect.attrib;
    >
    
    <!-- C.2.5 Exclude Element ............................. -->
    
    <!-- Name:         exclude
         URI:          http://purl.org/xcl/1.0/#exclude
         Label:        Module Exclusions
         Description:  see clause 6.1.1.4
    -->
    
    <!ENTITY % Exclude.content
       "( term )*"
    >
    <!ELEMENT exclude  %Exclude.content; >
    <!ATTLIST exclude
       %Common.attrib;
    >
    
    <!-- C.3. Sentence Elements ................................................ -->
    
    <!-- C.3.0.1 syntaxType Attribute ...................... -->
    
    <!-- Name:         syntaxType
         URI:          http://purl.org/xcl/1.0/#syntaxType
         Label:        Syntax Type
         Description:  see clauses C.3.1.3, C.3.2.6
    -->
    
    <!ENTITY % syntaxType.attrib
      "syntaxType      %URI.datatype;      #IMPLIED"
    >
    
    <!-- C.3.0.2 logicalFormOf Attribute ................... -->
    
    <!-- Name:         logicalFormOf
         URI:          http://purl.org/xcl/1.0/#logicalFormOf
         Label:        Logical-Form-Of
         Description:  see TBD
    -->
    
    <!ENTITY % logicalFormOf.attrib
      "logicalFormOf   %URI.datatype;      #IMPLIED"
    >
    
    <!-- C.3.1 Quantified Sentence Elements .......................... -->
    
    <!ENTITY % Quantified.content
       "( guard?, var+, %Sentence.class;, %Comment.class;* )"
    >
    
    <!-- C.3.1.1 Forall Element ............................ -->
    
    <!-- Name:         forall
         URI:          http://purl.org/xcl/1.0/#forall
         Label:        Universal Quantifier
         Description:  see clause 6.1.1.7
    -->
    
    <!ELEMENT forall  %Quantified.content; >
    <!ATTLIST forall
       %Common.attrib;
       %logicalFormOf.attrib;
       syntaxType      %URI.datatype;      #FIXED 'http://purl.org/xcl/1.0/#forall'
    >
    
    <!-- C.3.1.2 Exists Element ............................ -->
    
    <!-- Name:         exists
         URI:          http://purl.org/xcl/1.0/#exists
         Label:        Existential Quantifier
         Description:  see clause 6.1.1.7
    -->
    
    <!ELEMENT exists  %Quantified.content; >
    <!ATTLIST exists
       %Common.attrib;
       %logicalFormOf.attrib;
       syntaxType      %URI.datatype;      #FIXED 'http://purl.org/xcl/1.0/#exists'
    >
    
    <!-- C.3.1.3 Quantified Sentence - Generic Form ........ -->
    
    <!-- Name:         quantified
         URI:          http://purl.org/xcl/1.0/#quantified
         Label:        Quantified Sentence - Generic Form
         Description:  see clauses 6.1.1.7, C.3.0.1
    -->
    
    <!ELEMENT quantified  %Quantified.content; >
    <!ATTLIST quantified
       %Common.attrib;
       sort            NMTOKEN             #IMPLIED
       href            %URI.datatype;      #REQUIRED
       %logicalFormOf.attrib;
       %syntaxType.attrib;
    >
    
    <!-- C.3.1.4 Guard Element ............................. -->
    
    <!-- Name:         guard
         URI:          http://purl.org/xcl/1.0/#guard
         Label:        Quantifier Guard
         Description:  see clauses A.2.3.8, C.3.1
    -->
    
    <!ENTITY % Guard.content
       "( term, %Comment.class;* )"
    >
    
    <!ELEMENT guard  %Guard.content; >
    <!ATTLIST guard
       %Common.attrib;
    >
    
    <!-- C.3.1.5 Variable Element .......................... -->
    
    <!-- Name:         var
         URI:          http://purl.org/xcl/1.0/#var
         Label:        Variable
         Description:  see TBD
    -->
    
    <!ENTITY % Var.content
       "( %Comment.class;* )"
    >
    
    <!ELEMENT var  %Var.content; >
    <!ATTLIST var
       %Common.attrib;
       name            NMTOKEN             #REQUIRED
       sort            NMTOKEN             #IMPLIED
    >
    
    <!-- C.3.2 Boolean Sentence Elements ............................. -->
    
    <!ENTITY % Boolean.content
       "( %Sentence.class; | %Comment.class; )*"
    >
    
    <!-- C.3.2.1 And Element ............................... -->
    
    <!-- Name:         and
         URI:          http://purl.org/xcl/1.0/#and
         Label:        Conjunction
         Description:  see clause 6.1.1.8
    -->
    
    <!ELEMENT and  %Boolean.content; >
    <!ATTLIST and
       %Common.attrib;
       %logicalFormOf.attrib;
       syntaxType      %URI.datatype;      #FIXED 'http://purl.org/xcl/1.0/#and'
    >
    
    <!-- C.3.2.2 Or Element ................................ -->
    
    <!-- Name:         or
         URI:          http://purl.org/xcl/1.0/#or
         Label:        Disjunction
         Description:  see clause 6.1.1.8
    -->
    <!ELEMENT or  %Boolean.content; >
    <!ATTLIST or
       %Common.attrib;
       %logicalFormOf.attrib;
       syntaxType      %URI.datatype;      #FIXED 'http://purl.org/xcl/1.0/#or'
    >
    
    <!-- C.3.2.3 Not Element ............................... -->
    
    <!-- Name:         not
         URI:          http://purl.org/xcl/1.0/#not
         Label:        Negation
         Description:  see clause 6.1.1.8
    -->
    <!ENTITY % Not.content
       "( %Sentence.class;, %Comment.class;* )"
    >
    <!ELEMENT not  %Not.content; >
    <!ATTLIST not
       %Common.attrib;
       %logicalFormOf.attrib;
       syntaxType      %URI.datatype;      #FIXED 'http://purl.org/xcl/1.0/#not'
    >
    
    <!-- C.3.2.4 Implies Element ........................... -->
    
    <!-- Name:         implies
         URI:          http://purl.org/xcl/1.0/#implies
         Label:        Implication
         Description:  see clause 6.1.1.8
    -->
    <!ENTITY % ImpliesIff.content
       "( ( %Sentence.class;, %Sentence.class; ), %Comment.class;* )"
    >
    
    <!ELEMENT implies  %ImpliesIff.content; >
    <!ATTLIST implies
       %Common.attrib;
       %logicalFormOf.attrib;
       syntaxType      %URI.datatype;      #FIXED 'http://purl.org/xcl/1.0/#implies'
    >
    
    <!-- C.3.2.5 Iff Element ............................... -->
    
    <!-- Name:         iff
         URI:          http://purl.org/xcl/1.0/#iff
         Label:        Biconditional
         Description:  see clause 6.1.1.8
    -->
    <!ELEMENT iff  %ImpliesIff.content; >
    <!ATTLIST iff
       %Common.attrib;
       %logicalFormOf.attrib;
       syntaxType      %URI.datatype;      #FIXED 'http://purl.org/xcl/1.0/#iff'
    >
    
    <!-- C.3.2.6 Boolean Sentence - Generic Form ........... -->
    
    <!-- Name:         boolean
         URI:          http://purl.org/xcl/1.0/#boolean
         Label:        Boolean Sentence - Generic Form
         Description:  see clauses 6.1.1.8, C.3.2
    -->
    <!ELEMENT boolean  %Boolean.content; >
    <!ATTLIST boolean
       %Common.attrib;
       sort            NMTOKEN             #IMPLIED
       href            %URI.datatype;      #REQUIRED
       %syntaxType.attrib;
    >
    
    <!-- C.3.3 Atomic Sentence Elements .............................. -->
    
    <!-- C.3.3.1 Atomic Element ............................ -->
    
    <!-- Name:         atomic
         URI:          http://purl.org/xcl/1.0/#atomic
         Label:        Atomic Sentence
         Description:  see 6.1.1.9
    -->
    
    <!ENTITY % Atomic.content
       "( relation, ( term* | role* ), %Comment.class;* )"
    >
    
    <!ELEMENT atomic  %Atomic.content; >
    <!ATTLIST atomic
       %Common.attrib;
       href            %URI.datatype;      #IMPLIED
       %logicalFormOf.attrib;
       %syntaxType.attrib;
    >
    
    <!-- C.3.3.2 Relation Element .......................... -->
    
    <!-- Name:         relation
         URI:          http://purl.org/xcl/1.0/#relation
         Label:        Relation
         Description:  see TBD
    -->
    
    <!ENTITY % Relation.content
       "( term, %Comment.class;* )"
    >
    <!ELEMENT relation  %Relation.content; >
    <!ATTLIST relation
       %Common.attrib;
    >
    
    <!-- C.3.3.3 Equal Element ............................. -->
    
    <!-- Name:         equal
         URI:          http://purl.org/xcl/1.0/#equal
         Label:        Equality
         Description:  see clause A.2.3.4
    -->
    
    <!ENTITY % Equal.content
       "( term, term )"
    >
    <!ELEMENT equal  %Equal.content; >
    <!ATTLIST equal
       %Common.attrib;
    >
    
    <!-- C.3.3.4 Role Element .............................. -->
    
    <!-- Name:         role
         URI:          http://purl.org/xcl/1.0/#role
         Label:        Role
         Description:  see clause A.2.3.5
    -->
    
    <!ENTITY % Role.content
       "( term, %Comment.class;* )"
    >
    <!ELEMENT role  %Role.content; >
    <!ATTLIST role
       %Common.attrib;
       name            NMTOKEN             #REQUIRED
    >
    
    <!-- C.3.4 Term and Function Elements ............................ -->
    
    <!-- C.3.4.1 Term Element .............................. -->
    
    <!-- Name:         term
         URI:          http://purl.org/xcl/1.0/#term
         Label:        Term
         Description:  see clause 6.1.1.10
    -->
    
    <!ENTITY % Term.content
       "( ( function, term+ )?, %Comment.class;* )"
    >
    <!ELEMENT term  %Term.content; >
    <!ATTLIST term
       %Common.attrib;
       name            CDATA               #IMPLIED
    >
    
    <!-- C.3.4.2 Function Element .......................... -->
    
    <!-- Name:         function
         URI:          http://purl.org/xcl/1.0/#function
         Label:        Function
         Description:  see clause 6.1.1.11
    -->
    
    <!ENTITY % Function.content
       "( term, %Comment.class;* )"
    >
    <!ELEMENT function  %Function.content; >
    <!ATTLIST function
       %Common.attrib;
    >
    
    <!-- Architectural support declaration ............................
    
         In order to use the XCL 1.0 document type definition as
         a base architecture for other SGML/XML applications, the
         following architectural support declaration should be used:
    
           <?IS24707
             arch name="xcl"
             public-id="ISO/IEC 24707:2006//DTD XML Common Logic (XCL) 1.0//EN"
             dtd-system-id="http://purl.org/xcl/1.0/xcl1.dtd"
             renamer-att="XCLnames"
             doc-elem-form="text"
           ?>
    -->
    
    <!-- end of XCL 1.0 DTD -->

Appendix D. Design Goals

Following is a list of design goals, derived in part from both the Design Principles of XML and the Design Goals of KIF. The order of this list is not presented according to any priority, and intermixes various design aspects. (Clicking on a list number provides a self-referential link to that list item.)

This section derived from the design goals found in the earlier prototype XCL specification.

1.1  XCL shall be compatible with CL (and by extension, KIF).

1. XCL should conform to the CL abstract model, as expressed in the CL standard (when available).
2. It should be a relatively straightforward process to convert core XCL documents to other CL concrete syntaxes.
3. The core features of XCL syntax should have essentially the same expressive power as CL.

1.2.  XCL shall be expressed in XML 1.0, and compliant with XML 1.0 processors.

XCL documents shall be processable using commonly-available XML parsers. This means compliance with the normative requirements of XML 1.0 (Third Edition), such as Unicode, use of IETF and ISO standards for the identification of languages and countries, etc.

Where existing features in the family of XML specifications exist, these features shall be not be reinvented for XCL. For example, expression of the base URI of an XCL document shall use XML Base (i.e., the xml:base attribute) rather than inventing a new syntax.

1.3.  XCL shall support a wide variety of applications.

No design elements shall be adopted which would impair the usability or extensibility of XCL documents in other contexts or applications.

1.4.  It shall be easy to write programs which process XCL documents.

In particular, it shall be straightforwardly possible to construct useful XCL applications which do not require processing of an XCL schema/DTD.

1.5.  The number of optional features in the core XCL syntax is to be kept to the absolute minimum, ideally zero.

As a result of this, any XCL document has a high probability of being handled successfully by any XCL processor.

1.6.  Writing XCL documents shall not require invention of new XML markup.

Whereas RDF encourages and often requires document authors to design new RDF markup, and HTML prohibits this (i.e., all HTML authors use the elements and attributes provided them in the "HTML tool kit"), there shall be a clear delineation between markup and document content in XCL, as in HTML. XCL document authors will use only XCL 1.0 markup, e.g., development of predicates will occur via PSIs rather than new XML elements or attributes.

Note: this is contrasted to extensions to XCL, which may require creation of XML markup (in an XML Namespace different than XCL 1.0). But when it is possible for such extensions to use the existing XCL syntax, designers are encouraged to avoid creation of new markup as much as possible.

1.7.  XCL shall not allow "arbitrary" XML, but rather provide a clear path for extensions to the core syntax.

As a result of this, the core syntax of an extended XCL document still has a high probability of being handled successfully by any XCL processor.

1.8.  XCL documents should be human-legible and reasonably clear.

This is to be accomplished partly by providing a core XCL syntax that does not use arcane or unnecessary XML features such as XML Namespace prefixes. Three DTDs will be provided: an unprefixed DTD, a prefix-enabled DTD (whose default is no prefix but is modifiable by instances' internal subsets), and a default prefixed ("xcl:") DTD. Note: all three DTDs express the same syntax; differences are only in XML Namespace prefix.

1.9.  The XCL design should be prepared quickly.

A first draft of the XCL design should be ready for distribution and comment by end of summer 2003; a version should be ready for production use by the end of winter 2003.

1.10.  The design of XCL shall be as computationally well-described and tractable as possible.

While this is a difficult goal to provide a metric for, this is to be met by keeping the core syntax as simple as possible.

1.11.  The design of XCL shall be formal and concise.

XCL should be simple and easy for implementors to grasp; its reference documentation should not exceed 20 pages, which should contain mostly formal grammar and very little normative text, if any. Note: normative text is not the same as descriptive or explanatory text.

1.12.  XCL documents shall be easy to create.

It should be a straightforward task (though possibly labor-intensive) to create valid XCL documents by hand (i.e. without a validating authoring tool).

It should be a straightforward task (though possibly labor-intensive) to create a validating XCL authoring system.

1.13.  Terseness is of minimal importance.

Minimizing keystrokes is not deemed important in achieving any of the above goals, but other things being equal a concise notation should be preferred to a verbose.

Note: The following goals are tentatively included from the "Level 2" goals found in the earlier prototype XCL specification.

1.14.  XCL shall include inter-document linking features.

It shall be possible to author XCL documents whose expressions span multiple files, for purposes of modularization and reuse.

1.15.  Linking features of XCL shall be expressed in XLink 1.0.

Rather than creating a proprietary linking syntax, the linking syntax for XCL shall be XLink 1.0, the linking language for XML.

1.16.  XCL documents shall be straightforwardly usable across the Internet.

XCL expressions shall be capable of being distributed across the Internet, for purposes of sharing and interchange (the latter requires that two expressions have a means of declaring concept identities).

1.17.  XCL shall enable the statement of subject identity.

When XCL documents are shared, or when concepts within a published XCL document are used by other XCL documents, the ability to establish subject identity is necessary. This is a concept derived from Topic Maps (ISO 13250:2000) essential for information interchange. E.g., absent subject identity, it is impossible to determine whether the logical terms in two different XCL documents refer to the same subject.

1.18.  XCL shall use the concept of Published Subject Indicators (PSIs).

All components of the XCL syntax shall enable sharing and identity matching of concepts using Published Subject Indicators (PSIs). [PSIs are simply URIs used as canonical identifiers for a subject, similar to RDF's use of "namespaces" based on URIs.]

1.19.  Documentation, description and extension features will use their own XML Namespaces.

The documentation features for XCL shall use a different XML Namespace, with XCL 1.0 supporting simple text data, and subsequent (extension) versions to use a subset of XHTML.

All extensions to XCL shall occur as either PSIs within the existing XCL 1.0 syntax, or as extensions within a different XML Namespace. The latter is discouraged as this limits interchange.

Appendix E. Use of XCL with Other XML Markup

This section includes information on namespace-prefixed use of XCL as well as extensions to XCL, which are either:

1. extensions to the XCL 1.0 syntax within the default XCL namespace, or specific XML namespaces (such as XHTML) as part of the XCL project. These are called "XCL Extensions", or
2. extensions to XCL syntax using non-XCL namespaces, or not as a work product of the XCL project. These are called "Non-XCL Extensions".

Using XCL with an XML Namespace Prefix

    <?xml version="1.0"?>
    <abc:xcl xmlns:abc="http://purl.org/xcl/1.0/">
      <abc:formula>

      </abc:formula>
    </abc:xcl>

    <?xml version="1.0"?>
    <!DOCTYPE xcl PUBLIC "-//purl.org/xcl//DTD XML Common Logic (XCL) 1.0 Level 2 Prefixed//EN"
                            "http://purl.org/xcl/1.0/xcl1-2p.dtd">
    <xcl:xcl xmlns:xcl="http://purl.org/xcl/1.0/">
      <xcl:formula>

      </xcl:formula>
    </xcl:xcl>

    <?xml version="1.0"?>
    <!DOCTYPE xcl PUBLIC "-//purl.org/xcl//DTD XML Common Logic (XCL) 1.0 Level 2 Prefixed//EN"
                         "xcl1-2p.dtd" [
      <!ENTITY % XCL.pfx "abc">
    ]>
    <abc:xcl xmlns:abc="http://purl.org/xcl/1.0/">
      <abc:formula>

      </abc:formula>
    </abc:xcl>

XCL Extensions

A possible extension to XCL would be to include an appropriate subset of XHTML markup within the declaration for the %Comment.class; for improved documentation support. Other extensions (within a separate XCL-based namespace) might be to add a single <modal:constraint> element that could express the modal logic constraint within which a statement is true. Given that such constraints are similar conceptually to "scope" in XML Topic Maps, XCL could possibly then be used as an alternative serialization syntax for Topic Maps. Likewise, Conceptual Graphs expressed in XCL would immediately be "web-friendly".

Extensions to XCL are expected to often be handled within the existing syntax by creating canonical identifiers (Published Subject Indicators, or PSIs) for new quantifiers, connectives and predicates. Because of the basic graph structure of XCL it is as flexible as RDF or XTM in expressing semantic structures.

    <?xml version="1.0"?>
    <!DOCTYPE xcl PUBLIC "-//purl.org/xcl//DTD XML Common Logic (XCL) 1.0//EN"
                            "http://purl.org/xcl/1.0/xcl1.dtd">
    <xcl xmlns="http://purl.org/xcl/1.0/">
      
    </xcl>

Non-XCL Extensions

XCL is designed as an interchange syntax for Common Logic, hence the intermixing of "arbitrary" XML markup within an XCL document would introduce an unknown measure of ambiguity. Would the added markup change the interpretation of a formula? Is it only a documentation feature? These are not properly the kinds of questions a computer can answer without assistance. To provide this assistance, all extensions to XCL should include (for humans) publicly-available documentation of the extensions, as well as an appropriate schema (e.g., XML 1.0 DTD, RELAX-NG schema, XML Schema). For the benefit of computers, extended XCL documents should be clearly marked, preferably with a DOCTYPE declaration.

Appendix F. Architectural Forms Support

In order to use the XCL 1.0 document type definition as a base architecture for other SGML/XML applications, the following architectural support declaration should be used:

    <?IS24707
      arch name="xcl"
      public-id="ISO/IEC 24707:2006//DTD XML Common Logic (XCL) 1.0//EN"
      dtd-system-id="http://purl.org/xcl/1.0/xcl1.dtd"
      renamer-att="XCLnames"
      doc-elem-form="text"
    ?>

Appendix G. References

[CL]

Common Logic Standard (home page)
See:  http://cl.tamu.edu/

[CL-PROP]

Common Logic NWI Proposal
See:  http://cl.tamu.edu/agreed/jtc1-nwi.pdf

[CL-TALK]

Common Logic : A Framework for a Family of Logic-Based Languages
See:  http://www.jfsowa.com/talks/clprop.htm

[ISO24707]

ISO/IEC 24707:2006 Common Logic (TBD)
See:  http://cl.tamu.edu/ (TBD)

[KR]

Knowledge Representation: Logical, Philosophical and Computational Foundations
John F. Sowa (2000). Pacific Grove, California: Brooks/Cole.

[POSIX.1]

ISO/IEC 9945-1:1990 Information Technology - Portable Operating System Interface (POSIX)
- Part 1: System Application Program Interface (API) [C Language],
Institute of Electrical and Electronics Engineers, Inc, 1990.

[SCL]

Abstract Syntax and Semantics for SCL
Chris Menzel (Ed.), Common Logic Working Group. (currently undated)
See:  http://cl.tamu.edu/docs/scl.html

[SCL-TT]

XML concrete syntax early internal draft,
Tanel Tammet, 29 April 2003. (email to SCL mailing list)
http://philebus.tamu.edu/pipermail/scl/2003-April/000125.html

[RFC2119]

RFC 2119: Key words for use in RFCs to Indicate Requirement Levels,
S. Bradner, March 1997.
See:  http://www.ietf.org/rfc/rfc2119.txt

[RFC2396]

RFC 2396: Uniform Resource Identifiers (URI): Generic Syntax,
T. Berners-Lee, R. Fielding, L. Masinter, August 1998.
See:  http://www.ietf.org/rfc/rfc2396.txt

[ProtoXCL]

XML Common Logic (XCL) 1.0, (prototype)
Murray Altheim, 8 May 2003.
See:  http://www.altheim.com/specs/xcl/1.0/xcl1-20030508.html

[XML 1.0]

Extensible Markup Language (XML) 1.0 (Third Edition),
Tim Bray, Jean Paoli, and C.M. Sperberg-McQueen, Eve Maler, François Yergeau, editors. World Wide Web Consortium, W3C Recommendation 4 February 2004.
See:  http://www.w3.org/TR/REC-xml.

[XLink]

XML Linking Language (XLink) Version 1.0.,
Steve DeRose, Eve Maler, David Orchard, editors. World Wide Web Consortium, W3C Recommendation 27 June 2001.
See:  http://www.w3.org/TR/xlink.
XLink processing depends on [XML 1.0], [XMLNS], [XML Base], and [RFC2396].

[XML Base]

XML Base (XBase),
Jonathan Marsh, editor. World Wide Web Consortium, W3C Recommendation 27 June 2001.
See:  http://www.w3.org/TR/xmlbase.

[XMLNS]

Namespaces in XML,
Tim Bray, Dave Hollander, and Andrew Layman, editors. Textuality, Hewlett-Packard, and Microsoft. World Wide Web Consortium, W3C Recommendation 14 January 1999.
See:  http://www.w3.org/TR/REC-xml-names/.