Newcastle University Drylab/20 May 2008

Mark
Began the day by reading my new neural networks paper. Now moving onto the CellML tutorials. Worked through the cellML tutorials printing out the xml, and working through the signal transduction examples.

I then went onto downloading the COR program and started to look at becoming familiar with the language and how it fits in with XML.

Have also begun writing a java doc that reads in perfect data from a text file that can be used on a neural network. The program reads in each double value and performs a gaussian distribution on it generating a population of 1,000 tht is noisy data. It will output this in a file that can be input into the neural network program.

I started off by constructing a file parser which scanns the file for doubles. I also constructed a method that can perform the gaussian distribution step. I am now working on how to generate the population of 1 000 and also how to integrate the method with the parser.

Plan for tomorrow is to finish off the java doc and to start looking at further data structures for my evolutionary algorithm

Came in again to uni this evening and managed to get my double array input to work. I have also now written a full method for performing th gaussian distribution step.

Megan
Continue exploring the CELLML language and try to understand how to go about creating models of the parts
 * Followed the cellML tutorial
 * Look at wikipedia for brief overview
 * Try to understand example models in COR and the output of these
 * Outline possible variables and units for the broad parts

Morgan
Back to working on deletion. Hooked up the listener for the interaction types. Added BuildCircuit as a listener of that, and now it removes the TransferHandler when the edge button is enabled, and the edge listener when the pointer is enabled. Disabled un-selection of buttons.

Was trying to show Matt the debugged workbench and the truth tables promptly went back to hating my guts. God****. I'm going to rip the Input listener out entirely, since I think that's what's causing my grief. The user will just have to add his own god****ed rows.

Finally, that looks pretty stable. I also tooltipped all the buttons on the build panel and the behaviour panel, linking back to strings in Constants so that they're pretty easily changeable. I should make a method in PanelFactory for MenuItems and TreeNodes. Later, when I have deletion functionality.

DELETION WORKS. And it wasn't that hard either, not even the truth table stuff. HA. TAKE THAT.

Nina
Today I shall research RDFs and attempt to fill out more of the compatibility of parts matrix. I shall start by searching and reading about RDFs (resource description framework) on good old wiki and then try out the tutorial. RDF (Wiki)


 * Used as a general method of modeling information through a variety of syntax formats
 * An RDF model is a directed, labelled graph.
 * Makes statements about Web resources in the form of subject-predicate-object expressions called triples
 * i.e. "The sky has the color blue", where "the sky" is the object, "has the colour" is the predicate and "blue" is the subject.
 * Has two common serialization formats: XML and Notation3 (N3). The latter is easier to write by hand, follow and identify triple-encoded documents.
 * Collection of RDF statements represent a pseudograph. This data model is more naturally suited to certain types of knowledge than a relational or other ontology models.
 * Additional ontology languages can be built upon RDF
 * The subject of an RDF statement is a resource, possibly as named by a Uniform Resource Identifier (URI).
 * The predicate is a resource as well, representing a relationship.
 * The object is a resource or a Unicode string literal.

Example 1: In the English language statement 'New York has the postal abbreviation NY', 'New York' would be the subject, 'has the postal abbreviation' the predicate and 'NY' the object. Encoded as an RDF triple, the subject and predicate would have to be resources named by URIs. The object could be a resource or literal element. For example, in the N3 form of RDF:

  "NY" In this example, "urn:states:New%20York" is the URI denoting the U.S. state New York, "http://purl.org/dc/terms/alternative" is the URI for a predicate, and "NY" is a literal string. The triple above can also be equivalently represented in the standard RDF/XML format as:

  NY   Example 2: In a like manner, given that "http://en.wikipedia.org/wiki/Nina_Nielsen" identifies a particular resource, to say that the title of this resource is "Nina Nielsen" and its publisher is "Wikipedia" would be two assertions that could be expressed as valid RDF statements.   "Nina Nielsen".   "Wikipedia"

And these statements might be expressed in RDF/XML as:

  Nina Nielsen <dc:publisher>Wikipedia</dc:publisher> </rdf:Description> </rdf:RDF>

To an English-speaking person, the same information could be represented simply as: The title of this resource, which is published by Wikipedia, is 'Nina Nielsen' However, RDF puts the information in a formal way that a machine can understand. The purpose of RDF is to provide an encoding and interpretation mechanism so that resources can be described in a way that particular software can understand it, so that software can access and use information that it otherwise couldn't use. The following example shows how the above can be elaborated on, by combining multiple RDF vocabularies. Here, we note that the primary topic of the Wikipedia page is a "Person" whose name is "Nina Nielsen": <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:foaf="http://xmlns.com/foaf/0.1/" xmlns:dc="http://purl.org/dc/elements/1.1/"> <rdf:Description rdf:about="http://en.wikipedia.org/wiki/Nina_Nielsen"> Nina Nielsen</dc:title> <dc:publisher>Wikipedia</dc:publisher> <foaf:primaryTopic> <foaf:Person> <foaf:name>Nina Nielsen</foaf:name> </foaf:Person> </foaf:primaryTopic> </rdf:Description> </rdf:RDF> ie, "Jane says that john is the author of document X". An example of a SPARQL query to show country capitals in Africa, using a fictional ontology. PREFIX abc: <http://example.com/exampleOntology#>. SELECT ?capital ?country WHERE { ?x abc:cityname ?capital ; abc:isCapitalOf ?y. ?y abc:countryname ?country ; abc:isInContinent abc:Africa. } WHICH FORMAT WILL I BE USING? I REALLY HOPE I DON'T NEED TO USE XML AND HOPE TO USE N3. WILL I BE USING A QUERY LANGUAGE AND IF SO WHICH ONE? RDQL, versa, RQL, XUL? Problems with RDF.
 * Reification: Each statement (subject-predicate-object) together is assigned a URI and treated as a resource in which additional statements can be made.
 * Query language: predom. query language for RDF graphs is SPARQL, which like SQL.
 * The XML syntax for RDF is too verbose
 * The triple (subject, predicate, object) notation is not expressive enough
 * RDF's ability to reify statements is handled ambiguously.

