COP4020 Programming Languages

COP4020 Programming Languages

Inductive Data Sets

Inductive sets of data

Recursively Specified data

A brief explanation on LISP

Rules of inference

Deduction tree

Defining sets using grammars

COP4020 Programming Languages Inductive sets of data

We will present the basic programming tools we will need to write:

Interpreters and similar programs that form the heart of a programminglanguage processor.

Because the syntax of a programming language is usually a nested or tree-likestructure,

Recursion will be at the core of our technique


When writing code for a procedure we must know precisely:

What kind of values may occur as arguments to the procedure

What kinds of values are legal for the procedure to return

We will present formal techniques for specifying set of values

Inductive specifications is a powerful method of specifying a setof data values.

We will illustrate this method by using it to describe a certain subset of the natural numbers N = {0, 1, 2, 3, 4,…..}.

Definition: A natural number n is in S if and only if (iff):1.- n = 0

or2.- n – 3 A


COP4020 Programming Languages Recursively Specified data

Let us determine what natural numbers are in S.

We know that 0 S 3 S, since (3 – 3) = 0 and 0 S6 S, since (6 – 3) = 3 and 3 S

Continuing this way, we can conclude that all multiples of 3 are in S

Is 1 in S?We know that 1 0 so first condition is not satisfied.Furthermore, (1 – 3) = -2 which is not a natural number.

1 S2 S same argument we found in former case.4 S 4 S only if 1 S but 1 S, so 4 S

We conclude that S is the set of natural numbers multiple of 3


We can use the definition to write a procedure to decide whether a naturalnumber n is in S.

in-S?: N BoolUsage: (in-S? n) = #t if n is in S, #f otherwise.(define in-S?

