Math is hard!

I was complaining before about semantic web stuff being heavyweight? Here's a section from the SPARQL (RDF query language) specification:

2.5 Basic Graph Patterns

A basic graph patterns is a set of triple patterns and forms the basis of SPARQL query matching. Matching a basic graph pattern is defined in terms of generic entailment to allow for future extension of the language.

Definition: Basic Graph Pattern

A Basic Graph Pattern is a set of Triple Patterns.

Definition: E-entailment Regime

An E-entailment regime is a binary relation between subsets of RDF graphs.

A graph in the range of an E-entailment is called well-formed for the E-entailment.

This specification covers only simple entailment [RDF-MT] as E-entailment. Examples of other E-entailment regimes are RDF entailment [RDF-MT], RDFS entailment [RDF-MT], OWL entailment [OWL-Semantics].

Definition: Basic Graph Pattern equivalence

Two basic graph patterns are equivalent if there is a bijection M between the terms of the triple patterns that maps blank nodes to blank nodes and maps variables, literals and IRIs to themselves, such that a triple ( s, p, o ) is in the first pattern if and only if the triple ( M(s), M(p) M(o) ) is in the second.

This definition extends that for RDF graph-equivalence to basic graph patterns by preserving variables names across equivalent graphs

Now, this is not all that abstruse, but then I have a math degree and am used to it. Way back then I studied mathematical logic, thought it was fun but a lousy way to describe the world and a lousy model for computation. It seems to have triumphed, however, and now people are expected to speak that language (the RDF semantics spec is even worse). I have a hard time believing that working programmers (a set of which I myself am a member of, nowadays) are going to be gleefully soaking up all the model-theoretic semantic theory behind the semantic web.

Maybe I'm wrong, there are people willing to boil things down into understandability. This well-written article doesn't cover any sort of non-trivial queries however.

There seems to be a big gap between RDF-as-first-order-predicate-logic-with-model-theoretic-semantics and RDF-as-useful-flexible-emerging-data-standard. Looked at positively, it's a two-pronged thrust, from academia and hackerdom acting together.

A river runs over it

I did read John McPhee's great article Atchafalaya on attempts to keep the Mississippi river from doing what it wants to do, which is shift course entirely, several hundred miles upstream from New Orleans.

The river goes through New Orleans like an elevated highway. Jackson Square, in the French Quarter, is on high ground with respect to the rest of New Orleans, but even from the benches of Jackson Square one looks up across the levee at the hulls of passing ships. Their keels are higher than the AstroTurf in the Superdome, and if somehow the ships could turn and move at river level into the city and into the stadium they would hover above the playing field like blimps.

If ever an article called for extensive maps and diagrams, this is it. Unfortunatly it doesn't have them. McPhee is good at describing complex geographies in words, but still. It would be a neat project to have the web collectively generate a visual annotation. Here's my contribution (well, somebody else's, I'm just linking to it). More pictures at the link.

Update: A detailed map of the Old River Control Structure, which figures prominently in the McPhee article and is what is supposed to keep the Mississippi on its present course, but is hampered by the fact that it's kind of hard to push a big river around when it doesn't feel like cooperating.