module Subgraphs where import "Utils" import "XML" import "N3Parser" import "Array" import "LoadTree" import "Observe" import "GenerateDB" import "Transform" import "ToN3" import "TripleData" -- Author: G.Naudts. Mail: naudts_vannoten@yahoo.com. -- this module divides the db into subgraphs testSubDB = subDB ["authen.axiom.n3", "authen.lemma.n3"] -- This generates a database and a query . Input is a list of filenames; -- output is a database and a query as a list of (connected) triple sets. subDB :: [String] -> IO() subDB filenames = do listF <- sequence (map readFile filenames) putStr (transformToN3 listF) -- transforms db and query to N3 transformToN3 :: [String] -> String transformToN3 inputs = s where (db, query) = getDBQuery inputs s = dbToN3 db ++ dbToN3 query subDB1 :: [String] -> IO() subDB1 filenames = do listF <- sequence (map readFile filenames) putStr (transformToHaskell listF) -- transforms db and query to Haskell internal format transformToHaskell :: [String] -> String transformToHaskell inputs = s where (db, query) = getDBQuery inputs s = show db ++ show query -- returns db and query ([TripleSet], [TripleSet]) getDBQuery inputs = (dbOut, queryOut) where (dbH, queryH) = transTree (mergeInput inputs (Tag("semTree", [], ""))) dbOut = subgraphDB dbH 1 queryOut = subgraphDB queryH 1 -- The function subgraphDB will take every triple from the DB and make sure -- every TripleSet is a connected subgraph and different TripleSets are not -- connected. -- rules are placed at the back of the db; they are treated in a special way. -- embedded rules are not yet supported. subgraphDB :: DB -> Int -> DB subgraphDB [] i = [] subgraphDB (ts:db) i -- place rules at the back |bv1 && bv2 = (subgraphDB db (i)) ++ [ts] |bv1 = (subgraphDB db (i+1)) ++ [[r1]] |bool1 == False && bv2 = ts1:(subgraphDB db1 i) |bool1 == False = ts1:(subgraphDB db1 (i+1)) |bv2 = subgraphDB (ts1:db1) i |otherwise = subgraphDB (ts1:db1) (i+1) where (ts1, db1, bool1) = transferFromDB (ts, db, False) testRule (Rule(ants, seq, nr):ts) = True testRule ts = False bv1 = testRule ts (Rule(ants, seq, nr)):ts2 = ts r1 = Rule(ants, seq, i) bv2 = i == -1 -- transferFromDB will transfer connected triples from a DB -- to a TripleSet transferFromDB :: (TripleSet, DB, Bool) -> (TripleSet, DB, Bool) transferFromDB ([], db, bool) = ([], db, bool) transferFromDB (ts, [], bool) = (ts, [], bool) transferFromDB (ts, (ts1:db), bool) | ts1 == [] = transferFromDB (ts, db, bool) | otherwise = (ts4, ts3:db1,bool1 || bool2) where (ts2, ts3, bool1) = transferFromTripleSet (ts, ts1, bool) (ts4, db1, bool2) = transferFromDB (ts2, db, False) testTransferFromTripleSet = show (transferFromTripleSet (ts1, ts2, False)) testTransferFromTripleSet1 = show (transferFromTripleSet (ts1, ts3, False)) transferFromTripleSet :: (TripleSet, TripleSet, Bool) -> (TripleSet, TripleSet, Bool) transferFromTripleSet ([], ts2, bool) = ([], ts2, bool) transferFromTripleSet (ts1, [], bool) = (ts1, [], bool) transferFromTripleSet (ts1, (t:ts2), bool) | bool1 = (ts4, ts5, True) | otherwise = (ts4, t1:ts5, bool2) where (ts3, t1, bool1) = transferFromTriple (ts1, t, bool) (ts4, ts5, bool2) = transferFromTripleSet (ts3, ts2, bool1) testTransferFromTriple = show (transferFromTriple (ts1, tau1, False)) testTransferFromTriple1 = show (transferFromTriple (ts1, taut, False)) -- transfers a triple in a tripleset if it belongs to the same -- subgraph transferFromTriple :: (TripleSet, Triple, Bool) -> (TripleSet, Triple, Bool) transferFromTriple ([], t, bool) = ([], t, bool) transferFromTriple (ts, t, bool) | connectTripleInTripleSet ts t = (ts ++ [t], t, True) | otherwise = (ts, t, False) -- the function connectTripleInTripleSet will see whether it is -- connected to a triple in a TripleSet. connectTripleInTripleSet :: TripleSet -> Triple -> Bool connectTripleInTripleSet [] t = False connectTripleInTripleSet ((Rule (ants, con, _)):xs) t = connectTripleInTripleSet xs t connectTripleInTripleSet t (Rule (ants, con, _)) = False connectTripleInTripleSet ((Triple (sub1, pred1, obj1)):xs) t@(Triple(sub2, pred2, obj2)) | sub1 == sub2 && (not (testVar sub1)) && (not (testVar sub2)) = True | obj1 == obj2 && (not (testVar obj1)) && (not (testVar obj2)) = True | sub1 == obj2 && (not (testVar sub1)) && (not (testVar obj2)) = True | obj1 == sub2 && (not (testVar obj1)) && (not (testVar sub2)) = True | otherwise = connectTripleInTripleSet xs t where testVar (Var (EVar v)) = True testVar (Var (UVar v)) = True testVar t = False su1 = subDB ["animal.n3", "animal-simple.n3"] su2 = subDB ["authen.axiom.n3","authen.lemma.n3"] -- ok su3 = subDB ["danb.n3", "danb-query.n3"] su4 = subDB ["danc.n3", "danc-query.n3"] -- eliminate log:forSome su5 = subDB ["gedcom-facts.n3", "gedcom-relations.n3", "gedcom-query.n3"] su6 = subDB ["graph.axiom.n3", "graph.lemma.n3"] -- ontology features su6a = subDB ["graph.axiom1.n3", "graph.lemma1.n3"] su7 = subDB ["lists.n3", "lists-query.n3"] -- na su8 = subDB ["rdf-facts.n3", "rdf-rules.n3", "rdf-query.n3"] su9 = subDB ["rdfc25May-test.n3", "rdfc25May.n3"] su10 = subDB ["rdfs-rules.n3", "rdfs-query.n3"] su11 = subDB ["russell.axiom.n3", "russell.lemma.n3"] su12 = subDB ["subclass.n3", "subclass-query.n3"] su13 = subDB ["subprop.n3", "subprop-query.n3"] su14 = subDB ["test-test.n3", "test.n3"] su15 = subDB ["tpoint-all.n3", "tpoint-facts.n3", "tpoint.n3", "tpoint-query.n3"] su16 = subDB ["varprop.n3", "varprop-query.n3"] su17 = subDB ["ziv.n3", "ziv-query.n3"] su18 = subDB ["wol-facts.n3", "wol-rules.n3", "wol-query.n3"] su19 = subDB ["vogel.l.n3", "vogel.q.n3"] su20 = subDB ["boole.axiom.n3", "boole.lemma.n3"] su21 = subDB ["induction.axiom.n3", "induction.query.n3"] su22 = subDB ["Owls.n3", "owls.query.n3"] su23 = subDB ["logic.a.n3", "logic.q.n3"] su24 = subDB ["unif.n3","unif.q.n3"] su25 = subDB ["ontology.axiom.n3", "ontology.query.n3"] su26 = subDB ["ontology1.axiom.n3", "ontology1.query.n3"] su99 = subDB ["graphTest.a.n3", "graphTest.q.n3"] su27 = subDB ["gedcom-simple.n3", "gedcom-relations.n3", "gedcom-qsimple.n3"] su28 = subDB ["owns.n3", "owns.q.n3"] su29 = subDB ["ontology2.axiom.n3", "ontology.query.n3"] su30 = subDB ["eq.a.n3", "eq.q.n3"] su32 = subDB ["path.axiom.n3", "path.query.n3"] su34 = subDB ["boole.axiom.n3", "boole.lemma.n3"] su35 = subDB ["booleW.a.n3", "booleW.q.n3"] sut35 = subDB1 ["booleW.a.n3", "booleW.q.n3"] su36 = subDB ["schedRDF.a.n3", "hosts.a.n3", "schedRDF.q.n3"] su37 = subDB ["hosts.a.n3", "schedRDF.q.n3"] -- example authen.axiom.n3 and authen.lemma.n3 ts1 = [tau1, tau2] ts2 = [tau3, taut] ts3 = [taut, taut1] taut = Triple(URI " ", URI ":member :member", URI " ") taut1 = Triple(URI " ", URI ":member :member", URI " ") -- tau1 = Triple(URI " ", -- URI ":member :member", URI " ") -- tau2 = Triple(URI " ", URI ":w3cmember :w3cmember", -- URI " ") -- tau3 = Triple(URI " ", URI ":subscribed :subscribed", -- URI " ") -- tau4 = Triple(Var (UVar ":person :person"), URI ":member :member", Var (UVar ":institution :institution")) -- tau5 = Triple(Var (UVar ":institution :institution"), URI ":w3cmember :w3cmember", -- URI " ") -- tau6 = Triple(Var (UVar ":institution :institution"), URI ":subscribed :subscribed", -- Var (UVar ":mailinglist :mailinglist")) -- tau7 = Triple (Var (UVar ":person :person"), URI ":authenticated :authenticated", -- Var (UVar ":mailinglist :mailinglist")) -- ants = [tau4, tau5, tau6] -- cons = tau7 -- rule = Rule (ants, cons, 1) -- tau8 = Triple(Var (EVar "_:who _:who"), URI ":authenticated :authenticated", -- URI " ") -- tauQ = [tau8] -- tauDB = [tau1, tau2, tau3, rule] -- sub1 = (UVar ":person :person", URI " ") -- sub2 = (UVar ":mailinglist :mailinglist", URI " ") -- sub3 = (UVar ":institution :institution", URI " ") -- subList = [sub1, sub2, sub3]