Metadata/data classification pattern/framework‏

(This isn't very much RDF-XML related, although that format could be one of
the
import/export syntaxes for a tool built upon this framework)

In the path of building a KR/Ontology management system, where I've seen
many of the options available, I've thinked there should a way to finest
grain
to represent information and schema data, providing there will be a way to
decompose,
for later composing the information in given format should be required.

In the middle, this 'abstract representation' will allow to enrich data
provided, by
merging ontologies, reification, entailment and inferencing.

The whole idea consists in treating entities in an ontology as being one of
three kinds: Signs (Names), Object (Values) and Concepts (Types). This is a
way
of 'semantic' interpretation/representation of data-metadata but rather also
a
'semiotic' one, in which treatment of signs, objects and meaning
relationships
is done basically this way.

Once we have reached the Type-Name-Object level of abstraction (where
models, meta models
and meta meta models can reside) the task to be acomplished is to arrange
the data
in a manner where inference, entailment and reification may occur. This
should be done
grouping or 'aggregating' the entities this way:

Values of the same Name
Values of the same Type

Names of the same Value
Names of the same Type

Types of the same Value
Types of the same Name

The 'aggregation' is done in a Container-Containee abstraction pattern
fashion,
where the objects contained in a container are inside the container playing
an
specific Role, and, the container itself, in turn, is containg its children
in another given role.

This way one could find, given, for example, that many values are inside a
type in
the same role, that those values are at least 'similar', or also they are
the same value,
maybe with different name.

So, one could find answers, and see graphically where objects and nodes in
the graph
are the same thing, refer to the same thing, or are logically 'grouped'
thogether,
conforming a bigger entity. A tool should be developed to manipulate objects
like that.
The work is the early stages of development, only coded the core classes of
the main data
structures are coded.

There should be necessary later to build a parser, one of a given textual
grammar
for this model, one for a XML representation of the model, and another tool
for generating
output in one of these representations from, for example, a RDBMs schema and
data or XML/RDFS/OWL datasources.

More information available at: https://xama.dev.java.net/

Regards,
Sebastian

-- 
View this message in context: http://www.nabble.com/Metadata-data-classification-pattern-framework%E2%80%8F-tp25050581p25050581.html
Sent from the w3.org - www-rdf-logic mailing list archive at Nabble.com.

Received on Thursday, 20 August 2009 15:56:00 UTC