Transcript Programming Languages Haskell Part 2 Dr. Philip Cannata A programming language is a language with a welldefined syntax (lexicon and grammar), type.

Programming Languages
Haskell Part 2
Dr. Philip Cannata
1
A programming language is a language with a welldefined syntax (lexicon and grammar), type system, and
semantics that can be used to implement a set of
algorithms.
Haskell
Dr. Philip Cannata
2
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>
Dr. Philip Cannata
To load the file “10H2.hs” from
the directory in which you
started hugs. Similar for
10Logic and 10Movie
3
Propositional Logic
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
Dr. Philip Cannata
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
4
Truth tables:
P && Q
P || Q
not P
P ==> Q
P <=> Q
P <+> Q
P
Q
False
False
False
P
Q
P || Q
False
False
False
False
True
False
False
True
True
True
False
False
True
False
True
True
True
True
True
True
True
P
False
False
True
True
Q
PQ
False True
True True
False False
True True
P
P
False
True
True
False
P
Dr. Philip Cannata
Q
P && Q
P<=>Q
P
Q
P <+> Q
False
False
True
False
False
False
False
True
False
False
True
True
True
False
False
True
False
True
True
True
True
True
True
False
5
Reasoning with Truth Tables
Proposition (WFF): ((P  Q)((P)Q))
(P  Q)
(P)
False False
False
True
False
False
False True
True
True
True
True
True
False
True
False
True
True
True
True
True
False
True
True
P
Q
If prop is True when all
variables are True:
P, Q
((PQ)((P)Q))
((P)Q)
((PQ)((P)Q))
Some True: prop is Satisfiable*
If they were all True: Valid / Tautology
A Truth
double turnstile
All False: Contradiction
(not satisfiable*)
*Satisfiability was the first known NP-complete problem
Dr. Philip Cannata
6
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
• 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 nonpolynomial. Although it is widely suspected that there are no polynomialtime 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.
Dr. Philip Cannata
7
Truth Table Application
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
Dr. Philip Cannata
8
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]]
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
( \ p -> not p)
( \ p q -> (not p) || (not q) )
( \ p q r -> (not p) || (not q) && (not r) )
Dr. Philip Cannata
9
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
10
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]]
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)
LOGIC> valid3 (\ s w h -> ((s || w) && (s ==> h) && (w ==> h)) ==> h)
True
Is h a Truth?
Dr. Philip Cannata
11
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
12
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
13
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
14
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
15
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))
Dr. Philip Cannata
-- Idempotence
-- Idempotence
-- Idempotence
-- Implication
-- Contrapositive
-- Contrapositive
-- Contrapositive
-- Contrapositive
-- Commutativity
-- Commutativity
-- deMorgan
-- deMorgan
-- Associativity
-- Associativity
-- Distributivity
-- Distributivity
16
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
17
Haskell and SQL
Dr. Philip Cannata
18
Standard Oracle scott/tiger emp dept database
Dr. Philip Cannata
19
Standard Oracle scott/tiger emp dept database in Haskell
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") ]
Dr. Philip Cannata
20
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
21
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
22
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
23
Main> length [sal | (_, _, _, _, _, sal, _) <- emp]
14
Main>
Main> (\y -> fromIntegral(sum y) / fromIntegral(length y)) ([sal | (_, _, _, _, _, sal, _) <- emp])
2073.21428571429
Main>
Dr. Philip Cannata
24
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
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> 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
27
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
28
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
29
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
30
Dr. Philip Cannata
31
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>
-- 2.0
-- Main>
-- 2.0
cfoldr f
cfoldr f
foldr (/) 2 [8,4,2]
(/) 8 ((/) 4 ((/) 2 2))
i [a] = f a i
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
32
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
33
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
pradd x
prmul x
prexp x
prfac x
Primitive Recursive Functions on Natural Numbers
z = y (b (cond ((==) 0) (k z)) (b (s (b (+) (k 1))
z = y (b (cond ((==) 0) (k 0)) (b (s (b (+) (k z))
z = y (b (cond ((==) 0) (k 1)) (b (s (b (*) (k x))
= y (b (cond ((==) 0) (k 1)) (b (s (*)
)
)
)
)
(c
(c
(c
(c
b
b
b
b
pred)))
pred)))
pred)))
pred)))
x
x
z
x
To find Primitive Recursive Functions, try something like the following:
haskell type
checker that
prf
x z = y (b (cond ((==) 0) (k A)) (b (s AAAAAA . . . AAAAAAAAAA ) (c b pred))) A |
rules out bad
combinations
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
Dr. Philip Cannata
be lurking!
34
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
35
/ ASP
Other Takeaways ?
3rd Gen. PLs
2nd Gen. PLs
Pattern 1 (Modus Tollens):
Q :- (P1, P2).
-Q
 -(P1, P2)
Pattern 2 (Affirming a Conjunct):
P1.
-(P1, P2)
 -P2
No Gödel
Lisp/Haskell
(e1, e2, e3, e4, e5)
(p1 p2 p3 body)
Lisp:
(car (list 1 2 3 4))
Haskell:
head :: [a] -> a
head (x : _ ) = x
Dr. Philip Cannata
Pattern 3:
P2.
-P2
 Contradiction
Prolog
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)
1st Gen. PLs
FORTRAN
DTRAN
MTRAN
Formula Translation
Data Translation
Meaning Translation
Relation-based Languages
SQL
RDF/Inferencing /SPARQL
Select * from dept
OO
-- 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))
36