|  |  | 
__builtin__.dict(__builtin__.object)
Env
__builtin__.frozenset(__builtin__.object)
N3Set(__builtin__.frozenset, CompoundTerm)
__builtin__.object
ListView
Term
CompoundTerm
List
EmptyList
FragmentNil(EmptyList, Fragment)
NonEmptyList
N3Set(__builtin__.frozenset, CompoundTerm)
ErrorFlag(exceptions.TypeError, Term)
Existential
SkolemFunction
Literal
XMLLiteral
Node
AnonymousNode
AnonymousVariable
AnonymousExistential(AnonymousVariable, Existential)
AnonymousUniversal(AnonymousVariable, Universal)
LabelledNode
Fragment
BuiltIn
Function
MultipleFunction
GenericBuiltIn
FiniteProperty(GenericBuiltIn, Function, ReverseFunction)
HeavyBuiltIn
LightBuiltIn
RDFBuiltIn
ReverseFunction
MultipleReverseFunction
Symbol
Universal
exceptions.TypeError(exceptions.StandardError)
ArgumentNotLiteral
ErrorFlag(exceptions.TypeError, Term)
exceptions.ValueError(exceptions.StandardError)
UnknownType
 
 
| class AnonymousExistential(AnonymousVariable, Existential)
 |  |  | An anonymous node which is existentially quantified in a given context. Also known as a Blank Node, or "bnode" in RDF parlance.
 
 |  |  | Method resolution order:AnonymousExistentialAnonymousVariableAnonymousNodeNodeExistentialTerm__builtin__.object
 Methods defined here:
 
 __repr__(self)This method only used for debugging output - it can be ambiguous,as it is is deliberately short to make debug printout readable.
 
 output as XML qnames [http://www.w3.org/TR/REC-xml-names/#NT-QName].
 This could be beefed up to guarantee unambiguity.
 Methods inherited from AnonymousVariable:
 
 __init__(self, scope, uri=None)
 Methods inherited from AnonymousNode:
 
 asPair(self)
 classOrder(self)Anonymous ndoes are higher than symbols as the = smushingtries to minimize the order rank of the node which it adopts
 as the epresentative node of an equivalence class.
 compareTerm(self, other)Assume is also a Formula - see function compareTerm below
 freeVariables(self)
 generated(self)
 uriref(self)
 Methods inherited from Term:
 
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 doesNodeAppear(self, symbol)Does that node appear within this one
 This non-overloaded function will simply return if I'm equal to him
 occurringIn(self, vars)
 representation(self, base=None)The string represnting this in N3
 substituteEquals(self, bindings, newRedirections)Return this or a version of me with substitution made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with subsitution made
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 value(self)As a python value - by default, none exists, use self
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class AnonymousNode(Node)
 |  |  | Has no real URI except when needed for output. Goal is to eliminate use of ths URI in the code.
 The URI is however useful as a diagnostic, so we carry it
 when it is given.   It is NOT checked for uniqueness etc.
 This is a superclass of many things, including AnonymousExistential,
 which has a scope.
 
 |  |  | Method resolution order:AnonymousNodeNodeTerm__builtin__.object
 Methods defined here:
 
 __init__(self, store, uri=None)
 asPair(self)
 classOrder(self)Anonymous ndoes are higher than symbols as the = smushingtries to minimize the order rank of the node which it adopts
 as the epresentative node of an equivalence class.
 compareTerm(self, other)Assume is also a Formula - see function compareTerm below
 freeVariables(self)
 generated(self)
 uriref(self)
 Methods inherited from Term:
 
 __repr__(self)This method only used for debugging output - it can be ambiguous,as it is is deliberately short to make debug printout readable.
 
 output as XML qnames [http://www.w3.org/TR/REC-xml-names/#NT-QName].
 This could be beefed up to guarantee unambiguity.
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 doesNodeAppear(self, symbol)Does that node appear within this one
 This non-overloaded function will simply return if I'm equal to him
 occurringIn(self, vars)
 representation(self, base=None)The string represnting this in N3
 substituteEquals(self, bindings, newRedirections)Return this or a version of me with substitution made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with subsitution made
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 value(self)As a python value - by default, none exists, use self
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class AnonymousUniversal(AnonymousVariable, Universal)
 |  |  | Nodes which are introduced as universally quantified variables with no quotable URI
 
 |  |  | Method resolution order:AnonymousUniversalAnonymousVariableAnonymousNodeNodeUniversalTerm__builtin__.object
 Methods defined here:
 
 __init__(self, scope, uri=None)
 __repr__(self)This method only used for debugging output - it can be ambiguous,as it is is deliberately short to make debug printout readable.
 
 output as XML qnames [http://www.w3.org/TR/REC-xml-names/#NT-QName].
 This could be beefed up to guarantee unambiguity.
 asPair(self)
 Methods inherited from AnonymousNode:
 
 classOrder(self)Anonymous ndoes are higher than symbols as the = smushingtries to minimize the order rank of the node which it adopts
 as the epresentative node of an equivalence class.
 compareTerm(self, other)Assume is also a Formula - see function compareTerm below
 freeVariables(self)
 generated(self)
 uriref(self)
 Methods inherited from Term:
 
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 doesNodeAppear(self, symbol)Does that node appear within this one
 This non-overloaded function will simply return if I'm equal to him
 occurringIn(self, vars)
 representation(self, base=None)The string represnting this in N3
 substituteEquals(self, bindings, newRedirections)Return this or a version of me with substitution made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with subsitution made
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 value(self)As a python value - by default, none exists, use self
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class AnonymousVariable(AnonymousNode)
 |  |  | An anonymous node which is existentially quantified in a given context. Also known as a Blank Node, or "bnode" in RDF parlance.
 
 |  |  | Method resolution order:AnonymousVariableAnonymousNodeNodeTerm__builtin__.object
 Methods defined here:
 
 __init__(self, scope, uri=None)
 Methods inherited from AnonymousNode:
 
 asPair(self)
 classOrder(self)Anonymous ndoes are higher than symbols as the = smushingtries to minimize the order rank of the node which it adopts
 as the epresentative node of an equivalence class.
 compareTerm(self, other)Assume is also a Formula - see function compareTerm below
 freeVariables(self)
 generated(self)
 uriref(self)
 Methods inherited from Term:
 
 __repr__(self)This method only used for debugging output - it can be ambiguous,as it is is deliberately short to make debug printout readable.
 
 output as XML qnames [http://www.w3.org/TR/REC-xml-names/#NT-QName].
 This could be beefed up to guarantee unambiguity.
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 doesNodeAppear(self, symbol)Does that node appear within this one
 This non-overloaded function will simply return if I'm equal to him
 occurringIn(self, vars)
 representation(self, base=None)The string represnting this in N3
 substituteEquals(self, bindings, newRedirections)Return this or a version of me with substitution made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with subsitution made
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 value(self)As a python value - by default, none exists, use self
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
 
| class BuiltIn(Fragment)
 |  |  | This class is a supercalss to any builtin predicate in cwm. 
 A binary operator can calculate truth value given 2 arguments
 
 |  |  | Method resolution order:BuiltInFragmentLabelledNodeNodeTerm__builtin__.object
 Methods defined here:
 
 __init__(self, resource, fragid)
 eval(self, subj, obj, queue, bindings, proof, query)This function which has access to the store, unless overridden,calls a simpler one which uses python conventions.
 
 To reduce confusion, the inital ones called with the internals available
 use abreviations "eval", "subj" etc while the python-style ones use
 evaluate, subject, etc.
 Static methods defined here:
 
 __new__(cls, *args, **keywords)
 Data and other attributes defined here:
 
 all = []
 Methods inherited from Fragment:
 
 compareTerm(self, other)
 dereference(self, mode='', workingContext=None)dereference an identifyer, finding the semantics of its schema if any
 Returns None if it cannot be retreived.
 generated(self)A generated identifier?This arises when a document is parsed and a arbitrary
 name is made up to represent a node with no known URI.
 It is useful to know that its ID has no use outside that
 context.
 representation(self, base=None)Optimize output if prefixes available
 uriref(self)
 uriref2(self, base)
 Methods inherited from LabelledNode:
 
 classOrder(self)
 Methods inherited from Term:
 
 __repr__(self)This method only used for debugging output - it can be ambiguous,as it is is deliberately short to make debug printout readable.
 
 output as XML qnames [http://www.w3.org/TR/REC-xml-names/#NT-QName].
 This could be beefed up to guarantee unambiguity.
 asPair(self)Representation in an earlier format, being phased out 2002/08
 The first part of the pair is a constant number represnting the type
 see RDFSink.py.  the second is the value -- uri for symbols,
 string for literals
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 doesNodeAppear(self, symbol)Does that node appear within this one
 This non-overloaded function will simply return if I'm equal to him
 freeVariables(self)
 occurringIn(self, vars)
 substituteEquals(self, bindings, newRedirections)Return this or a version of me with substitution made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with subsitution made
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 value(self)As a python value - by default, none exists, use self
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class CompoundTerm(Term)
 |  |  | A compound term has occurrences of terms within it. Examples: List, Formula
 
 |  |  | Method resolution order:CompoundTermTerm__builtin__.object
 Methods inherited from Term:
 
 __init__(self, store)
 __repr__(self)This method only used for debugging output - it can be ambiguous,as it is is deliberately short to make debug printout readable.
 
 output as XML qnames [http://www.w3.org/TR/REC-xml-names/#NT-QName].
 This could be beefed up to guarantee unambiguity.
 asPair(self)Representation in an earlier format, being phased out 2002/08
 The first part of the pair is a constant number represnting the type
 see RDFSink.py.  the second is the value -- uri for symbols,
 string for literals
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 doesNodeAppear(self, symbol)Does that node appear within this one
 This non-overloaded function will simply return if I'm equal to him
 freeVariables(self)
 generated(self)Boolean Is this thing a genid - is its name arbitrary?
 occurringIn(self, vars)
 representation(self, base=None)The string represnting this in N3
 substituteEquals(self, bindings, newRedirections)Return this or a version of me with substitution made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with subsitution made
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 value(self)As a python value - by default, none exists, use self
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class EmptyList(List)
 |  |  |  | Method resolution order:EmptyListListCompoundTermTerm__builtin__.object
 Methods defined here:
 
 __getitem__(self, i)
 __repr__(self)
 classOrder(self)
 newList(self, value)
 occurringIn(self, vars)
 substituteEquals(self, bindings, newBindings)Return this or a version of me with substitution of equals made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with substitution made
 uriref(self)
 value(self)
 Methods inherited from List:
 
 __init__(self, store, first, rest)
 __iter__(self)The internal method which allows one to iterate over the statementsas though a formula were a sequence.
 __len__(self)The internal method which allows one to count the statementsas though a formula were a sequence.
 asSequence(self)Convert to a python sequence - NOT recursive
 doesNodeAppear(self, symbol)Does that particular node appear anywhere in this list
 This function is necessarily recursive, and is useful for the pretty
 printer. It will also be useful for the flattener, when we write it.
 freeVariables(self)
 prepend(self, first)
 Methods inherited from Term:
 
 asPair(self)Representation in an earlier format, being phased out 2002/08
 The first part of the pair is a constant number represnting the type
 see RDFSink.py.  the second is the value -- uri for symbols,
 string for literals
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 generated(self)Boolean Is this thing a genid - is its name arbitrary?
 representation(self, base=None)The string represnting this in N3
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class Env(__builtin__.dict)
 |  |  | An env is an immutable dict 
 you can hash it (if you want to)
 
 |  |  | Method resolution order:Env__builtin__.dict__builtin__.object
 Methods defined here:
 
 __getitem__(self, item)
 __hash__(self)
 __init__(self, other=None, keywords={})
 __repr__(self)
 __setitem__(self, item, val)
 asDict(self)
 bind = newBinding(self, var, val)
 canBind(self, var, val)
 copy(self)
 dereference(self, var)
 filter(self, varSet)
 flatten(self, other)Pull all of the bindings of other into a copy of self
 get(self, item, default=None)
 newBinding(self, var, val)
 substitution(self, node, *otherEnvs)
 update(self, d2)
 update2(self, d2)
 Data and other attributes defined here:
 
 __slots__ = ['_hashval', '__weakref__', 'id']
 __weakref__ = <attribute '__weakref__' of 'Env' objects>list of weak references to the object (if defined)
 id = <member 'id' of 'Env' objects>
 Methods inherited from __builtin__.dict:
 
 __cmp__(...)x.__cmp__(y) <==> cmp(x,y)
 __contains__(...)D.__contains__(k) -> True if D has a key k, else False
 __delitem__(...)x.__delitem__(y) <==> del x[y]
 __eq__(...)x.__eq__(y) <==> x==y
 __ge__(...)x.__ge__(y) <==> x>=y
 __getattribute__(...)x.__getattribute__('name') <==> x.name
 __gt__(...)x.__gt__(y) <==> x>y
 __iter__(...)x.__iter__() <==> iter(x)
 __le__(...)x.__le__(y) <==> x<=y
 __len__(...)x.__len__() <==> len(x)
 __lt__(...)x.__lt__(y) <==> x<y
 __ne__(...)x.__ne__(y) <==> x!=y
 clear(...)D.clear() -> None.  Remove all items from D.
 has_key(...)D.has_key(k) -> True if D has a key k, else False
 items(...)D.items() -> list of D's (key, value) pairs, as 2-tuples
 iteritems(...)D.iteritems() -> an iterator over the (key, value) items of D
 iterkeys(...)D.iterkeys() -> an iterator over the keys of D
 itervalues(...)D.itervalues() -> an iterator over the values of D
 keys(...)D.keys() -> list of D's keys
 pop(...)D.pop(k[,d]) -> v, remove specified key and return the corresponding valueIf key is not found, d is returned if given, otherwise KeyError is raised
 popitem(...)D.popitem() -> (k, v), remove and return some (key, value) pair as a2-tuple; but raise KeyError if D is empty
 setdefault(...)D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
 values(...)D.values() -> list of D's values
 Data and other attributes inherited from __builtin__.dict:
 
 __new__ = <built-in method __new__ of type object>T.__new__(S, ...) -> a new object with type S, a subtype of T
 fromkeys = <built-in method fromkeys of type object>dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.v defaults to None.
 |  
 
| class ErrorFlag(exceptions.TypeError, Term)
 |  |  |  | Method resolution order:ErrorFlagexceptions.TypeErrorexceptions.StandardErrorexceptions.ExceptionTerm__builtin__.object
 Methods defined here:
 
 __init__(...)
 __repr__ = __str__(...)
 __str__(...)
 classOrder(self)
 value lambda s
 Methods inherited from exceptions.Exception:
 
 __getitem__(...)
 Methods inherited from Term:
 
 asPair(self)Representation in an earlier format, being phased out 2002/08
 The first part of the pair is a constant number represnting the type
 see RDFSink.py.  the second is the value -- uri for symbols,
 string for literals
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 doesNodeAppear(self, symbol)Does that node appear within this one
 This non-overloaded function will simply return if I'm equal to him
 freeVariables(self)
 generated(self)Boolean Is this thing a genid - is its name arbitrary?
 occurringIn(self, vars)
 representation(self, base=None)The string represnting this in N3
 substituteEquals(self, bindings, newRedirections)Return this or a version of me with substitution made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with subsitution made
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class Existential(Term)
 |  |  |  | Method resolution order:ExistentialTerm__builtin__.object
 Methods inherited from Term:
 
 __init__(self, store)
 asPair(self)Representation in an earlier format, being phased out 2002/08
 The first part of the pair is a constant number represnting the type
 see RDFSink.py.  the second is the value -- uri for symbols,
 string for literals
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 doesNodeAppear(self, symbol)Does that node appear within this one
 This non-overloaded function will simply return if I'm equal to him
 freeVariables(self)
 generated(self)Boolean Is this thing a genid - is its name arbitrary?
 occurringIn(self, vars)
 representation(self, base=None)The string represnting this in N3
 substituteEquals(self, bindings, newRedirections)Return this or a version of me with substitution made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with subsitution made
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 value(self)As a python value - by default, none exists, use self
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class FiniteProperty(GenericBuiltIn, Function, ReverseFunction)
 |  |  | A finite property has a finite set of pairs of (subj, object) values 
 The built-in finite property can ennumerate them all if necessary.
 Argv is the only useful example I can think of right now.
 
 |  |  | Method resolution order:FinitePropertyGenericBuiltInFunctionReverseFunctionBuiltInFragmentLabelledNodeNodeTerm__builtin__.object
 Methods defined here:
 
 enn(self)Return list of pairs [(subj, obj)]
 ennumerate(self)
 eval(self, subj, obj, queue, bindings, proof, query)This is of course   very inefficient except for really small ones like argv.
 evalObj(self, subj, queue, bindings, proof, query)This is of course   very inefficient except for really small ones like argv.
 evalSubj(self, obj, queue, bindings, proof, query)This is of course   very inefficient except for really small ones like argv.
 Methods inherited from GenericBuiltIn:
 
 __init__(self, resource, fragid)
 Static methods inherited from BuiltIn:
 
 __new__(cls, *args, **keywords)
 Data and other attributes inherited from BuiltIn:
 
 all = []
 Methods inherited from Fragment:
 
 compareTerm(self, other)
 dereference(self, mode='', workingContext=None)dereference an identifyer, finding the semantics of its schema if any
 Returns None if it cannot be retreived.
 generated(self)A generated identifier?This arises when a document is parsed and a arbitrary
 name is made up to represent a node with no known URI.
 It is useful to know that its ID has no use outside that
 context.
 representation(self, base=None)Optimize output if prefixes available
 uriref(self)
 uriref2(self, base)
 Methods inherited from LabelledNode:
 
 classOrder(self)
 Methods inherited from Term:
 
 __repr__(self)This method only used for debugging output - it can be ambiguous,as it is is deliberately short to make debug printout readable.
 
 output as XML qnames [http://www.w3.org/TR/REC-xml-names/#NT-QName].
 This could be beefed up to guarantee unambiguity.
 asPair(self)Representation in an earlier format, being phased out 2002/08
 The first part of the pair is a constant number represnting the type
 see RDFSink.py.  the second is the value -- uri for symbols,
 string for literals
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 doesNodeAppear(self, symbol)Does that node appear within this one
 This non-overloaded function will simply return if I'm equal to him
 freeVariables(self)
 occurringIn(self, vars)
 substituteEquals(self, bindings, newRedirections)Return this or a version of me with substitution made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with subsitution made
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 value(self)As a python value - by default, none exists, use self
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class Fragment(LabelledNode)
 |  |  | A Term which DOES have a fragment id in its URI 
 |  |  | Method resolution order:FragmentLabelledNodeNodeTerm__builtin__.object
 Methods defined here:
 
 __init__(self, resource, fragid)
 compareTerm(self, other)
 dereference(self, mode='', workingContext=None)dereference an identifyer, finding the semantics of its schema if any
 Returns None if it cannot be retreived.
 generated(self)A generated identifier?This arises when a document is parsed and a arbitrary
 name is made up to represent a node with no known URI.
 It is useful to know that its ID has no use outside that
 context.
 representation(self, base=None)Optimize output if prefixes available
 uriref(self)
 uriref2(self, base)
 Methods inherited from LabelledNode:
 
 classOrder(self)
 Methods inherited from Term:
 
 __repr__(self)This method only used for debugging output - it can be ambiguous,as it is is deliberately short to make debug printout readable.
 
 output as XML qnames [http://www.w3.org/TR/REC-xml-names/#NT-QName].
 This could be beefed up to guarantee unambiguity.
 asPair(self)Representation in an earlier format, being phased out 2002/08
 The first part of the pair is a constant number represnting the type
 see RDFSink.py.  the second is the value -- uri for symbols,
 string for literals
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 doesNodeAppear(self, symbol)Does that node appear within this one
 This non-overloaded function will simply return if I'm equal to him
 freeVariables(self)
 occurringIn(self, vars)
 substituteEquals(self, bindings, newRedirections)Return this or a version of me with substitution made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with subsitution made
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 value(self)As a python value - by default, none exists, use self
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class FragmentNil(EmptyList, Fragment)
 |  |  | This is unique in being both a symbol and a list 
 |  |  | Method resolution order:FragmentNilEmptyListListCompoundTermFragmentLabelledNodeNodeTerm__builtin__.object
 Methods defined here:
 
 __init__(self, resource, fragid)
 Methods inherited from EmptyList:
 
 __getitem__(self, i)
 __repr__(self)
 classOrder(self)
 newList(self, value)
 occurringIn(self, vars)
 substituteEquals(self, bindings, newBindings)Return this or a version of me with substitution of equals made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with substitution made
 uriref(self)
 value(self)
 Methods inherited from List:
 
 __iter__(self)The internal method which allows one to iterate over the statementsas though a formula were a sequence.
 __len__(self)The internal method which allows one to count the statementsas though a formula were a sequence.
 asSequence(self)Convert to a python sequence - NOT recursive
 doesNodeAppear(self, symbol)Does that particular node appear anywhere in this list
 This function is necessarily recursive, and is useful for the pretty
 printer. It will also be useful for the flattener, when we write it.
 freeVariables(self)
 prepend(self, first)
 Methods inherited from Fragment:
 
 compareTerm(self, other)
 dereference(self, mode='', workingContext=None)dereference an identifyer, finding the semantics of its schema if any
 Returns None if it cannot be retreived.
 generated(self)A generated identifier?This arises when a document is parsed and a arbitrary
 name is made up to represent a node with no known URI.
 It is useful to know that its ID has no use outside that
 context.
 representation(self, base=None)Optimize output if prefixes available
 uriref2(self, base)
 Methods inherited from Term:
 
 asPair(self)Representation in an earlier format, being phased out 2002/08
 The first part of the pair is a constant number represnting the type
 see RDFSink.py.  the second is the value -- uri for symbols,
 string for literals
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class Function(BuiltIn)
 |  |  | A function is a builtin which can calculate its object given its subject. 
 To get cwm to invoke it this way, your built-in must be a subclass of Function.
 I may make changes to clean up the parameters of these methods below some day. -tbl
 
 |  |  | Method resolution order:FunctionBuiltInFragmentLabelledNodeNodeTerm__builtin__.object
 Methods defined here:
 
 __init__(self)
 eval(self, subj, obj, queue, bindings, proof, query)
 evalObj(self, subj, queue, bindings, proof, query)This function which has access to the store, unless overridden,calls a simpler one which uses python conventions.
 
 To reduce confusion, the inital ones called with the internals available
 use abreviations "eval", "subj" etc while the python-style ones use "evaluate", "subject", etc.
 Static methods inherited from BuiltIn:
 
 __new__(cls, *args, **keywords)
 Data and other attributes inherited from BuiltIn:
 
 all = []
 Methods inherited from Fragment:
 
 compareTerm(self, other)
 dereference(self, mode='', workingContext=None)dereference an identifyer, finding the semantics of its schema if any
 Returns None if it cannot be retreived.
 generated(self)A generated identifier?This arises when a document is parsed and a arbitrary
 name is made up to represent a node with no known URI.
 It is useful to know that its ID has no use outside that
 context.
 representation(self, base=None)Optimize output if prefixes available
 uriref(self)
 uriref2(self, base)
 Methods inherited from LabelledNode:
 
 classOrder(self)
 Methods inherited from Term:
 
 __repr__(self)This method only used for debugging output - it can be ambiguous,as it is is deliberately short to make debug printout readable.
 
 output as XML qnames [http://www.w3.org/TR/REC-xml-names/#NT-QName].
 This could be beefed up to guarantee unambiguity.
 asPair(self)Representation in an earlier format, being phased out 2002/08
 The first part of the pair is a constant number represnting the type
 see RDFSink.py.  the second is the value -- uri for symbols,
 string for literals
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 doesNodeAppear(self, symbol)Does that node appear within this one
 This non-overloaded function will simply return if I'm equal to him
 freeVariables(self)
 occurringIn(self, vars)
 substituteEquals(self, bindings, newRedirections)Return this or a version of me with substitution made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with subsitution made
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 value(self)As a python value - by default, none exists, use self
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class GenericBuiltIn(BuiltIn)
 |  |  |  | Method resolution order:GenericBuiltInBuiltInFragmentLabelledNodeNodeTerm__builtin__.object
 Methods defined here:
 
 __init__(self, resource, fragid)
 Methods inherited from BuiltIn:
 
 eval(self, subj, obj, queue, bindings, proof, query)This function which has access to the store, unless overridden,calls a simpler one which uses python conventions.
 
 To reduce confusion, the inital ones called with the internals available
 use abreviations "eval", "subj" etc while the python-style ones use
 evaluate, subject, etc.
 Static methods inherited from BuiltIn:
 
 __new__(cls, *args, **keywords)
 Data and other attributes inherited from BuiltIn:
 
 all = []
 Methods inherited from Fragment:
 
 compareTerm(self, other)
 dereference(self, mode='', workingContext=None)dereference an identifyer, finding the semantics of its schema if any
 Returns None if it cannot be retreived.
 generated(self)A generated identifier?This arises when a document is parsed and a arbitrary
 name is made up to represent a node with no known URI.
 It is useful to know that its ID has no use outside that
 context.
 representation(self, base=None)Optimize output if prefixes available
 uriref(self)
 uriref2(self, base)
 Methods inherited from LabelledNode:
 
 classOrder(self)
 Methods inherited from Term:
 
 __repr__(self)This method only used for debugging output - it can be ambiguous,as it is is deliberately short to make debug printout readable.
 
 output as XML qnames [http://www.w3.org/TR/REC-xml-names/#NT-QName].
 This could be beefed up to guarantee unambiguity.
 asPair(self)Representation in an earlier format, being phased out 2002/08
 The first part of the pair is a constant number represnting the type
 see RDFSink.py.  the second is the value -- uri for symbols,
 string for literals
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 doesNodeAppear(self, symbol)Does that node appear within this one
 This non-overloaded function will simply return if I'm equal to him
 freeVariables(self)
 occurringIn(self, vars)
 substituteEquals(self, bindings, newRedirections)Return this or a version of me with substitution made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with subsitution made
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 value(self)As a python value - by default, none exists, use self
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class HeavyBuiltIn(GenericBuiltIn)
 |  |  | A heavy built-in is fast and is calculated late, after searching the store to see if the answer is already in it.
 
 Make your built-in a subclass of either this or LightBultIn to tell cwm when to
 run it.  Going out onto the web or net counts as Heavy.
 
 |  |  | Method resolution order:HeavyBuiltInGenericBuiltInBuiltInFragmentLabelledNodeNodeTerm__builtin__.object
 Methods inherited from GenericBuiltIn:
 
 __init__(self, resource, fragid)
 Methods inherited from BuiltIn:
 
 eval(self, subj, obj, queue, bindings, proof, query)This function which has access to the store, unless overridden,calls a simpler one which uses python conventions.
 
 To reduce confusion, the inital ones called with the internals available
 use abreviations "eval", "subj" etc while the python-style ones use
 evaluate, subject, etc.
 Static methods inherited from BuiltIn:
 
 __new__(cls, *args, **keywords)
 Data and other attributes inherited from BuiltIn:
 
 all = []
 Methods inherited from Fragment:
 
 compareTerm(self, other)
 dereference(self, mode='', workingContext=None)dereference an identifyer, finding the semantics of its schema if any
 Returns None if it cannot be retreived.
 generated(self)A generated identifier?This arises when a document is parsed and a arbitrary
 name is made up to represent a node with no known URI.
 It is useful to know that its ID has no use outside that
 context.
 representation(self, base=None)Optimize output if prefixes available
 uriref(self)
 uriref2(self, base)
 Methods inherited from LabelledNode:
 
 classOrder(self)
 Methods inherited from Term:
 
 __repr__(self)This method only used for debugging output - it can be ambiguous,as it is is deliberately short to make debug printout readable.
 
 output as XML qnames [http://www.w3.org/TR/REC-xml-names/#NT-QName].
 This could be beefed up to guarantee unambiguity.
 asPair(self)Representation in an earlier format, being phased out 2002/08
 The first part of the pair is a constant number represnting the type
 see RDFSink.py.  the second is the value -- uri for symbols,
 string for literals
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 doesNodeAppear(self, symbol)Does that node appear within this one
 This non-overloaded function will simply return if I'm equal to him
 freeVariables(self)
 occurringIn(self, vars)
 substituteEquals(self, bindings, newRedirections)Return this or a version of me with substitution made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with subsitution made
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 value(self)As a python value - by default, none exists, use self
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class LabelledNode(Node)
 |  |  | The labelled node is one which has a URI. 
 |  |  | Method resolution order:LabelledNodeNodeTerm__builtin__.object
 Methods defined here:
 
 classOrder(self)
 compareTerm(self, other)Assume is also a LabelledNode - see function compareTerm in formula.py
 Methods inherited from Term:
 
 __init__(self, store)
 __repr__(self)This method only used for debugging output - it can be ambiguous,as it is is deliberately short to make debug printout readable.
 
 output as XML qnames [http://www.w3.org/TR/REC-xml-names/#NT-QName].
 This could be beefed up to guarantee unambiguity.
 asPair(self)Representation in an earlier format, being phased out 2002/08
 The first part of the pair is a constant number represnting the type
 see RDFSink.py.  the second is the value -- uri for symbols,
 string for literals
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 doesNodeAppear(self, symbol)Does that node appear within this one
 This non-overloaded function will simply return if I'm equal to him
 freeVariables(self)
 generated(self)Boolean Is this thing a genid - is its name arbitrary?
 occurringIn(self, vars)
 representation(self, base=None)The string represnting this in N3
 substituteEquals(self, bindings, newRedirections)Return this or a version of me with substitution made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with subsitution made
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 value(self)As a python value - by default, none exists, use self
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class LightBuiltIn(GenericBuiltIn)
 |  |  | A light built-in is fast and is calculated immediately before searching the store. 
 Make your built-in a subclass of either this or HeavyBultIn to tell cwm when to
 run it.  Going out onto the web or net counts as heavy.
 
 |  |  | Method resolution order:LightBuiltInGenericBuiltInBuiltInFragmentLabelledNodeNodeTerm__builtin__.object
 Methods inherited from GenericBuiltIn:
 
 __init__(self, resource, fragid)
 Methods inherited from BuiltIn:
 
 eval(self, subj, obj, queue, bindings, proof, query)This function which has access to the store, unless overridden,calls a simpler one which uses python conventions.
 
 To reduce confusion, the inital ones called with the internals available
 use abreviations "eval", "subj" etc while the python-style ones use
 evaluate, subject, etc.
 Static methods inherited from BuiltIn:
 
 __new__(cls, *args, **keywords)
 Data and other attributes inherited from BuiltIn:
 
 all = []
 Methods inherited from Fragment:
 
 compareTerm(self, other)
 dereference(self, mode='', workingContext=None)dereference an identifyer, finding the semantics of its schema if any
 Returns None if it cannot be retreived.
 generated(self)A generated identifier?This arises when a document is parsed and a arbitrary
 name is made up to represent a node with no known URI.
 It is useful to know that its ID has no use outside that
 context.
 representation(self, base=None)Optimize output if prefixes available
 uriref(self)
 uriref2(self, base)
 Methods inherited from LabelledNode:
 
 classOrder(self)
 Methods inherited from Term:
 
 __repr__(self)This method only used for debugging output - it can be ambiguous,as it is is deliberately short to make debug printout readable.
 
 output as XML qnames [http://www.w3.org/TR/REC-xml-names/#NT-QName].
 This could be beefed up to guarantee unambiguity.
 asPair(self)Representation in an earlier format, being phased out 2002/08
 The first part of the pair is a constant number represnting the type
 see RDFSink.py.  the second is the value -- uri for symbols,
 string for literals
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 doesNodeAppear(self, symbol)Does that node appear within this one
 This non-overloaded function will simply return if I'm equal to him
 freeVariables(self)
 occurringIn(self, vars)
 substituteEquals(self, bindings, newRedirections)Return this or a version of me with substitution made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with subsitution made
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 value(self)As a python value - by default, none exists, use self
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class List(CompoundTerm)
 |  |  |  | Method resolution order:ListCompoundTermTerm__builtin__.object
 Methods defined here:
 
 __init__(self, store, first, rest)
 __iter__(self)The internal method which allows one to iterate over the statementsas though a formula were a sequence.
 __len__(self)The internal method which allows one to count the statementsas though a formula were a sequence.
 asSequence(self)Convert to a python sequence - NOT recursive
 doesNodeAppear(self, symbol)Does that particular node appear anywhere in this list
 This function is necessarily recursive, and is useful for the pretty
 printer. It will also be useful for the flattener, when we write it.
 freeVariables(self)
 occurringIn(self, vars)Which variables in the list occur in this list?
 prepend(self, first)
 substituteEquals(self, bindings, newBindings)Return this or a version of me with substitution of equals made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with variable substitution made
 uriref(self)
 value(self)
 Methods inherited from Term:
 
 __repr__(self)This method only used for debugging output - it can be ambiguous,as it is is deliberately short to make debug printout readable.
 
 output as XML qnames [http://www.w3.org/TR/REC-xml-names/#NT-QName].
 This could be beefed up to guarantee unambiguity.
 asPair(self)Representation in an earlier format, being phased out 2002/08
 The first part of the pair is a constant number represnting the type
 see RDFSink.py.  the second is the value -- uri for symbols,
 string for literals
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 generated(self)Boolean Is this thing a genid - is its name arbitrary?
 representation(self, base=None)The string represnting this in N3
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class ListView(__builtin__.object)
 |  |  | #### Everything that follows are the new unification routines 
 |  |  | Methods defined here: 
 __init__(self, list, start=0)
 __len__(self)
 Properties defined here:
 
 carget = _car(self)
 cdrget = _cdr(self)
 Data and other attributes defined here:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'ListView' objects>list of weak references to the object (if defined)
 |  
 
| class Literal(Term)
 |  |  | A Literal is a representation of an RDF literal 
 really, data:text/rdf+n3;%22hello%22 == "hello" but who
 wants to store it that way?  Maybe we do... at least in theory and maybe
 practice but, for now, we keep them in separate subclases of Term.
 An RDF literal has a value - by default a string, and a datattype, and a
 language.
 
 |  |  | Method resolution order:LiteralTerm__builtin__.object
 Methods defined here:
 
 __decimal__(self)
 __float__(self)
 __init__(self, store, str, dt=None, lang=None)
 __int__(self)
 __repr__(self)
 __str__(self)
 asHashURI(self)return a md5: URI for this literal.Hmm... encoding... assuming utf8? @@test this.
 Hmm... for a class of literals including this one,
 strictly speaking.
 asPair(self)
 classOrder(self)
 compareTerm(self, other)Assume is also a literal - see function compareTerm in formula.py
 occurringIn(self, vars)
 representation(self, base=None)
 substituteEquals(self, bindings, newBindings)Return this or a version of me with subsitution made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with subsitution made
 uriref(self)
 value(self)Datatype conversion XSD to Python
 RDF primitive datatypes are XML schema datatypes, in the XSD namespace.
 see http://www.w3.org/TR/xmlschema-2
 Methods inherited from Term:
 
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 doesNodeAppear(self, symbol)Does that node appear within this one
 This non-overloaded function will simply return if I'm equal to him
 freeVariables(self)
 generated(self)Boolean Is this thing a genid - is its name arbitrary?
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class MultipleFunction(Function)
 |  |  | Multiple return values. The preconditions are the same as for Function, that the subject must be bound.
 The result is different, as multiple versions are returned. Example: member of list.
 
 |  |  | Method resolution order:MultipleFunctionFunctionBuiltInFragmentLabelledNodeNodeTerm__builtin__.object
 Methods defined here:
 
 evalSubj(self, obj, queue, bindings, proof, query)This function which has access to the store, unless overridden,calls a simpler one which uses python conventions.
 The python one returns a list of function values.
 This returns a 'new bindings' structure (nbs) which is a sequence of
 (bindings, reason) pairs.
 Methods inherited from Function:
 
 __init__(self)
 eval(self, subj, obj, queue, bindings, proof, query)
 evalObj(self, subj, queue, bindings, proof, query)This function which has access to the store, unless overridden,calls a simpler one which uses python conventions.
 
 To reduce confusion, the inital ones called with the internals available
 use abreviations "eval", "subj" etc while the python-style ones use "evaluate", "subject", etc.
 Static methods inherited from BuiltIn:
 
 __new__(cls, *args, **keywords)
 Data and other attributes inherited from BuiltIn:
 
 all = []
 Methods inherited from Fragment:
 
 compareTerm(self, other)
 dereference(self, mode='', workingContext=None)dereference an identifyer, finding the semantics of its schema if any
 Returns None if it cannot be retreived.
 generated(self)A generated identifier?This arises when a document is parsed and a arbitrary
 name is made up to represent a node with no known URI.
 It is useful to know that its ID has no use outside that
 context.
 representation(self, base=None)Optimize output if prefixes available
 uriref(self)
 uriref2(self, base)
 Methods inherited from LabelledNode:
 
 classOrder(self)
 Methods inherited from Term:
 
 __repr__(self)This method only used for debugging output - it can be ambiguous,as it is is deliberately short to make debug printout readable.
 
 output as XML qnames [http://www.w3.org/TR/REC-xml-names/#NT-QName].
 This could be beefed up to guarantee unambiguity.
 asPair(self)Representation in an earlier format, being phased out 2002/08
 The first part of the pair is a constant number represnting the type
 see RDFSink.py.  the second is the value -- uri for symbols,
 string for literals
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 doesNodeAppear(self, symbol)Does that node appear within this one
 This non-overloaded function will simply return if I'm equal to him
 freeVariables(self)
 occurringIn(self, vars)
 substituteEquals(self, bindings, newRedirections)Return this or a version of me with substitution made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with subsitution made
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 value(self)As a python value - by default, none exists, use self
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class MultipleReverseFunction(ReverseFunction)
 |  |  | Multiple return values 
 |  |  | Method resolution order:MultipleReverseFunctionReverseFunctionBuiltInFragmentLabelledNodeNodeTerm__builtin__.object
 Methods defined here:
 
 evalObj(self, subj, queue, bindings, proof, query)
 Methods inherited from ReverseFunction:
 
 __init__(self)
 eval(self, subj, obj, queue, bindings, proof, query)
 evalSubj(self, obj, queue, bindings, proof, query)This function which has access to the store, unless overridden,calls a simpler one which uses python conventions
 Static methods inherited from BuiltIn:
 
 __new__(cls, *args, **keywords)
 Data and other attributes inherited from BuiltIn:
 
 all = []
 Methods inherited from Fragment:
 
 compareTerm(self, other)
 dereference(self, mode='', workingContext=None)dereference an identifyer, finding the semantics of its schema if any
 Returns None if it cannot be retreived.
 generated(self)A generated identifier?This arises when a document is parsed and a arbitrary
 name is made up to represent a node with no known URI.
 It is useful to know that its ID has no use outside that
 context.
 representation(self, base=None)Optimize output if prefixes available
 uriref(self)
 uriref2(self, base)
 Methods inherited from LabelledNode:
 
 classOrder(self)
 Methods inherited from Term:
 
 __repr__(self)This method only used for debugging output - it can be ambiguous,as it is is deliberately short to make debug printout readable.
 
 output as XML qnames [http://www.w3.org/TR/REC-xml-names/#NT-QName].
 This could be beefed up to guarantee unambiguity.
 asPair(self)Representation in an earlier format, being phased out 2002/08
 The first part of the pair is a constant number represnting the type
 see RDFSink.py.  the second is the value -- uri for symbols,
 string for literals
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 doesNodeAppear(self, symbol)Does that node appear within this one
 This non-overloaded function will simply return if I'm equal to him
 freeVariables(self)
 occurringIn(self, vars)
 substituteEquals(self, bindings, newRedirections)Return this or a version of me with substitution made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with subsitution made
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 value(self)As a python value - by default, none exists, use self
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class N3Set(__builtin__.frozenset, CompoundTerm)
 |  |  | There can only be one of every N3Set 
 |  |  | Method resolution order:N3Set__builtin__.frozensetCompoundTermTerm__builtin__.object
 Methods defined here:
 
 __init__(self, stuff=[])something
 asSequence(self)
 classOrder(self)
 compareTerm(self, other)This is annoying
 freeVariables(self)
 occurringIn(self, vars)
 substituteEquals(self, bindings, newBindings)Return this or a version of me with substitution of equals made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with variable substitution made
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 uriref(self)
 Static methods defined here:
 
 __new__(cls, stuff=[])
 Data and other attributes defined here:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 res = {}
 Methods inherited from __builtin__.frozenset:
 
 __and__(...)x.__and__(y) <==> x&y
 __cmp__(...)x.__cmp__(y) <==> cmp(x,y)
 __contains__(...)x.__contains__(y) <==> y in x.
 __eq__(...)x.__eq__(y) <==> x==y
 __ge__(...)x.__ge__(y) <==> x>=y
 __getattribute__(...)x.__getattribute__('name') <==> x.name
 __gt__(...)x.__gt__(y) <==> x>y
 __hash__(...)x.__hash__() <==> hash(x)
 __iter__(...)x.__iter__() <==> iter(x)
 __le__(...)x.__le__(y) <==> x<=y
 __len__(...)x.__len__() <==> len(x)
 __lt__(...)x.__lt__(y) <==> x<y
 __ne__(...)x.__ne__(y) <==> x!=y
 __or__(...)x.__or__(y) <==> x|y
 __rand__(...)x.__rand__(y) <==> y&x
 __reduce__(...)Return state information for pickling.
 __repr__(...)x.__repr__() <==> repr(x)
 __ror__(...)x.__ror__(y) <==> y|x
 __rsub__(...)x.__rsub__(y) <==> y-x
 __rxor__(...)x.__rxor__(y) <==> y^x
 __sub__(...)x.__sub__(y) <==> x-y
 __xor__(...)x.__xor__(y) <==> x^y
 copy(...)Return a shallow copy of a set.
 difference(...)Return the difference of two sets as a new set.
 (i.e. all elements that are in this set but not the other.)
 intersection(...)Return the intersection of two sets as a new set.
 (i.e. all elements that are in both sets.)
 issubset(...)Report whether another set contains this set.
 issuperset(...)Report whether this set contains another set.
 symmetric_difference(...)Return the symmetric difference of two sets as a new set.
 (i.e. all elements that are in exactly one of the sets.)
 union(...)Return the union of two sets as a new set.
 (i.e. all elements that are in either set.)
 Methods inherited from Term:
 
 asPair(self)Representation in an earlier format, being phased out 2002/08
 The first part of the pair is a constant number represnting the type
 see RDFSink.py.  the second is the value -- uri for symbols,
 string for literals
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 doesNodeAppear(self, symbol)Does that node appear within this one
 This non-overloaded function will simply return if I'm equal to him
 generated(self)Boolean Is this thing a genid - is its name arbitrary?
 representation(self, base=None)The string represnting this in N3
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 value(self)As a python value - by default, none exists, use self
 Data and other attributes inherited from Term:
 
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class Node(Term)
 |  |  | A node in the graph 
 |  |  | Method resolution order:NodeTerm__builtin__.object
 Methods inherited from Term:
 
 __init__(self, store)
 __repr__(self)This method only used for debugging output - it can be ambiguous,as it is is deliberately short to make debug printout readable.
 
 output as XML qnames [http://www.w3.org/TR/REC-xml-names/#NT-QName].
 This could be beefed up to guarantee unambiguity.
 asPair(self)Representation in an earlier format, being phased out 2002/08
 The first part of the pair is a constant number represnting the type
 see RDFSink.py.  the second is the value -- uri for symbols,
 string for literals
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 doesNodeAppear(self, symbol)Does that node appear within this one
 This non-overloaded function will simply return if I'm equal to him
 freeVariables(self)
 generated(self)Boolean Is this thing a genid - is its name arbitrary?
 occurringIn(self, vars)
 representation(self, base=None)The string represnting this in N3
 substituteEquals(self, bindings, newRedirections)Return this or a version of me with substitution made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with subsitution made
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 value(self)As a python value - by default, none exists, use self
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class NonEmptyList(List)
 |  |  |  | Method resolution order:NonEmptyListListCompoundTermTerm__builtin__.object
 Methods defined here:
 
 __getitem__(self, i)
 classOrder(self)
 compareTerm(self, other)Assume is also a NonEmptyList - see function compareTerm in formula.py
 debugString(self, already=[])
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 Methods inherited from List:
 
 __init__(self, store, first, rest)
 __iter__(self)The internal method which allows one to iterate over the statementsas though a formula were a sequence.
 __len__(self)The internal method which allows one to count the statementsas though a formula were a sequence.
 asSequence(self)Convert to a python sequence - NOT recursive
 doesNodeAppear(self, symbol)Does that particular node appear anywhere in this list
 This function is necessarily recursive, and is useful for the pretty
 printer. It will also be useful for the flattener, when we write it.
 freeVariables(self)
 occurringIn(self, vars)Which variables in the list occur in this list?
 prepend(self, first)
 substituteEquals(self, bindings, newBindings)Return this or a version of me with substitution of equals made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with variable substitution made
 uriref(self)
 value(self)
 Methods inherited from Term:
 
 __repr__(self)This method only used for debugging output - it can be ambiguous,as it is is deliberately short to make debug printout readable.
 
 output as XML qnames [http://www.w3.org/TR/REC-xml-names/#NT-QName].
 This could be beefed up to guarantee unambiguity.
 asPair(self)Representation in an earlier format, being phased out 2002/08
 The first part of the pair is a constant number represnting the type
 see RDFSink.py.  the second is the value -- uri for symbols,
 string for literals
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 generated(self)Boolean Is this thing a genid - is its name arbitrary?
 representation(self, base=None)The string represnting this in N3
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class RDFBuiltIn(LightBuiltIn)
 |  |  | An RDF built-in is a light built-in which is inherent in the RDF model. 
 The only examples are (I think) rdf:first and rdf:rest which in the RDF model
 are arcs but in cwm have to be builtins as Lists a a first class data type.
 .
 
 |  |  | Method resolution order:RDFBuiltInLightBuiltInGenericBuiltInBuiltInFragmentLabelledNodeNodeTerm__builtin__.object
 Methods inherited from GenericBuiltIn:
 
 __init__(self, resource, fragid)
 Methods inherited from BuiltIn:
 
 eval(self, subj, obj, queue, bindings, proof, query)This function which has access to the store, unless overridden,calls a simpler one which uses python conventions.
 
 To reduce confusion, the inital ones called with the internals available
 use abreviations "eval", "subj" etc while the python-style ones use
 evaluate, subject, etc.
 Static methods inherited from BuiltIn:
 
 __new__(cls, *args, **keywords)
 Data and other attributes inherited from BuiltIn:
 
 all = []
 Methods inherited from Fragment:
 
 compareTerm(self, other)
 dereference(self, mode='', workingContext=None)dereference an identifyer, finding the semantics of its schema if any
 Returns None if it cannot be retreived.
 generated(self)A generated identifier?This arises when a document is parsed and a arbitrary
 name is made up to represent a node with no known URI.
 It is useful to know that its ID has no use outside that
 context.
 representation(self, base=None)Optimize output if prefixes available
 uriref(self)
 uriref2(self, base)
 Methods inherited from LabelledNode:
 
 classOrder(self)
 Methods inherited from Term:
 
 __repr__(self)This method only used for debugging output - it can be ambiguous,as it is is deliberately short to make debug printout readable.
 
 output as XML qnames [http://www.w3.org/TR/REC-xml-names/#NT-QName].
 This could be beefed up to guarantee unambiguity.
 asPair(self)Representation in an earlier format, being phased out 2002/08
 The first part of the pair is a constant number represnting the type
 see RDFSink.py.  the second is the value -- uri for symbols,
 string for literals
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 doesNodeAppear(self, symbol)Does that node appear within this one
 This non-overloaded function will simply return if I'm equal to him
 freeVariables(self)
 occurringIn(self, vars)
 substituteEquals(self, bindings, newRedirections)Return this or a version of me with substitution made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with subsitution made
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 value(self)As a python value - by default, none exists, use self
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class ReverseFunction(BuiltIn)
 |  |  | A reverse function is a builtin which can calculate its subject given its object. 
 To get cwm to invoke it this way, your built-in must be a subclass of ReverseFunction.
 If a function (like log:uri for example) is a two-way  (1:1) builtin, it should be declared
 a subclass of Function and ReverseFunction. Then, cwm will call it either way as needed
 in trying to resolve a query.
 
 |  |  | Method resolution order:ReverseFunctionBuiltInFragmentLabelledNodeNodeTerm__builtin__.object
 Methods defined here:
 
 __init__(self)
 eval(self, subj, obj, queue, bindings, proof, query)
 evalSubj(self, obj, queue, bindings, proof, query)This function which has access to the store, unless overridden,calls a simpler one which uses python conventions
 Static methods inherited from BuiltIn:
 
 __new__(cls, *args, **keywords)
 Data and other attributes inherited from BuiltIn:
 
 all = []
 Methods inherited from Fragment:
 
 compareTerm(self, other)
 dereference(self, mode='', workingContext=None)dereference an identifyer, finding the semantics of its schema if any
 Returns None if it cannot be retreived.
 generated(self)A generated identifier?This arises when a document is parsed and a arbitrary
 name is made up to represent a node with no known URI.
 It is useful to know that its ID has no use outside that
 context.
 representation(self, base=None)Optimize output if prefixes available
 uriref(self)
 uriref2(self, base)
 Methods inherited from LabelledNode:
 
 classOrder(self)
 Methods inherited from Term:
 
 __repr__(self)This method only used for debugging output - it can be ambiguous,as it is is deliberately short to make debug printout readable.
 
 output as XML qnames [http://www.w3.org/TR/REC-xml-names/#NT-QName].
 This could be beefed up to guarantee unambiguity.
 asPair(self)Representation in an earlier format, being phased out 2002/08
 The first part of the pair is a constant number represnting the type
 see RDFSink.py.  the second is the value -- uri for symbols,
 string for literals
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 doesNodeAppear(self, symbol)Does that node appear within this one
 This non-overloaded function will simply return if I'm equal to him
 freeVariables(self)
 occurringIn(self, vars)
 substituteEquals(self, bindings, newRedirections)Return this or a version of me with substitution made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with subsitution made
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 value(self)As a python value - by default, none exists, use self
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class SkolemFunction(Existential)
 |  |  |  | Method resolution order:SkolemFunctionExistentialTerm__builtin__.object
 Methods inherited from Term:
 
 __init__(self, store)
 asPair(self)Representation in an earlier format, being phased out 2002/08
 The first part of the pair is a constant number represnting the type
 see RDFSink.py.  the second is the value -- uri for symbols,
 string for literals
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 doesNodeAppear(self, symbol)Does that node appear within this one
 This non-overloaded function will simply return if I'm equal to him
 freeVariables(self)
 generated(self)Boolean Is this thing a genid - is its name arbitrary?
 occurringIn(self, vars)
 representation(self, base=None)The string represnting this in N3
 substituteEquals(self, bindings, newRedirections)Return this or a version of me with substitution made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with subsitution made
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 value(self)As a python value - by default, none exists, use self
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class Symbol(LabelledNode)
 |  |  | A Term which has no fragment 
 |  |  | Method resolution order:SymbolLabelledNodeNodeTerm__builtin__.object
 Methods defined here:
 
 __getitem__(self, lname)get the lname Symbol in this namespace.
 lname -- an XML name (limited to URI characters)
 __init__(self, uri, store)
 dereference(self, mode='', workingContext=None)dereference an identifier, finding the semantics of its schema if any
 Returns None if it cannot be retreived.
 internFrag(self, fragid, thetype)
 uriref(self)
 uriref2(self, base)
 Methods inherited from LabelledNode:
 
 classOrder(self)
 compareTerm(self, other)Assume is also a LabelledNode - see function compareTerm in formula.py
 Methods inherited from Term:
 
 __repr__(self)This method only used for debugging output - it can be ambiguous,as it is is deliberately short to make debug printout readable.
 
 output as XML qnames [http://www.w3.org/TR/REC-xml-names/#NT-QName].
 This could be beefed up to guarantee unambiguity.
 asPair(self)Representation in an earlier format, being phased out 2002/08
 The first part of the pair is a constant number represnting the type
 see RDFSink.py.  the second is the value -- uri for symbols,
 string for literals
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 doesNodeAppear(self, symbol)Does that node appear within this one
 This non-overloaded function will simply return if I'm equal to him
 freeVariables(self)
 generated(self)Boolean Is this thing a genid - is its name arbitrary?
 occurringIn(self, vars)
 representation(self, base=None)The string represnting this in N3
 substituteEquals(self, bindings, newRedirections)Return this or a version of me with substitution made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with subsitution made
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 value(self)As a python value - by default, none exists, use self
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class Term(__builtin__.object)
 |  |  | The Term object represents an RDF term. 
 It is interned for speed of processing by the store.
 Every term has a pointer back to its store.
 
 |  |  | Methods defined here: 
 __init__(self, store)
 __repr__(self)This method only used for debugging output - it can be ambiguous,as it is is deliberately short to make debug printout readable.
 
 output as XML qnames [http://www.w3.org/TR/REC-xml-names/#NT-QName].
 This could be beefed up to guarantee unambiguity.
 asPair(self)Representation in an earlier format, being phased out 2002/08
 The first part of the pair is a constant number represnting the type
 see RDFSink.py.  the second is the value -- uri for symbols,
 string for literals
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 doesNodeAppear(self, symbol)Does that node appear within this one
 This non-overloaded function will simply return if I'm equal to him
 freeVariables(self)
 generated(self)Boolean Is this thing a genid - is its name arbitrary?
 occurringIn(self, vars)
 representation(self, base=None)The string represnting this in N3
 substituteEquals(self, bindings, newRedirections)Return this or a version of me with substitution made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with subsitution made
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 value(self)As a python value - by default, none exists, use self
 Data and other attributes defined here:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
| class Universal(Term)
 |  |  |  | Method resolution order:UniversalTerm__builtin__.object
 Methods inherited from Term:
 
 __init__(self, store)
 asPair(self)Representation in an earlier format, being phased out 2002/08
 The first part of the pair is a constant number represnting the type
 see RDFSink.py.  the second is the value -- uri for symbols,
 string for literals
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 doesNodeAppear(self, symbol)Does that node appear within this one
 This non-overloaded function will simply return if I'm equal to him
 freeVariables(self)
 generated(self)Boolean Is this thing a genid - is its name arbitrary?
 occurringIn(self, vars)
 representation(self, base=None)The string represnting this in N3
 substituteEquals(self, bindings, newRedirections)Return this or a version of me with substitution made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with subsitution made
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 value(self)As a python value - by default, none exists, use self
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  
 
 
| class XMLLiteral(Literal)
 |  |  | A Literal is a representation of an RDF literal 
 really, data:text/rdf+n3;%22hello%22 == "hello" but who
 wants to store it that way?  Maybe we do... at least in theory and maybe
 practice but, for now, we keep them in separate subclases of Term.
 An RDF literal has a value - by default a string, and a datattype, and a
 language.
 
 |  |  | Method resolution order:XMLLiteralLiteralTerm__builtin__.object
 Methods defined here:
 
 __decimal__(self)
 __float__(self)
 __init__(self, store, dom)
 __int__(self)
 __repr__(self)
 __str__(self)
 asHashURI(self)return a md5: URI for this literal.Hmm... encoding... assuming utf8? @@test this.
 Hmm... for a class of literals including this one,
 strictly speaking.
 asPair(self)
 classOrder(self)
 compareTerm(self, other)Assume is also a literal - see function compareTerm in formula.py
 occurringIn(self, vars)
 representation(self, base=None)
 substituteEquals(self, bindings, newBindings)Return this or a version of me with subsitution made
 substitution(self, bindings, why=None, cannon=False)Return this or a version of me with subsitution made
 uriref(self)
 value(self)Datatype conversion XSD to Python
 The internal reopresentation is the dom tree
 Methods inherited from Term:
 
 compareAnyTerm(self, other)Compare two langauge itemsThis is a cannoncial ordering in that is designed to allow
 the same graph always to be printed in the same order.
 This makes the regression tests possible.
 The literals are deemed smaller than symbols, which are smaller
 than formulae.  This puts the rules at the botom of a file where
 they tend to take a lot of space anyway.
 Formulae have to be compared as a function of their sorted contents.
 
 @@ Anonymous nodes have to, within a given Formula, be compared as
 a function of the sorted information about them in that context.
 This is not done yet
 debugString(self, already=[])
 doesNodeAppear(self, symbol)Does that node appear within this one
 This non-overloaded function will simply return if I'm equal to him
 freeVariables(self)
 generated(self)Boolean Is this thing a genid - is its name arbitrary?
 unify(self, other, env1=Env({}), env2=Env({}), vars=set([]), universals=set([]), existentials=set([]), n1Source=32, n2Source=32)
 unifySecondary(self, other, env1, env2, vars, universals, existentials, n1Source=55, n2Source=55)
 Data and other attributes inherited from Term:
 
 __dict__ = <dictproxy object>dictionary for instance variables (if defined)
 __weakref__ = <attribute '__weakref__' of 'Term' objects>list of weak references to the object (if defined)
 |  |