programming languages - department of computer …cannata/cs345/new class notes/14 haskell part...

Dr. Philip Cannata 1

Programming Languages!

Haskell Part 2


A programming language is a language with a well-defined syntax (lexicon and grammar), type system, and semantics that can be used to implement a set of algorithms.

Haskell


Haskell: /lusr/bin/hugs, should be in your default $PATH or for windows, download and install winhugs at http://cvs.haskell.org/Hugs/pages/downloading.htm $ hugs __ __ __ __ ____ ___ _________________________________________ || || || || || || ||__ Hugs 98: Based on the Haskell 98 standard ||___|| ||__|| ||__|| __|| Copyright (c) 1994-2005 ||---|| ___|| World Wide Web: http://haskell.org/hugs || || Bugs: http://hackage.haskell.org/trac/hugs || || Version: 20051031 _________________________________________ Haskell 98 mode: Restart with command line option -98 to enable extensions Type :? for help Hugs> :load 10H2 Main>

To load the file “10H2.hs” from the directory in which you started hugs. Similar for 10Logic and 10Movie


Propositions:

Statements that can be either True or False Logical Operators: •  Negation: not

not :: Bool-> Bool not True = False not False = True

•  Conjunction: && (&&) :: Bool-> Bool-> Bool False && x = False True && x = x

•  Disjunction: || (||) :: Bool-> Bool-> Bool True || x = True False || x = x

Propositional Logic

Logical Operators: •  Implication (if – then): ==> Antecedent ==> Consequent

(==>) :: Bool -> Bool -> Bool x ==> y = (not x) || y

•  Equivalence (if, and only if): <=> (<=>) :: Bool -> Bool -> Bool x <=> y = x == y

•  Not Equivalent <+> (<+>) :: Bool -> Bool -> Bool x <+> y = x /= y


Truth tables: P && Q P || Q not P P ==> Q P <=> Q P <+> Q

P Q P && Q

False False False

False True False

True False False

True True True

P Q P || Q

False False False

False True True

True False True

True True True

P ¬ P

False True

True False

P Q P→Q False False True False True True True False False True True True

P Q P<=>Q

False False True

False True False

True False False

True True True

P Q P <+> Q

False False False

False True True

True False True

True True False


Proposition (WFF): ((P ∨ Q)∧((¬P)→Q)) P Q

False False

False True

True False

True True

False

True

True

True

(P ∨ Q) (¬P)

True

True

False

False

((¬P)→Q)

False

True

True

True

((P∨Q)∧((¬P)→Q))

False

True

True

True

Some True: prop is Satisfiable* If they were all True: Valid / Tautology

All False: Contradiction (not satisfiable*)

*Satisfiability was the first known NP-complete problem

If prop is True when all variables are True: P, Q ((P∨Q)∧((¬P)→Q))

A Truth double turnstile

Reasoning with Truth Tables


•  If there is a polynomial algorithm for any NP-hard problem, then there are polynomial algorithms for all problems in NP, and hence P = NP;

•  If P ≠ NP, then NP-hard problems have no solutions in polynomial time, while P = NP does not resolve whether the NP-hard problems can be solved in polynomial time;

•  A common mistake is to think that the NP in NP-hard stands for non-polynomial. Although it is widely suspected that there are no polynomial-time algorithms for NP-hard problems, this has never been proven. Moreover, the class NP also contains all problems which can be solved in polynomial time.

The class P consists of all those decision problems (see Delong, page 159) that can be solved on a deterministic sequential machine in an amount of time that is polynomial in the size of the input; the class NP consists of all those decision problems whose positive solutions can be verified in polynomial time given the right information.

A problem is NP-hard if an algorithm for solving it can be translated into one for solving any NP-problem (nondeterministic polynomial time) problem. NP-hard therefore means "at least as hard as any NP-problem," although it might, in fact, be harder.

Complexity Theory


truthTable :: (Bool -> Bool -> Bool) -> [Bool] truthTable wff = [ (wff p q) | p <- [True,False], q <- [True,False]] tt = (\ p q -> not (p ==> q)) Hugs> :load 10Logic.hs LOGIC> :type tt tt :: Bool -> Bool -> Bool LOGIC> truthTable tt [False,True,False,False] LOGIC> or (truthTable tt) True LOGIC> and (truthTable tt) False

Truth Table Application


