Provided by: swap-cwm_1.2.1-7_all bug


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


       Command line RDF/N3 tool

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


       --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)

              Input & Output ** in RDF and set given RDF flags

              Input & Output in N3 and set N3 flags

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

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

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

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

              Store input and regurgitate in subject order *

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

                     Set  the  base URI. Input or output is done as though this were the document

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

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

                     Read patches from foo, applying insertions and deletions to store

                     Read rules from foo, apply to store, REPLACING store with conclusions

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

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

                     Apply rules in store to store, adding conclusions to store

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

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

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

                     proof tries to be shorter

                     Set modus operandi for inference (see below)

                     Replace the statements in the store with statements describing them.

                     Undo the effects of --reify

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

                     Undo the effects of --flatten

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

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

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

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

                     Enable processing of crypto builtin functions. Requires python crypto.

              --help print this message

                     print CVS revision numbers of major modules

                     Verbose debugging output of questionable use, range 0-99

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

                     After sparql query, print in sparqlResults format instead of rdf


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

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


       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  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

              Note:  The  parser   (sax2rdf)   does   not   support   reification,   bagIds,   or

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