(lambda (n)if (zero? n) #t

if (>= (- n 3) 0 )(in-S? ( - n 3) ) #f ) ) ) )

in-S?: N Bool: is a comment, called the contract for this procedure. It meansthat in-S? is intended to be a procedure that takes a naturalnumber and produces a Boolean.

This comments are useful for reading and writing programs.


Here there is an alternative way of writing down the definition of S.

Definition: Define the set S to be the smallest set contained in N and satisfying the following properties: 1.- 0 S, and 2.- if n S, then n + 3 S

A “smallest set” is one that satisfies properties 1 and 2 and that is a subset of anyOther satisfying properties 1 and 2.

It is easy to see that there can be only one such set:

If S1 and S2 both satisfy properties 1 and 2, and both are smallest, thenS1 S2 (since S1 is smallest), and S2 S1 (since S2 is smallest), hence S1 = S2.



Here is another way of writing the definition(shorthand notation):

0 S

n S(n + 3) S

Each entry is call a “rule of inference”, or just a rule.

The horizontal line is read as an “if-then”.The part above the line is called the “hypothesis” or the “antecedent”.The part below the line is called the “conclusion” or the “consequent”

Note: When there are two or more hypotheses listed, they are connected byand implicit “and” (sometimes by a “;” is used to represent “and”).

A rule with no hypotheses is called an “axiom”. We often write an axiom without the horizontal line: 0 S



The rule are interpreted as saying that a natural number n is in S if and only if (iff)the statement “n S” can be derived from the axioms by using the rules ofinference finitely many times.

The interpretation automatically makes S the smallest set that is closed under the rules.

These definitions all say the same thing:

1.- First version is called top-down definition.

2.- second version is called bottom-up definition.

3.- third version is called rules-of-inference definition.



The names CAR and CDR are a historical curiosity; apparently they abbreviate:

“Contents of Address Register” CAR

“Contents of Data Register” CDR

This reflects how the first LISP systems at MIT were implemented in an IBM 709.*M. Gordon, Programming Languages: Theory and implementation.

We could say that Head and Tail are synonymous for CAR and CDR.

CAR apply to a list returns the first element of its list parameter.CDR returns its parameter list minus its first element.

Example: Given the list (A B C D)

(CAR ‘(A B C D)) returns A and (CDR ‘(A B C D)) returns ( B C D)



Exercise in class:

(CAR(CDR(CDR(CAR ‘((A B ( C ) D) E) ) ) ) ) = ?(CAR(CDR(CDR ‘((A B ( C ) D) ) ) ) = ?(CAR(CDR ‘( B ( C ) D) ) ) = ?(CAR ‘( ( C ) D) ) = ?( C )


Definition: (List of integers, top-down): A “Scheme” list is a list of integers ifand only if either:

1.- It is the empty list, or

2.- It is a pair whose CAR is an integer and whose CDR is a list of integers.

We will use Int to denote the set of integers, and List-of-Int to denote the setof a list of integers.


Definition 4 (list of integers bottom-up): The set List-of-Integers is the smallest setof Scheme list satisfying the following two properties:

1.- ( ) List-of-Int, and2.- If n Int and L List-of-Int then (n . L ) List-of-Int

Here we use the infix “.” to denote the result of the CONS operation in Scheme.

CONS: The phrase (n . L ) denotes a Scheme pair whose CAR is n and whose CDR is L. The built-in function CONS returns a list constructed from its two arguments, which will then be the head and tail of the resultant list.

Example: (CONS ‘A ‘B) returns (A B)

(CONS ‘A ‘(B C)) returns (A B C)

A B C



Example: (CONS ‘(A B) ‘(C D)) returns ( (A B) C D )

C D

A B



Definition 5 (List of integers, rules of inference)

( ) List-of-Int

n Int L List-of-Int (n . L ) List-of-Int

Examples:1.- ( ) is a list of integers, because of property 1 of definition 4 or the first rule of definition 5.

2.- (14 . ( )) is a list of integers, because of the second rule of definition 5

14 Int ( ) List-of-Int (14 . ( ) ) List-of-Int

Rules of inference


Example: ( 3 . ( 14 . ( ) ) )

( 3 . ( 14 . ( ) ) ) is a list of integers since 3 is an integer and ( 14 . ( ) ) is a List-of-Int.We can write this as:

3 Int (14 . ( ) ) List-of-Int ( 3 . ( 14 . ( ) ) ) List-of-Int

Example: ( -7 . ( 3 . ( 14 . ( ) ) ) ) is a list of integers because

-7 Int ( 3 . ( 14 . ( ) ) ) List-of-Int ( -7 . ( 3 . ( 14 . ( ) ) ) ) List-of-Int

We can also create a tree-like picture or deduction tree and this is called derivation.

Rules of inference


We will put together the three last examples to show the deduction tree.

14 Int ( ) List-of-Int 3 Int (14 . ( ) ) List-of-Int

-7 Int ( 3 . ( 14 . ( ) ) ) List-of-Int ( -7 . ( 3 . ( 14 . ( ) ) ) ) List-of-Int

Deduction tree


Grammar are typically used to specify sets of strings, but we can use them to definesets of values as well.

For example: We can define a the set of “List-of Int” by the following two rule grammar:

List-of-Int ::= ( )

List-of-Int ::= (Int . List-of-Int)

First rule says that the empty list is in List-of-Int.

The second rule says that if n is in Int and L is in List-of Int, then( n . L ) is in List-of-Int.



A grammar is composed of:

- Nonterminal symbols These are the names of the sets being defined and those sets are called syntacticcategories. We will use capital letters to refer to nonterminals and sets. For example, Expressionis a nonterminal. when we write e Expression it means “e is an expression”.

We can use as well BNF and write expression enclosed in angle brackets to refer to the syntactic category. For example, <expression>.

- Terminal SymbolsThese are the characters in he external representation, in this example:

List-of-Int ::= (Int . List-of-Int)

The terminal symbols are “.”, “(“, and “)”



A grammar is composed of:

- Productions- The rules are called productions.- Each production has a left hand side, which is a nonterminal symbol and a right hand side (RHS), which consists of terminals and nonterminal symbols.- The symbol “::=“ can be read as “is defined as” or “is” or “can be”.

The RHS specifies a method for constructing members of the syntactic categoryIn terms of other syntactic categories and terminal symbols.

The grammar for List-of-Int could be written as:

List-of-Int ::= ( ) | (Int . List-of-Int)

Another shortcut is the Kleene star, expressed by the notation {…}* which means “zero or more instances”

List-of-Int ::= ( {Int}* )



A variant of the star notation is Kleene plus {…}+, which indicates a sequence of one or more instances.

Another variant of the star notation is the separated list notation:

We write { Int}*(c) to denote a sequence of any number of instances of the nonterminal

Int, separated by the non-empty character “c”.

{Int}*( , ) includes the strings

814, 127, 2, 15, 20

{Int}*( ; ) includes the strings

814; 127; 2; 15; 20



If a set is specified by a grammar, a syntactic derivation may be used to show that a given data value is a member of the set.

Derivation starts with a nonterminal corresponding to the set.

At each step, indicated by an arrow ( =>), a nonterminal is replaced by the RHS of the corresponding rule.orwith a known member of its syntactic class was left defined.

Example: (14 . ( ) ) may be formalized with the syntactic derivation:

List-of-Int List-of-Int (Int . Lis-of-Int) => (Int . Lis-of-Int) (14 . List-of-Int) => (Int . ( )) (14 . ( ) ) => (14 . ( ) )

The order in which nonterminals are replaced does not matter.

On derivations


Exercise: Write a derivation from List-of-Int to (-7 . (3 . (14 . ( ) ) ) )

Many symbol manipulation procedures are assigned to operate on lists that containonly symbols and other similar restricted lists. We call these lists s-lists, defined as follows:

Definition (s-list, s-exp)

(S-list ::= ( { S-exp}* )S-exp ::= symbol | S-list

An s-list is a list of s-exp, and an s-exp is either a list or a symbol.

Examples:

(a b c) (an ((( s-list)) (with ( ) lots) ) (( of ) nesting ) ) )

On derivations


The lambda calculus ( l-calculus) is simple language that is often esed to study the theory of programming language

This language consists only of:variable referencesprocedures that take a single argumentprocedure calls

We can defined with the grammar:

l-exp ::= identifier | (l .identifier l-exp | (l.exp l.exp )

Where identifier is any symbol other than lambda (l).

The identifier in the second production is the name of a variable in the body of the lambda expression. This variable is called the bound variable of the expression, because it binds or captures any occurrence of the variable in the body.

Any occurrence of the variable in the body refers to this one.

l-calculus


Example:

(lambda (x) ( + x 5 )

This expression describe a procedure that adds 5 to its argument.

Example: free variable (occurs-free)

(lambda (x) ( + x 5 ) ( - x 7 ) )

The last occurrence of x does not refer to the x that is bound in the lambda expression.

These grammars are said to be context-free because a rule defining a given syntactic category may be applied in any context that makes reference to that syntactic category.

l-calculus

To be continued

Documents

COP4020 Programming Languages