W3C home > Mailing lists > Public > public-cwm-talk@w3.org > October to December 2009

FuXi 1.0-rc 1.0-rc-III updates

From: Chimezie <chimezie@gmail.com>
Date: Mon, 21 Dec 2009 14:35:36 -0800 (PST)
Message-ID: <ac127498-278c-4240-9df6-06f09b7d1be8@t19g2000vbc.googlegroups.com>
To: fuxi-discussion <fuxi-discussion@googlegroups.com>
Cc: public-cwm-talk@w3.org
I have made a few updates to FuXi.  Some are minor, others are major.
The detailed changes are below, but in summary.

- Fixes to major problems including the way adorned rules are compared
in order to ensure that - during a proof - the same goal will not be
proved twice (i.e., memoization or tabling)
- Fixed hashing of rules to take adornment into consideration, so
GrandFather_bb(?Y ?Z) :- And( Father(?X ?Y) Parent(?Z ?X)) is
considered different from GrandFather_bf(?Y ?Z) :- And( Father(?X ?Y)
Parent(?Z ?X))
- Rules for owl:IFP, owl:FP, and owl:oneOf terms are now only included
if these terms are in the signature of the OWL graph
- Added method to determine the derived predicates from an OWL graph
and a DDL-like graph which uses a vocabulary that allows
identification of derived / base predicates explicitly, common prefix,
or substring match (IdentifyDerivedPredicates).  See:
- Various correctness fixes for the top-down proof system
- Restriction BooleanClass instances (in InfixOWL) can now be directly

InfixOWL has now stabilized to the point where I use it readily for
several other projects where I need to manipulate or create OWL
programatically - For extracting subsets of SNOMED-CT as OWL for

The major addition, however (described here:
http://code.google.com/p/fuxi/wiki/FuXiUserManual#FuXi_.SPARQL) is an
rdflib store that can acts as a  thin wrapper between a SPARQL dataset
and a Semantic Web theory (as RIF Core / N3 / OWL2-RL) such that high-
level SPARQL queries (which use predicates whose semantics are
determined by the theory) can be answered against the 'base' SPARQL
dataset via query-rewriting.  This is one part of a framework for
federated SPARQL query mediation.

Most of what is needed to be a RIF implementation (and thus contribute
to the W3C implementation report of the RIF-related specifications) is
a syntax parser for the XML-based exchange syntax for RIF.  I just
need to find the time to work on this.  I'd welcome any volunteers who
wish to help in that regard.  Other than this, I think I'm pretty much
on a glide path to a 1.0 release.

I have yet to push these changes to cheeseshop/pypy so the only way to
pick them up is via the Mercurial repository.  Plus I need to look
into issues with easy_install identified in a previous email

-------------------- Changelog ---------------------------

fix to properly move builtins to end of chain
- removed semantics for owl:differentFrom, list handling, owl:IFP,
owl:FP, owl:oneOf,  (they are now
- Added FuXi.DLP.ConditionalAxioms.AdditionalRules which takes an OWL
graph and returns a generator
over additional owl:IFP, owl:FP, etc. rules
- needed depending on the existence of axioms involving these
- added additional arguments to FuXi.Horn.HornRules.HornFromDL needed
setupDescriptionLogicProgramming (derivedPreds - a list of derived
predicated and complSkip  - a
list of complement classes whose semantics will be ignored)
- added utility function FuXi.Horn.HornRules.NormalizeBody which takes
a rule and moves all its
builtins to the end
- updated getVarMapping method on Uniterms to take a reverse boolean
keyword argument which switches
the order of the mapping (from one predicate instance to another)
- Updated doctest strings
- The alphaNetworkHash method (on FuXi.Rete.AlphaNode instances) now
takes a list of BNodes which
are to be treated as skolem terms rather than undistinguished
- Typo fixes
- Removed from MagicSetTransformation, the checking for owl:IFP,
owl:FP, and owl:oneOf terms to add
their corresponding clauses.  These need to be checked for by the user
explicitly via
- Added adornment to string representation of a rule (which is the
basis for the hash of a rule)
- AdornLiteral now takes a skolemTerms argument (a list of BNodes)
that indicates which BNodes
should not be treated as an undistinguished variable
- added IdentifyDerivedPredicates to FuXi.Rete.Magic which takes a DDL
meta graph, an OWL graph and
a ruleset.  Returns the set of derived predicate names as determined
by the input.  See:
http://code.google.com/p/fuxi/wiki/DataDescriptionLanguage for a
description of the data description
- changed setupDescriptionLogicProgramming method on
FuXi.Rete.ReteNetwork instances so
AdditionalRules is used to add additional clauses if addPDSemantics is
specified as true
- added versions of normalizeUri and compute_qname used to create
QNames in generated SPARQL queries
(during top-down proving)

In FuXi.Rete.Util:
- lazyGeneratorPeek generalized to arbitrary first N terms checked.
Added helper class as a special
generator with an indication of success or failure of an earlier

In FuXi.Rete.Magic:
- Completely refactored out RDFTuplesToSPARQL which takes a
conjunction of Horn literals and returns
the corresponding SPARQL query
- Added normalizeBindingsAndQuery which takes a query in the form of a
list of variables to bind to
an a priori set of bindings and a conjunct of literals and applies the
- Various fixes to RunQuery related to generation of SPARQL and
determination of whether or not
query is ground or not.
- RunQuery now returns a generator over its solutions (except ASK
queries) - this ensures that the
entire proof chain is solved incrementally and via lazy iteration
rather than fetching all answers
from a ground query before continuation.
- Added a framework for indentation of debugging (to determine shape
of the proof search space), and
a means for storing answers to queries for subsequent invokations
- lazyGeneratorPeek is now used to ensure the propagation of proof
searching is incremental and
facilitated by lazil incrementing a generator
- Fixed code determining variables to return for RunQuery
- Fixed handling of multiple answers from combined ground querying for
a list of literals in a rule
- Created PML proofs now include query nodes
- Building of proof graph (in PML) is optional
- Added fix to catch answers that do not combine properly (they are
discarded as subsequent answers)
- Fixed sip strategy handling of previously solved goals and adornment
- Added check to ensure that in the absence of any valid rules for a
goal and with an unsuccessful
ground query, if the query prediacate is not in the IDB, we have
To FuXi.Syntax.InfixOWL
- added DeepClassClear which recursively clears the given class,
continuing where any related class
is an anonymous class
- Added common MalformedClass exception
- Added support for comparing BooleanClass instances where equivalence
is determined by equivalence
of their members
- Fixed order of class inheritance for EnumeratedClass and
- Fixed Restriction to better handle when the graph already has the
restriction defined in the graph
and where it doesn't and we want to populate the graph
using the given arguments
- If either of someValuesFrom, allValuesFrom, etc.. is anything other
than a Class, or Identifier,
this signals that there is a value already specified in the underlying
graph which needs to be
- Restrictions are now hashable (and thus comparable)
Added an implementation for a top-down query answering component

-- Chime
Received on Monday, 21 December 2009 22:36:09 UTC

This archive was generated by hypermail 2.3.1 : Tuesday, 6 January 2015 20:01:06 UTC