RDF (Tutorial) http://rdfabout.com/quickintro.xpd ps. I think after reading some of the tutorial that I am going to stick to writing in N3 rather than XML. It looks easier. Is this ok?? What really sets RDF apart from XML and other things is that RDF is designed to represent knowledge in a distributed world. This means RDF is particularly concerned with meaning. Everything at all mentioned in RDF means something, whether a reference to something concrete in the world, an abstract concept, or a fact.

What makes RDF suited for distributed knowledge is that RDF applications can put together RDF files posted by different people around the Internet and easily learn from them new things that no single document asserted. It does this in two ways, first by linking documents together by the common vocabularies they use, and second by allowing any document to use any vocabulary. This flexibility is fairly unique to RDF Why use RDF?
 * You want to integrate data from different sources without custom programming.
 * You want to offer your data for re-use by other parties
 * You want to decentralize data in a way that no single party "owns" all the data.
 * You want to do something fancy with large amounts of data (browse, query, match, input, extract, ...), so you develop (or re-use) a generic tool that allows you to do this on top of the RDF data model (which has the advantage of not being tied to a proprietary data storage/representation technology, like a database dialect).

About the URI's Global names, which have the same meaning everywhere, are always Uniform Resource Identifiers (URIs).

URIs can have the same format as website addresses like http://www.w3.org/1999/02/22-rdf-syntax-ns#type, where that URI is the global name for some entity.

The fact that it looks like a web address is incidental. There may or may not be an actual website at that address, doesn't matter.

There are other types of URIs besides http:-type URIs.

URNs are a subtype of URI used for things like identifying books by their ISBN number, e.g. urn:isbn:0143034650.

TAGs are a general-purpose type of URI. Important point - Whatever their form, URIs you see in RDF documents are merely verbose names for entities, nothing more. Forget that it has anything to do with the web. Since URIs can be quite long, in various RDF notations they're usually abbreviated using the concept of namespaces from XML. That's what the colons are doing in :john, :hasMother. The colons indicate the name is an abbreviated form. I.e. The names were http://www.example.org/#john, http://www.example.org/#hasMother. When written out, URIs are generally enclosed in brackets to distinguish them from namespaced-abbreviated names. Literal values allow text to be included in RDF. This is used heavily when RDF is used for metadata:

<http://www.rdfabout.net/> a :Website. <http://www.rdfabout.net/> dc:title "rdf:about". <http://www.rdfabout.net/> dc:description "A website about Resource Description Framework." .

RDF As A Graph

There are two complementary ways of looking at RDF information. The first is as a set of statements, like above. The second way is as a graph.

Graphs consist of nodes interconnected by edges. In the Internet, for instance, the nodes are the computers, and the edges are the ethernet wires connecting them. Here's an example:

'''Another tutorial... RDF in depth''' On the Semantic Web, computers do the browsing for us.
 * Each arrow or edge is a RDF statement.
 * The name at the start of the arrow is the statement's subject, the name at the end of the arrow is the statement's object, and the name that labels the arrow is the predicate.
 * RDF as a graph expresses exactly the same information as RDF written out as triples, but the graph form makes it easier for us humans to see structure in the data.

The “SemWeb” enables computers to seek out knowledge distributed throughout the Web, mesh it, and then take action based on it. A full example: table and code.

====Table====

Code (N3)
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>. @prefix ex: <http://www.example.org/>. ex:vincent_donofrio ex:starred_in ex:law_and_order_ci. ex:law_and_order_ci rdf:type ex:tv_show. ex:the_thirteenth_floor ex:similar_plot_as ex:the_matrix

RDF is a general method to decompose knowledge into small pieces, with some rules about the meaning of those pieces. The point is to have a method so simple that it can express any fact, and yet so structured that computer applications can do useful things with knowledge expressed in RDF.

Suggestions about my three entities
It is necessary for me to complete the example matrix that I started last week to implement the meaning in RDF format. Bit stuck.. Dont know which RDF to download. Have downloaded one in PHP. Is it easier to download one in Java? Am I suppose to try and make a RDF graph from the pretend parts we have?
 * Subject - part a (such as TetR).
 * Predicate - "interacts with" or "controls gene expression of"
 * Object - part b (such as LacI)

I will try and do this... but first I will try and populate the matrix a bit more.