Satisfiable: Are there well formed propositional formulas that return True for some input? satisfiable1 :: (Bool -> Bool) -> Bool satisfiable1 wff = (wff True) || (wff False) satisfiable2 :: (Bool -> Bool -> Bool) -> Bool satisfiable2 wff = or [ (wff p q) | p <- [True,False], q <- [True,False]] satisfiable3 :: (Bool -> Bool -> Bool -> Bool) -> Bool satisfiable3 wff = or [ (wff p q r) | p <- [True,False], q <- [True,False], r <- [True,False]] ( \ p -> not p) ( \ p q -> (not p) || (not q) ) ( \ p q r -> (not p) || (not q) && (not r) )

Define these first infix 1 ==> (==>) :: Bool -> Bool -> Bool x ==> y = (not x) || y infix 1 <=> (<=>) :: Bool -> Bool -> Bool x <=> y = x == y infixr 2 <+> (<+>) :: Bool -> Bool -> Bool x <+> y = x /= y


Validity (Tautology): Are there well formed propositional formulas that return True no matter what their input values are? valid1 :: (Bool -> Bool) -> Bool valid1 wff = (wff True) && (wff False) valid2 :: (Bool -> Bool -> Bool) -> Bool valid2 wff = (wff True True) && (wff True False) && (wff False True) && (wff False False)

( \ p -> p || not p ) -- Excluded Middle ( \ p -> p ==> p ) ( \ p q -> p ==> (q ==> p) ) ( \ p q -> (p ==> q) ==> p )


Tautological Proof It’s either summer or winter. If it’s summer, I’m happy. If it’s winter, I’m happy. Is there anything you can uncompress from this? ( (s ∨ w) ^ (s -> h) ^ (w -> h) ) -> h valid3 :: (Bool -> Bool -> Bool -> Bool) -> Bool valid3 bf = and [ bf r s t| r <- [True,False], s <- [True,False], t <- [True,False]] LOGIC> valid3 (\ s w h -> ((s || w) && (s ==> h) && (w ==> h)) ==> h) True Is h a Truth?

Another form of a un-compression (proof):

( (p ∨ q) ^ (¬p ∨ r) ^ (¬q ∨ r) ) -> r ( (p ^ ¬p) ∨ (r ^ q) ^ (¬q ∨ r) ) -> r (F ∨ (q ^ ¬q) ∨ r) -> r r -> r ¬r ∨ r .: T

(Convince yourself of this using logEquiv3)


if … then … else …

( (c → b) & (~c → a) )

( (c & b) ∨ (~c & a) )

LOGIC> valid3 (\ c a b ->((c==>a) && ((not c)==>b))) False LOGIC> logEquiv3 (\ c a b ->((c==>a) && ((not c)==>b))) (\ c a b -> ((c && a) || ((not c) && b))) True


Contradiction (Not Satisfiable): Are there well formed propositional formulas that return False no matter what their input values are? contradiction1 :: (Bool -> Bool) -> Bool contradiction1 wff = not (wff True) && not (wff False) contradiction2 :: (Bool -> Bool -> Bool) -> Bool contradiction2 wff = and [not (wff p q) | p <- [True,False], q <- [True,False]] contradiction3 :: (Bool -> Bool -> Bool -> Bool) -> Bool contradiction3 wff = and [ not (wff p q r) | p <- [True,False], q <- [True,False], r <- [True,False]] ( \ p -> p && not p) ( \ p q -> (p && not p) || (q && not q) ) ( \ p q r -> (p && not p) || (q && not q) && (r && not r) )


Truth: Are there well formed propositional formulas that return True when their input is True truth1 :: (Bool -> Bool) -> Bool truth1 wff = (wff True) truth2 :: (Bool -> Bool -> Bool) -> Bool truth2 wff = (wff True True)

( \ p -> not p)

( \ p q -> (p && q) || (not p ==> q))

( \ p q -> not p ==> q)

( \ p q -> (not p && q) && (not p ==> q) )


Equivalence:

logEquiv1 :: (Bool -> Bool) -> (Bool -> Bool) -> Bool logEquiv1 bf1 bf2 = (bf1 True <=> bf2 True) && (bf1 False <=> bf2 False)

logEquiv2 :: (Bool -> Bool -> Bool) -> (Bool -> Bool -> Bool) -> Bool logEquiv2 bf1 bf2 = and [(bf1 r s) <=> (bf2 r s) | r <- [True,False], s <- [True,False]]

