NAME

       cwm - Closed World Machine, an RDF/N3 semantic web data processor

DESCRIPTION

       Command line RDF/N3 tool

              <command> <options> <steps> [--with <more args> ]

OPTIONS

       --pipe Don't store, just pipe out *

       steps, in order left to right:

       --rdf  Input & Output ** in RDF/XML instead of n3 from now on

       --n3   Input & Output in N3 from now on. (Default)

       --rdf=flags
              Input & Output ** in RDF and set given RDF flags

       --n3=flags
              Input & Output in N3 and set N3 flags

       --ntriples
              Input & Output in NTriples (equiv --n3=usbpartane -bySubject -quiet)

       --language=x
              Input & Output in "x" (rdf, n3, etc)  --rdf same as: --language=rdf

       --languageOptions=y
              --n3=sp same as:  --language=n3 --languageOptions=sp

       --ugly Store input and regurgitate, data only, fastest *

       --bySubject
              Store input and regurgitate in subject order *

       --no   No output *
              (default is to store and pretty print with anonymous nodes) *

              --base=<uri>
                     Set  the  base URI. Input or output is done as though this were the document
                     URI.

              --closure=flags
                     Control automatic lookup  of  identifiers  (see  below)  <uri>          Load
                     document. URI may be relative to current directory.

              --apply=foo
                     Read rules from foo, apply to store, adding conclusions to store

              --patch=foo
                     Read patches from foo, applying insertions and deletions to store

              --filter=foo
                     Read rules from foo, apply to store, REPLACING store with conclusions

              --query=foo
                     Read  a  N3QL  query  from foo, apply it to the store, and replace the store
                     with its conclusions

              --sparql=foo
                     Read a SPARQL query from foo, apply it to the store, and replace  the  store
                     with its conclusions

              --rules
                     Apply rules in store to store, adding conclusions to store

              --think
                     as -rules but continue until no more rule matches (or forever!)

              --engine=otter
                     use otter (in your $PATH) instead of llyn for linking, etc

              --why  Replace the store with an explanation of its contents

              --why=u
                     proof tries to be shorter

              --mode=flags
                     Set modus operandi for inference (see below)

              --reify
                     Replace the statements in the store with statements describing them.

              --dereify
                     Undo the effects of --reify

              --flatten
                     Reify only nested subexpressions (not top level) so that no {} remain.

              --unflatten
                     Undo the effects of --flatten

              --think=foo
                     as -apply=foo but continue until no more rule matches (or forever!)

              --purge
                     Remove from store any triple involving anything in class log:Chaff

              --data Remove all except plain RDF triples (formulae, forAll, etc)

              --strings
                     Dump :s to stdout ordered by :k whereever { :k log:outputString :s }

              --crypto
                     Enable processing of crypto builtin functions. Requires python crypto.

              --help print this message

              --revision
                     print CVS revision numbers of major modules

              --chatty=50
                     Verbose debugging output of questionable use, range 0-99

              --sparqlServer
                     instead of outputting, start a SPARQL server on port 8000 of the store

              --sparqlResults
                     After sparql query, print in sparqlResults format instead of rdf

              finally:

              --with Pass any further arguments to the N3 store as os:argv values

                     * mutually exclusive ** doesn't work for complex cases :-/

EXAMPLES

       cwm --rdf foo.rdf --n3 --pipe
              Convert from rdf/xml to rdf/n3

       cwm foo.n3 bar.n3 --think
              Combine data and find all deductions

              cwm foo.n3 --flat --n3=spart

   Mode flags affect inference extending to the web:
       r      Needed to enable any remote stuff.

       a      When reading schema, also load rules pointed to by schema (requires r, s)

       E      Errors loading schemas of definitive documents are ignored

       m      Schemas  and  definitive  documents  loaded  are  merged  into  the  meta knowledge
              (otherwise they are consulted independently)

       s      Read the schema for any predicate in a query.

       u      Generate unique ids using a run-specific

       Closure flags are set to cause the working formula to be  automatically  expanded  to  the
       closure under the operation of looking up:

       s      the subject of a statement added

       p      the predicate of a statement added

       o      the object of a statement added

       t      the object of an rdf:type statement added

       i      any owl:imports documents

       r      any doc:rules documents

       E      errors are ignored --- This is independant of --mode=E

       n      Normalize IRIs to URIs

       e      Smush together any nodes which are = (owl:sameAs)

       See http://www.w3.org/2000/10/swap/doc/cwm  for more documentation.

       Setting  the  environment  variable  CWM_RDFLIB to 1 makes Cwm use rdflib to parse rdf/xml
       files. Note that this requires rdflib.

       Flags for N3 output are as follows:-

       a   Anonymous nodes should be output using the _: convention (p flag or not).   d    Don't
       use  default  namespace  (empty  prefix)  e    escape literals --- use \u notation i   Use
       identifiers from store - don't regen on output l   List syntax suppression. Don't use (..)
       n    No  numeric  syntax - use strings typed with ^^ syntax p   Prefix suppression - don't
       use them, always URIs in <> instead of qnames.  q   Quiet - don't  output  comments  about
       version  and  base  URI  used.  r   Relative URI suppression. Always use absolute URIs.  s
       Subject must be explicit for every statement. Don't use ";"  shorthand.   t    "this"  and
       "()" special syntax should be suppressed.  u   Use \u for unicode escaping in URIs instead
       of utf-8 %XX v   Use  "this log:forAll" for @forAll, and "this log:forAll" for "@forSome".
       /   If namespace has no # in it, assume it ends at the last slash if outputting.

       Flags for N3 input:

       B   Turn any blank node into an existentially qualified explicitly named node.

       Flags to control RDF/XML output (after --rdf=) areas follows:

       b   -  Don't  use  nodeIDs  for Bnodes c  - Don't use elements as class names d  - Default
       namespace supressed.  l  - Don't use RDF collection syntax for lists  r   -  Relative  URI
       suppression. Always use absolute URIs.  z  - Allow relative URIs for namespaces

              Flags to control RDF/XML INPUT (after --rdf=) follow:

       S      - Strict spec. Unknown parse type treated as Literal instead of error.

       T      - take foreign XML as transparent and parse any RDF in it

              (default is to ignore unless rdf:RDF at top level)

       L      - If non-rdf attributes have no namespace prefix, assume in local <#> namespace

       D      - Assume default namespace declared as local document is assume xmlns=""

       R      -  Do not require an outer <rdf:RDF>, treating the file as RDF content (opposite of
              T)

              Note:  The  parser   (sax2rdf)   does   not   support   reification,   bagIds,   or
              parseType=Literal.

              It does support the rest of RDF incl. datatypes, xml:lang, and nodeIds.