Dr. Philip Cannata 1 Programming Languages Chapter 19 - Continuations.
Programming Languages - Department of Computer …cannata/cs345/New Class Notes/14 Haskell Part...
-
Upload
duongtuyen -
Category
Documents
-
view
216 -
download
0
Transcript of Programming Languages - Department of Computer …cannata/cs345/New Class Notes/14 Haskell Part...
Dr. Philip Cannata 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
Dr. Philip Cannata 3
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
Dr. Philip Cannata 4
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
Dr. Philip Cannata 5
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
Dr. Philip Cannata 6
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
Dr. Philip Cannata 7
• 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
Dr. Philip Cannata 8
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
Dr. Philip Cannata 9
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
Dr. Philip Cannata 10
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 )
Dr. Philip Cannata 11
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)
Dr. Philip Cannata 12
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
Dr. Philip Cannata 13
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) )
Dr. Philip Cannata 14
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) )
Dr. Philip Cannata 15
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
Dr. Philip Cannata 16
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
Dr. Philip Cannata 17
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.
Dr. Philip Cannata 20
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
Dr. Philip Cannata 21
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>
Dr. Philip Cannata 22
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>
Dr. Philip Cannata 23
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>
Dr. Philip Cannata 24
Main> length [sal | (_, _, _, _, _, sal, _) <- emp] 14 Main>
Main> (\y -> fromIntegral(sum y) / fromIntegral(length y)) ([sal | (_, _, _, _, _, sal, _) <- emp]) 2073.21428571429 Main>
Dr. Philip Cannata 25
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>
Dr. Philip Cannata 26
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>
Dr. Philip Cannata 27
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>
Dr. Philip Cannata 28
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>
Dr. Philip Cannata 29
Main> [(name, sal, dept) | (_, name, _, _, _, sal, dept) <- emp, dept `notElem` [20, 30]] [("KING",5000,10), ("CLARK",2450,10), ("MILLER",1300,10)] Main>
Dr. Philip Cannata 30
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>
Dr. Philip Cannata 32
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]
Dr. Philip Cannata 33
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
Dr. Philip Cannata 34
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
Dr. Philip Cannata 35
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
Dr. Philip Cannata 36
/ 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))