logEquiv3 :: (Bool -> Bool -> Bool -> Bool) -> (Bool -> Bool -> Bool -> Bool) -> Bool logEquiv3 bf1 bf2 = and [(bf1 r s t) <=> (bf2 r s t) | r <- [True,False], s <- [True,False], t <- [True,False]]

formula3 p q = p formula4 p q = (p <+> q) <+> q formula5 p q = p <=> ((p <+> q) <+> q)

*Haskell> logEquiv2 formula3 formula4 True *Haskell> logEquiv2 formula4 formula5 False


Equivalence continued: logEquiv1 id (\ p -> not (not p)) id is the identity function, i.e., id True gives True logEquiv1 id (\ p -> p && p) logEquiv1 id (\ p -> p || p) logEquiv2 (\ p q -> p ==> q) (\ p q -> not p || q) logEquiv2 (\ p q -> not (p ==> q)) (\ p q -> p && not q) logEquiv2 (\ p q -> not p ==> not q) (\ p q -> q ==> p) logEquiv2 (\ p q -> p ==> not q) (\ p q -> q ==> not p) logEquiv2 (\ p q -> not p ==> q) (\ p q -> not q ==> p) logEquiv2 (\ p q -> p <=> q) (\ p q -> (p ==> q) && (q ==> p)) logEquiv2 (\ p q -> p <=> q) (\ p q -> (p && q) || (not p && not q)) logEquiv2 (\ p q -> p && q) (\ p q -> q && p) logEquiv2 (\ p q -> p || q) (\ p q -> q || p) logEquiv2 (\ p q -> not (p && q)) (\ p q -> not p || not q) logEquiv2 (\ p q -> not (p || q)) (\ p q -> not p && not q) logEquiv3 (\ p q r -> p && (q && r)) (\ p q r -> (p && q) && r) logEquiv3 (\ p q r -> p || (q || r)) (\ p q r -> (p || q) || r) logEquiv3 (\ p q r -> p && (q || r)) (\ p q r -> (p && q) || (p && r)) test9b logEquiv3 (\ p q r -> p || (q && r)) (\ p q r -> (p || q) && (p || r))

-- Idempotence -- Idempotence -- Idempotence -- Implication -- Contrapositive -- Contrapositive -- Contrapositive -- Contrapositive -- Commutativity -- Commutativity -- deMorgan -- deMorgan -- Associativity -- Associativity -- Distributivity -- Distributivity


Why Reasoning with Truth Tables is Infeasible

Works fine when there are 2 variables {T,F} × {T,F} = set of potential values of variables 2 × 2 lines in truth table

Three variables — starts to get tedious {T,F} × {T,F} × {T,F} = set of potential values 2 × 2 × 2 lines in truth table

Twenty variables — definitely out of hand 2 × 2 × … × 2 lines (220) You want to look at a million lines? If you did, how would you avoid making errors?

Hundreds of variables — not in a million years à A need for Predicate Logic. We’ll look at this with Prolog.


Haskell and SQL


Standard Oracle scott/tiger emp dept database


emp = [ (7839, "KING", "PRESIDENT", 0, "17-NOV-81", 5000, 10), (7698, "BLAKE", "MANAGER", 7839, "01-MAY-81", 2850, 30), (7782, "CLARK", "MANAGER", 7839, "09-JUN-81", 2450, 10), (7566, "JONES", "MANAGER", 7839, "02-APR-81", 2975, 20), (7788, "SCOTT", "ANALYST", 7566, "09-DEC-82", 3000, 20), (7902, "FORD", "ANALYST", 7566, "03-DEC-81", 3000, 20), (7369, "SMITH", "CLERK", 7902, "17-DEC-80", 800, 20), (7499, "ALLEN", "SALESMAN", 7698, "20-FEB-81", 1600, 30), (7521, "WARD", "SALESMAN", 7698, "22-FEB-81", 1250, 30), (7654, "MARTIN", "SALESMAN", 7698, "28-SEP-81", 1250, 30), (7844, "TURNER", "SALESMAN", 7698, "08-SEP-81", 1500, 30), (7876, "ADAMS", "CLERK", 7788, "12-JAN-83", 1100, 20), (7900, "JAMES", "CLERK", 7698, "03-DEC-81", 950, 30), (7934, "MILLER", "CLERK", 7782, "23-JAN-82", 1300, 10) ] dept = [ (10, "ACCOUNTING", "NEW YORK"), (20, "RESEARCH", "DALLAS"), (30, "SALES", "CHICAGO"), (40, "OPERATIONS", "BOSTON") ]

