Inbetween

So I have been thinking at lot about the inconsistency in RDF graphs that must arise when ever more than one authority has equal right to make statements about the same thing. The foundation of the problem is that there is no A Priori way to choose one set of statements over another, they are both equally true. And this will happen a lot when you take data from multiple systems because you cannot get users to all act in the same way when making classification decisions, even by giving them detailed training and manuals.

I wondered what it might look like if we generalised the approach to computing with the semantic web so that FOPC(programmatic logic) was a special case, rather than the only case.
That is, we accept inconsistency as a fundamental property. This would allow the semantic web to embrace the bottom up highly inconsistent folksonomies and strict banking applications in the same logic, proof and trust framework.

In traditional software applications there is only one authority; only one version of the truth is allowed and so inconsistency as a fundamental issue doesn't arise. In the post Schrodinger's Web and comments I tried to give an example of how easily this inconsistency arises even in a simple system as soon as you allow multiple authorities to have equal right to make statements, even when the software systems are identical. This is because however you train the users, when presented with choices to make in day to day operations no two users of separate systems will make exactly the same decisions about classification of the same thing.

I will borrowed the concept of Superposition from quantum mechanics. A super position is just the sum of all the possible states, in this case that would be a collection of inconsistent statements along with their source, call it a superposition node.

When graphs are joined and inconsistencies occur a superposition node could be created in the graph.
Superposition nodes are different, FOPC (programmatic logic) cannot be applied directly to them (it would fail on the inconsistencies). Instead statistical operators can be applied to merge or transform (but not collapse) different super positions, or instead a collapsing function could operate on it to choose the wining statement and collapse the super position into an ordinary node. If your application did wish to operate on the node with programmatic logic then a collapsing function must be supplied. The collapsing function uses some rule appropriate to the application to collapse the super position into a consistent statement that is then safely operated on by FOPC.

If a superposition node occurred in a portion of your graph that you didn't need to operate on programmatically then it need never be collapsed.

Single Authority Example: Banking
For example, a banking application would use a collapsing function based on which statements also contained trusted proof that they had the authority of the banking system i.e. in this case there is only one true authority so it is straightforward to collapse the superposition and allow the application logic to operate. Note the application logic should not have to know how to collapse the superposition, it just requires consistent trusted data.

Multiple Authority Example: Library System Catalogues
In the previous example I gave where multiple libraries catalogues the same work with different number of editions, when these descriptions are brought together, a superposition node occurs in the graph at the editions point. So a Work is related to a superposition of editions. Here the collapsing function could be statistical, choosing which ever was the most popular statement. The rest of the application then works off that choice.
But if you were creating an application for a university research, maybe you would create a collapsing function that gave extra weight to the statements of other research libraries over public libraries.

Statistical Operators
For some applications the major work will be in statistical operations on superposition rather than any programmatic logic. The Google spell checker springs to mind. This effectively uses statistical methods based on what many people have typed and then retyped when getting no results combined with the people peoples reactions to the offered spelling corrections.
The real work is in the manipulation of the superposition rather than any procedural logic based on a collapse.

A few comments on the previous posting have suggested we need to change the way users behave. I think that is unrealistic. I would rather we created systems that supported the way users do behave (and that alas is inconsistently).

So that’s my thoughts on inconsistency and the semantic web.
Trying to avoid it seems so limiting to me, and I don't see why we should.