Standard Oracle scott/tiger emp dept database in Haskell


Main>Main> [(empno, ename, job, sal, deptno) | (empno, ename, job, _, _, sal, deptno) <- emp] [(7839,"KING","PRESIDENT",5000,10), (7698,"BLAKE","MANAGER",2850,30), (7782,"CLARK","MANAGER",2450,10), (7566,"JONES","MANAGER",2975,20), (7788,"SCOTT","ANALYST",3000,20), (7902,"FORD","ANALYST",3000,20), (7369,"SMITH","CLERK",800,20), (7499,"ALLEN","SALESMAN",1600,30), (7521,"WARD","SALESMAN",1250,30), (7654,"MARTIN","SALESMAN",1250,30), (7844,"TURNER","SALESMAN",1500,30), (7876,"ADAMS","CLERK",1100,20), (7900,"JAMES","CLERK",950,30), (7934,"MILLER","CLERK",1300,10)] Main>


Main> [(empno, ename, job, sal, deptno) | (empno, ename, job, _, _, sal, deptno) <- emp, deptno == 10] [(7839,"KING","PRESIDENT",5000,10), (7782,"CLARK","MANAGER",2450,10), (7934,"MILLER","CLERK",1300,10)] Main>


Main> [(empno, ename, job, sal, dname) | (empno, ename, job, _, _, sal, edeptno) <- emp, (deptno, dname, loc) <- dept, edeptno == deptno ] [(7839,"KING","PRESIDENT",5000,"ACCOUNTING"), (7698,"BLAKE","MANAGER",2850,"SALES"), (7782,"CLARK","MANAGER",2450,"ACCOUNTING"), (7566,"JONES","MANAGER",2975,"RESEARCH"), (7788,"SCOTT","ANALYST",3000,"RESEARCH"), (7902,"FORD","ANALYST",3000,"RESEARCH"), (7369,"SMITH","CLERK",800,"RESEARCH"), (7499,"ALLEN","SALESMAN",1600,"SALES"), (7521,"WARD","SALESMAN",1250,"SALES"), (7654,"MARTIN","SALESMAN",1250,"SALES"), (7844,"TURNER","SALESMAN",1500,"SALES"), (7876,"ADAMS","CLERK",1100,"RESEARCH"), (7900,"JAMES","CLERK",950,"SALES"), (7934,"MILLER","CLERK",1300,"ACCOUNTING")] Main>


Main> length [sal | (_, _, _, _, _, sal, _) <- emp] 14 Main>

Main> (\y -> fromIntegral(sum y) / fromIntegral(length y)) ([sal | (_, _, _, _, _, sal, _) <- emp]) 2073.21428571429 Main>


Main> map sqrt (map fromIntegral [sal | (_, _, _, _, _, sal, _) <- emp]) [70.7106781186548, 53.3853912601566, 49.4974746830583, 54.5435605731786, 54.7722557505166, 54.7722557505166, 28.2842712474619, 40.0, 35.3553390593274, 35.3553390593274, 38.7298334620742, 33.166247903554, 30.8220700148449, 36.0555127546399] Main>


Main> (map sqrt . map fromIntegral) [sal | (_, _, _, _, _, sal, _) <- emp] [70.7106781186548, 53.3853912601566, 49.4974746830583, 54.5435605731786, 54.7722557505166, 54.7722557505166, 28.2842712474619, 40.0, 35.3553390593274, 35.3553390593274, 38.7298334620742, 33.166247903554, 30.8220700148449, 36.0555127546399] Main>


Main> zip ([name | (_, name, _, _, _, _, _) <- emp]) (map sqrt (map fromIntegral [sal | (_, _, _, _, _, sal, _) <- emp])) [("KING",70.7106781186548), ("BLAKE",53.3853912601566), ("CLARK",49.4974746830583), ("JONES",54.5435605731786), ("SCOTT",54.7722557505166), ("FORD",54.7722557505166), ("SMITH",28.2842712474619), ("ALLEN",40.0), ("WARD",35.3553390593274), ("MARTIN",35.3553390593274), ("TURNER",38.7298334620742), ("ADAMS",33.166247903554), ("JAMES",30.8220700148449), ("MILLER",36.0555127546399)] Main>


Main> [(name, sal, dept) | (_, name, _, _, _, sal, dept) <- emp, dept `elem` [20, 30]] [("BLAKE",2850,30), ("JONES",2975,20), ("SCOTT",3000,20), ("FORD",3000,20), ("SMITH",800,20), ("ALLEN",1600,30), ("WARD",1250,30), ("MARTIN",1250,30), ("TURNER",1500,30), ("ADAMS",1100,20), ("JAMES",950,30)] Main>


Main> [(name, sal, dept) | (_, name, _, _, _, sal, dept) <- emp, dept `notElem` [20, 30]] [("KING",5000,10), ("CLARK",2450,10), ("MILLER",1300,10)] Main>


Main> [(name, sal, dept) | (_, name, _, _, _, sal, dept) <- emp, dept `notElem` [20, 30]] ++ [(name, sal, dept) | (_, name, _, _, _, sal, dept) <- emp, dept `elem` [20, 30]] [("KING",5000,10), ("CLARK",2450,10), ("MILLER",1300,10), ("BLAKE",2850,30), ("JONES",2975,20), ("SCOTT",3000,20), ("FORD",3000,20), ("SMITH",800,20), ("ALLEN",1600,30), ("WARD",1250,30), ("MARTIN",1250,30), ("TURNER",1500,30), ("ADAMS",1100,20), ("JAMES",950,30)] Main>


A Hint of Curry and Skolem -- See also: http://book.realworldhaskell.org/read/functional-programming.html

cadd a b = (\ x -> (\ y -> x + y)) a b

cmap f [] = [] cmap f l = (\ x -> (\ (y:ys) -> x y : cmap x ys )) f l

-- Main> foldr (/) 2 [8,4,2] -- 2.0 -- Main> (/) 8 ((/) 4 ((/) 2 2)) -- 2.0 cfoldr f i [a] = f a i cfoldr f i l = (\ x -> (\ y -> (\ (z:zs) -> x z (cfoldr x y zs) ))) f i l

-- cfoldr (/) 2 [8,4,2]

-- The class of functions that we can express using foldr is called primitive recursive. -- A surprisingly large number of list manipulation functions are primitive recursive. -- For example, here's map, filter and foldl written in terms of foldr: cfoldr_map f l = cfoldr (\ x -> (\ y -> f x : y)) [] l

-- cfoldr_map (\ x -> x*x) [1,2,3,4,5] cfoldr_filter f l = cfoldr (\ x -> (\ y -> if f x then x : y else y )) [] l

-- cfoldr_filter (\ x -> x /= 4) [1,2,3,4,5] -- cfoldr_filter (\ x -> (x `mod` 2) == 0) [1,2,3,4,5]

-- Main> foldl (/) 2 [8,4,2] -- 0.03125 -- Main> (/) ((/) ((/) 2 8) 4) 2 -- 0.03125 cflip f a b = (\ x -> (\ y -> (\ z -> x b a))) f a b cfoldr_foldl f i l = cfoldr (cflip f) i (reverse l)

-- cfoldr_foldl (/) 2 [8,4,2]


Function Bodies using Combinators

A function is called primitive recursive if there is a finite sequence of functions ending with f such that each function is a successor, constant or identity function or is defined from preceding

functions in the sequence by substitution or recursion.

s f g x = f x (g x) k x y = x b f g x = f (g x) c f g x = f x g y f = f (y f) cond p f g x = if p x then f x else g x -- Some Primitive Recursive Functions on Natural Numbers pradd x z = y (b (cond ((==) 0) (k z)) (b (s (b (+) (k 1)) ) (c b pred))) x prmul x z = y (b (cond ((==) 0) (k 0)) (b (s (b (+) (k z)) ) (c b pred))) x prexp x z = y (b (cond ((==) 0) (k 1)) (b (s (b (*) (k x)) ) (c b pred))) z prfac x = y (b (cond ((==) 0) (k 1)) (b (s (*) ) (c b pred))) x -- Alternative formulation pradd1 x z = y (b (cond ((==) 0) (k z)) (b (s (b (+) (k 1)) ) (c b pred))) x prmul1 x z = y (b (cond ((==) 0) (k 0)) (b (s (b (pradd1) (k z)) ) (c b pred))) x prexp1 x z = y (b (cond ((==) 0) (k 1)) (b (s (b (prmul1) (k x)) ) (c b pred))) z prfac1 x = y (b (cond ((==) 0) (k 1)) (b (s (prmul1) ) (c b pred))) x

No halting problem here but not Turing complete either

Implies recursion or bounded loops, if-then-else constructs and run-time stack.

see the BlooP language in


A Strange Proposal

s f g x = f x (g x) k x y = x b f g x = f (g x) c f g x = f x g y f = f (y f) cond p f g x = if p x then f x else g x

-- Some Primitive Recursive Functions on Natural Numbers pradd x z = y (b (cond ((==) 0) (k z)) (b (s (b (+) (k 1)) ) (c b pred))) x prmul x z = y (b (cond ((==) 0) (k 0)) (b (s (b (+) (k z)) ) (c b pred))) x prexp x z = y (b (cond ((==) 0) (k 1)) (b (s (b (*) (k x)) ) (c b pred))) z prfac x = y (b (cond ((==) 0) (k 1)) (b (s (*) ) (c b pred))) x

To find Primitive Recursive Functions, try something like the following:

prf x z = y (b (cond ((==) 0) (k A)) (b (s AAAAAA . . . AAAAAAAAAA ) (c b pred))) A | Where each A is a possibly different element of {x z 0 1 + * s k b c ( ) “”} but at least having parentheses match.

Gödel may be lurking!

haskell type checker that rules out bad combinations


John McCarthy’s Takeaway

-- Primitive Recursive Functions on Lists are more interesting than PRFs on Numbers

prlen x = y (b (cond ((==) []) (k 0)) (b (s (b (+) (k 1)) ) (c b cdr))) x prsum x = y (b (cond ((==) []) (k 0)) (b (s (b (+) (car)) ) (c b cdr))) x prprod x = y (b (cond ((==) []) (k 1)) (b (s (b (*) (car)) ) (c b cdr))) x prmap f x = y (b (cond ((==) []) (k [])) (b (s (b (:) (f) ) ) (c b cdr))) x -- prmap (\ x -> (car x) + 2) [1,2,3] or -- prmap (\ x -> pradd (car x) 2) [1,2,3]

prFoldr fn z x = y (b (cond ((==) []) (k z)) (b (s (b fn (car)) ) (c b cdr))) x prfoo x = y (b (cond ((==) []) (k [])) (b (s (b (:) (cdr)) ) (c b cdr))) x -- A programming language should have first-class functions as (b p1 p2 . . . Pn), substitution, lists with car, cdr and cons operations and recursion. car (f:r) = f cdr (f:r) = r : -- cons


/ ASP

Pattern 1 (Modus Tollens): Q :- (P1, P2). -Q è -(P1, P2) Pattern 2 (Affirming a Conjunct): P1. -(P1, P2) è -P2 Pattern 3: P2. -P2 è Contradiction

No Gödel FORTRAN DTRAN MTRAN Formula Translation Data Translation Meaning Translation

Other Takeaways ?

1st Gen. PLs

2nd Gen. PLs

3rd Gen. PLs

Relation-based Languages Lisp/Haskell Prolog SQL RDF/Inferencing/SPARQL OO

(e1, e2, e3, e4, e5)

(p1 p2 p3 body)

Lisp:

(car (list 1 2 3 4))

Haskell:

head :: [a] -> a head (x : _ ) = x

1). parent(hank,ben). 2). parent(ben,carl). 3). parent(ben,sue). 4). grandparent(X,Z) :- parent(X,Y) , parent(Y,Z). 5). –grandparent(A, B)

Select * from dept -- General inferencing in the family model EXECUTE SEM_APIS.CREATE_RULEBASE('family_rb_cs345_XXX'); INSERT INTO mdsys.semr_family_rb_cs345_XXX VALUES ('grandparent_rule', '(?x :parentOf ?y) (?y :parentOf ?z)', NULL, '(?x :grandParentOf ?z)', SEM_ALIASES(SEM_ALIAS('','http://www.example.org/family/'))); COMMIT; -- Select all grandfathers and their grandchildren from the family model. -- Use inferencing from both the RDFS and family_rb rulebases. SELECT x grandfather, y grandchild FROM TABLE(SEM_MATCH( '(?x :grandParentOf ?y) (?x rdf:type :Male)', SEM_Models('family_cs345_XXX'), SEM_Rulebases('RDFS','family_rb_cs345_XXX'), SEM_ALIASES(SEM_ALIAS('','http://www.example.org/family/')), null))

programming languages - department of computer …cannata/cs345/new class notes/14 haskell part...

Documents