Save this PDF as:

Size: px
Start display at page:

## Transcription

1 FIRST AND FOLLOW Example CS Stephen Watt University of Western Ontario Copyright 2007 Stephen M. Watt

2 FIRST/FOLLOW Main Ideas Look at all the grammar rules. Examine the possibilities of all substrings of RHS symbols being nullable. Nullable RHS prefixes imply adding to FIRST sets. Nullable RHS suffixes imply adding to FOLLOW sets. Nullable RHS interior substrings imply adding to FOLLOW sets.

3 Algorithm for FIRST, FOLLOW, nullable for each symbol X FIRST[X] := { }, FOLLOW[X] := { }, nullable[x] := false for each terminal symbol t FIRST[t] := {t} repeat for each production X Y1 Y2 Yk, if all Yi are nullable then nullable[x] := true if Y1..Yi-1 are nullable then FIRST[X] := FIRST[X] U FIRST[Yi] if Yi+1..Yk are all nullable then FOLLOW[Yi] := FOLLOW[Yi] U FOLLOW[X] if Yi+1..Yj-1 are all nullable then FOLLOW[Yi] := FOLLOW[Yi] U FIRST[Yj] until FIRST, FOLLOW, nullable do not change

4 Example Grammar G = (Σ, V, S, P), where Σ = { a, c, d} V = {X, Y, Z} S = Z P = { Z d, Y ε, X Y, Z X Y Z, Y c, X a }

5 Initialization The initialization loops give FIRST[X] := {} FOLLOW[X] := {} nullable[x] := false FIRST[Y] := {} FOLLOW[Y] := {} nullable[y] := false FIRST[Z] := {} FOLLOW[Z] := {} nullable[z] := false FIRST[a] := {a} FIRST[c] := {c} FIRST[d] := {d}

6 Rules That We Will Iterate for each production X Y1 Y2 Yk, if all Yi are nullable then nullable[x] := true if Y1..Yi-1 are nullable then FIRST[X] := FIRST[X] U FIRST[Yi] if Yi+1..Yk are all nullable then FOLLOW[Yi] := FOLLOW[Yi] U FOLLOW[X] if Yi+1..Yj-1 are all nullable then FOLLOW[Yi] := FOLLOW[Yi] U FIRST[Yj]

7 How to Interpret Sub-sequences Yi..Yk when i < k has k-i+1 elements Yi..Yk when i = k has k-i+1 = 1 elements Yi..Yk when i = k+1 has k-i+1 = 0 elements Otherwise, not defined. (Some applications actually do define i > k+1 by making a subsequence taking the original elements backwards, which can be interesting and powerful.)

8 Specialize for Z d Taking Z d as the production X Y1..Yk, we have X is Z and Y1 is d. There are no other Yi. The first rule if all Yi are nullable then nullable[x] := true is if d is nullable (it isn t) then nullable[z] := true.

9 Specialize for Z d The second rule if Y1..Yi-1 are nullable then FIRST[X] := FIRST[X] U FIRST[Yi] can be instantiated only for i=1. This gives if Y1..Y0 = ε is nullable (which it is) then FIRST[Z] := FIRST[Z] U { d }

10 Specialize for Z d The third rule if Yi+1..Yk are all nullable then FOLLOW[Yi] := FOLLOW[Yi] U FOLLOW[X] can be instantiated only for i=1. This gives if Y2..Y1= ε is nullable then FOLLOW[d] := FOLLOW[d] U FOLLOW[Z] We are not interested in computing FOLLOW of terminals, so we won t bother with this one.

11 Specialize for Z d The fourth rule if Yi+1..Yj-1 are all nullable then FOLLOW[Yi] := FOLLOW[Yi] U FIRST[Yj] has no valid values for i and j. The only Yi is Y1, so we would have to have i=j=1. But the subsequence Y2..Y0 does not exist.

12 Rules for X a, Y c, Z d The same logic applies for all of X a, Y c, Z d. This gives: FIRST[X] := FIRST[Z] U {a} FIRST[Y] := FIRST[Z] U {c} FIRST[Z] := FIRST[Z] U {d} There are also some rules to compute FOLLOW of terminals but we don t care about those.

13 Specialize for X Y Taking X Y as the production X Y1..Yk, we have X is X, Y1 is Y, and there are no other Yi. The first rule if all Yi are nullable then nullable[x] := true is if Y is nullable then nullable[x] := true.

14 Specialize for X Y The second rule if Y1..Yi-1 are nullable then FIRST[X] := FIRST[X] U FIRST[Yi] can be instantiated only for i=1. It becomes if Y1..Y0 is nullable then FIRST[X] := FIRST[X] U FIRST[Y] The condition is always satisfied as Y1..Y0 is empty. FIRST[X] := FIRST[X] U FIRST[Y]

15 Specialize for X Y The third rule if Yi+1..Yk are all nullable then FOLLOW[Yi] := FOLLOW[Yi] U FOLLOW[X] can be instantiated only for i=1. It becomes if Y2..Y1 is nullable then FOLLOW[Y] := FOLLOW[Y] U FOLLOW[X]. The test is true (the empty string is nullable).

16 Specialize for X Y The fourth rule if Yi+1..Yj-1 are all nullable then FOLLOW[Yi] := FOLLOW[Yi] U FIRST[Yj] has no instantiation. The only Y is Y1, so we would have to have i=j=1. But the subsequence Y2..Y0 is not defined.

17 Rules for X Y All the rules together for X Y are if Yi is nullable then, nullable[z] := true. FIRST[X] := FIRST[X] U FIRST[Y] FOLLOW[Y] := FOLLOW[Y] U FOLLOW[X].

18 Specialize for Y ε Taking Y ε as the production X Y1..Yk, we have X is Y, and there are no Yi. The first rule if all Yi are nullable then nullable[x] := true is if all zero of the Y s are nullable (true) then nullable[y] := true.

19 Specialize for Y ε The second rule if Y1..Yi-1 are nullable then FIRST[X] := FIRST[X] U FIRST[Yi] cannot be instantiated as there are no Yi.

20 Specialize for Y ε The third rule if Yi+1..Yk are all nullable then FOLLOW[Yi] := FOLLOW[Yi] U FOLLOW[X] cannot be instantiated as there are no Yi.

21 Specialize for Y ε The fourth rule if Yi+1..Yj-1 are all nullable then FOLLOW[Yi] := FOLLOW[Yi] U FIRST[Yj] has no instantiation as there are no Yi.

22 Rules for Y ε All the rules together for Y ε are nullable[y] := true.

23 Specialize for Z X Y Z Taking Z X Y Z as the production X Y1..Yk, we have X is Z, Y1 is X, Y2 is Y, Y3 is Z. The first rule if all Yi are nullable then nullable[x] := true is if X, Y, Z are all nullable then nullable[z] := true.

24 Specialize for Z X Y Z The second rule if Y1..Yi-1 are nullable then FIRST[X] := FIRST[X] U FIRST[Yi] can be instantiated for i=1,2 or 3. These give if ε is nullable (which it is) then FIRST[Z] := FIRST[Z] union FIRST[X] if X is nullable then FIRST[Z] := FIRST[Z] union FIRST[Y] if XY is nullable then ou FIRST[Z] := FIRST[Z] union FIRST[Z]

25 Specialize for Z X Y Z The third rule if Yi+1..Yk are all nullable then FOLLOW[Yi] := FOLLOW[Yi] U FOLLOW[X] can be instantiated for i=1,2,3. These give if YZ is nullable then FOLLOW[X] := FOLLOW[X] union FOLLOW[Z] if Zisnullable then FOLLOW[Y] := FOLLOW[Y] union FOLLOW[Z] if ε is nullable then FOLLOW[Z] := FOLLOW[Z] union FOLLOW[Z]

26 Specialize for Z XYZ The fourth rule if Yi+1..Yj-1 are all nullable then FOLLOW[Yi] := FOLLOW[Yi] U FIRST[Yj] has instantiations for (i,j) = (1,2), (1,3), (2,3). if ε is nullable then FOLLOW[X] := FOLLOW[X] union FIRST[Y] if Y is nullable then FOLLOW[X] O := FOLLOW[X] O union FIRST[Z] if ε is nullable then FOLLOW[Y] := FOLLOW[Y] union FIRST[Z]

27 Rules for Z X Y Z if X, Y, Z all nullable then nullable[z] := true. if X is nullable then FIRST[Z] := FIRST[Z] union FIRST[Y] if XY is nullable then FIRST[Z] := FIRST[Z] union FIRST[Z] if YZ is nullable then FOLLOW[X] := FOLLOW[X] union FOLLOW[Z] if Z is nullable then FOLLOW[Y] := FOLLOW[Y] union FOLLOW[Z] if Yi is nullable then FOLLOW[X] := FOLLOW[X] union FIRST[Z] FIRST[Z] := FIRST[Z] union FIRST[X] FOLLOW[X] := FOLLOW[X] union FIRST[Y] FOLLOW[Y] := FOLLOW[Y] union FIRST[Z] FOLLOW[Z] := FOLLOW[Z] union FOLLOW[Z]

28 All the Rules We Need to Iterate nullable[x] := true, if Y is nullable nullable[y] := true. nullable[z] := true, if X, Y, Z all nullable FIRST[X] := FIRST[Z] U {a} FIRST[Y] := FIRST[Z] U {c} FIRST[Z] := FIRST[Z] U {d} FIRST[X] := FIRST[X] U FIRST[Y] FIRST[Z] := FIRST[Z] U FIRST[X] FIRST[Z] := FIRST[Z] U FIRST[Y], if X is nullable FIRST[Z] := FIRST[Z] U FIRST[Z], if XY is nullable // Trivial can drop it FOLLOW[X] := FOLLOW[X] U FIRST[Y] FOLLOW[X] := FOLLOW[X] U FIRST[Z], if Y is nullable FOLLOW[Y] := FOLLOW[Y] U FIRST[Z] FOLLOW[X] := FOLLOW[X] U FOLLOW[Z], if YZ is nullable FOLLOW[Y] := FOLLOW[Y] U FOLLOW[Z], if Z is nullable FOLLOW[Y] := FOLLOW[Y] U FOLLOW[X] FOLLOW[Z] := FOLLOW[Z] U FOLLOW[Z]

29 Now Can Iterate to Fill in the Table Z d Y ε X Y Z X Y Z Y c X a X Y Z nullable FIRST FOLLOW false false false nullable FIRST FOLLOW X false a c d Y true c d Z false d nullable FIRST FOLLOW X true a c a c d Y true c a c d Z false a c d

### FIRST and FOLLOW sets a necessary preliminary to constructing the LL(1) parsing table

FIRST and FOLLOW sets a necessary preliminary to constructing the LL(1) parsing table Remember: A predictive parser can only be built for an LL(1) grammar. A grammar is not LL(1) if it is: 1. Left recursive,

### CS 4120 Introduction to Compilers

CS 4120 Introduction to Compilers Andrew Myers Cornell University Lecture 5: Top-down parsing 5 Feb 2016 Outline More on writing CFGs Top-down parsing LL(1) grammars Transforming a grammar into LL form

Top-down Parsing Recursive Descent & LL(1) Copyright 2010, Keith D. Cooper & Linda Torczon, all rights reserved. Roadmap (Where are we?) We set out to study parsing Specifying syntax Context-free grammars

### CS 341 Homework 9 Languages That Are and Are Not Regular

CS 341 Homework 9 Languages That Are and Are Not Regular 1. Show that the following are not regular. (a) L = {ww R : w {a, b}*} (b) L = {ww : w {a, b}*} (c) L = {ww' : w {a, b}*}, where w' stands for w

### Logic in Computer Science: Logic Gates

Logic in Computer Science: Logic Gates Lila Kari The University of Western Ontario Logic in Computer Science: Logic Gates CS2209, Applied Logic for Computer Science 1 / 49 Logic and bit operations Computers

### Syntactic Analysis and Context-Free Grammars

Syntactic Analysis and Context-Free Grammars CSCI 3136 Principles of Programming Languages Faculty of Computer Science Dalhousie University Winter 2012 Reading: Chapter 2 Motivation Source program (character

### Automata and Formal Languages

Automata and Formal Languages Winter 2009-2010 Yacov Hel-Or 1 What this course is all about This course is about mathematical models of computation We ll study different machine models (finite automata,

### Bottom-Up Parsing. An Introductory Example

Bottom-Up Parsing Bottom-up parsing is more general than top-down parsing Just as efficient Builds on ideas in top-down parsing Bottom-up is the preferred method in practice Reading: Section 4.5 An Introductory

### University of Toronto Department of Electrical and Computer Engineering. Midterm Examination. CSC467 Compilers and Interpreters Fall Semester, 2005

University of Toronto Department of Electrical and Computer Engineering Midterm Examination CSC467 Compilers and Interpreters Fall Semester, 2005 Time and date: TBA Location: TBA Print your name and ID

### Our recursive descent parser encodes state. information in its run-time stack, or call. Using recursive procedure calls to implement a

Non-recursive predictive parsing Observation: Our recursive descent parser encodes state information in its run-time stack, or call stack. Using recursive procedure calls to implement a stack abstraction

### CS103B Handout 17 Winter 2007 February 26, 2007 Languages and Regular Expressions

CS103B Handout 17 Winter 2007 February 26, 2007 Languages and Regular Expressions Theory of Formal Languages In the English language, we distinguish between three different identities: letter, word, sentence.

### Optimizations. Optimization Safety. Optimization Safety. Control Flow Graphs. Code transformations to improve program

Optimizations Code transformations to improve program Mainly: improve execution time Also: reduce program size Control low Graphs Can be done at high level or low level E.g., constant folding Optimizations

### Positional Numbering System

APPENDIX B Positional Numbering System A positional numbering system uses a set of symbols. The value that each symbol represents, however, depends on its face value and its place value, the value associated

### CS143 Handout 08 Summer 2008 July 02, 2007 Bottom-Up Parsing

CS143 Handout 08 Summer 2008 July 02, 2007 Bottom-Up Parsing Handout written by Maggie Johnson and revised by Julie Zelenski. Bottom-up parsing As the name suggests, bottom-up parsing works in the opposite

### Fast string matching

Fast string matching This exposition is based on earlier versions of this lecture and the following sources, which are all recommended reading: Shift-And/Shift-Or 1. Flexible Pattern Matching in Strings,

### Please note that there is more than one way to answer most of these questions. The following only represents a sample solution.

HOMEWORK THREE SOLUTION CSE 355 DUE: 10 MARCH 2011 Please note that there is more than one way to answer most of these questions. The following only represents a sample solution. (1) 2.4 and 2.5 (b),(c),(e),(f):

### Python Loops and String Manipulation

WEEK TWO Python Loops and String Manipulation Last week, we showed you some basic Python programming and gave you some intriguing problems to solve. But it is hard to do anything really exciting until

### Definition: String concatenation. Definition: String. Definition: Language (cont.) Definition: Language

CMSC 330: Organization of Programming Languages Regular Expressions and Finite Automata Introduction That s it for the basics of Ruby If you need other material for your project, come to office hours or

### Database Design and Normal Forms

Database Design and Normal Forms Database Design coming up with a good schema is very important How do we characterize the goodness of a schema? If two or more alternative schemas are available how do

### Theory of Computation

Theory of Computation For Computer Science & Information Technology By www.thegateacademy.com Syllabus Syllabus for Theory of Computation Regular Expressions and Finite Automata, Context-Free Grammar s

### Turing Machines, Part I

Turing Machines, Part I Languages The \$64,000 Question What is a language? What is a class of languages? Computer Science Theory 2 1 Now our picture looks like Context Free Languages Deterministic Context

### Conditional and Looping Construct

Chapter 3 Conditional and Looping Construct After studying this lesson, students will be able to: Understand the concept and usage of selection and iteration statements. Know various types of loops available

### Foundations of Computing Discrete Mathematics Solutions to exercises for week 2

Foundations of Computing Discrete Mathematics Solutions to exercises for week 2 Agata Murawska (agmu@itu.dk) September 16, 2013 Note. The solutions presented here are usually one of many possiblities.

### Syntaktická analýza. Ján Šturc. Zima 208

Syntaktická analýza Ján Šturc Zima 208 Position of a Parser in the Compiler Model 2 The parser The task of the parser is to check syntax The syntax-directed translation stage in the compiler s front-end

### MATH 55: HOMEWORK #2 SOLUTIONS

MATH 55: HOMEWORK # SOLUTIONS ERIC PETERSON * 1. SECTION 1.5: NESTED QUANTIFIERS 1.1. Problem 1.5.8. Determine the truth value of each of these statements if the domain of each variable consists of all

### Recall that the gradient of a differentiable scalar field ϕ on an open set D in R n is given by the formula:

Chapter 7 Div, grad, and curl 7.1 The operator and the gradient: Recall that the gradient of a differentiable scalar field ϕ on an open set D in R n is given by the formula: ( ϕ ϕ =, ϕ,..., ϕ. (7.1 x 1

### Automata Theory and Languages

Automata Theory and Languages SITE : http://www.info.univ-tours.fr/ mirian/ Automata Theory, Languages and Computation - Mírian Halfeld-Ferrari p. 1/1 Introduction to Automata Theory Automata theory :

### Automata Theory. Şubat 2006 Tuğrul Yılmaz Ankara Üniversitesi

Automata Theory Automata theory is the study of abstract computing devices. A. M. Turing studied an abstract machine that had all the capabilities of today s computers. Turing s goal was to describe the

### CSE 308. Coding Conventions. Reference

CSE 308 Coding Conventions Reference Java Coding Conventions googlestyleguide.googlecode.com/svn/trunk/javaguide.html Java Naming Conventions www.ibm.com/developerworks/library/ws-tipnamingconv.html 2

### Chapter 7. Arrays and Collections. Instructor s Manual Table of Contents. At a Glance. Chapter Overview. Chapter Objectives.

C# Programming: From Problem Analysis to Program Design, 2nd ed. 7-1 Chapter 7 Arrays and Collections At a Glance Instructor s Manual Table of Contents Chapter Overview Chapter Objectives Instructor Notes

### Binary numbers. Try converting 3, 22, and 71 to binary; try converting 10101, 1100, and to decimal. Satisfaction problem

Binary numbers We are used to expressing numbers in base 10, but binary numbers are base 2. Here are some simple examples of decimal numbers and their binary equivalents. Decimal Binary 0 00 1 01 2 10

### Relational Database Design

Relational Database Design Jan Chomicki University at Buffalo Jan Chomicki () Relational database design 1 / 16 Outline 1 Functional dependencies 2 Normal forms 3 Multivalued dependencies Jan Chomicki

### The current topic: Scheme. Announcements. Numeric operators. Review: car, cdr, and cons

The current topic: Scheme! Introduction! Object-oriented programming: Python Functional programming: Scheme! Introduction Next up: Numeric operators, REPL, quotes, functions, conditionals Types and values

### Let s s explore what you know!

Let s s explore what you know! Draw a microscopic representation for the reactants and the products in each of these chemical equations. Use the following symbolism to complete the task: W = X = Y = Z

Test Case Generation for Ultimately Periodic Paths Joint work with Saddek Bensalem Hongyang Qu Stavros Tripakis Lenore Zuck Accepted to HVC 2007 How to find the condition to execute a path? (weakest precondition

### Induction. Mathematical Induction. Induction. Induction. Induction. Induction. 29 Sept 2015

Mathematical If we have a propositional function P(n), and we want to prove that P(n) is true for any natural number n, we do the following: Show that P(0) is true. (basis step) We could also start at

### 1. Prove that the empty set is a subset of every set.

1. Prove that the empty set is a subset of every set. Basic Topology Written by Men-Gen Tsai email: b89902089@ntu.edu.tw Proof: For any element x of the empty set, x is also an element of every set since

### A simple algorithm with no simple verication

A simple algorithm with no simple verication Laszlo Csirmaz Central European University Abstract The correctness of a simple sorting algorithm is resented, which algorithm is \evidently wrong" at the rst

### Groups, Rings, and Fields. I. Sets Let S be a set. The Cartesian product S S is the set of ordered pairs of elements of S, S S = {(x, y) x, y S}.

Groups, Rings, and Fields I. Sets Let S be a set. The Cartesian product S S is the set of ordered pairs of elements of S, A binary operation φ is a function, S S = {(x, y) x, y S}. φ : S S S. A binary

### Negative Integer Exponents

7.7 Negative Integer Exponents 7.7 OBJECTIVES. Define the zero exponent 2. Use the definition of a negative exponent to simplify an expression 3. Use the properties of exponents to simplify expressions

### Functional Dependencies and Finding a Minimal Cover

Functional Dependencies and Finding a Minimal Cover Robert Soulé 1 Normalization An anomaly occurs in a database when you can update, insert, or delete data, and get undesired side-effects. These side

### Chapter 3: Control Structures

Chapter 3: Control Structures 1. Higher order organization of Python instructions In the previous chapters, we have introduced the different types of variables known by Python, as well as the operators

### Mathematical induction & Recursion

CS 441 Discrete Mathematics for CS Lecture 15 Mathematical induction & Recursion Milos Hauskrecht milos@cs.pitt.edu 5329 Sennott Square Proofs Basic proof methods: Direct, Indirect, Contradiction, By Cases,

### (Refer Slide Time 1.50)

Discrete Mathematical Structures Dr. Kamala Krithivasan Department of Computer Science and Engineering Indian Institute of Technology, Madras Module -2 Lecture #11 Induction Today we shall consider proof

### PROBLEM SET. Practice Problems for Exam #2. Math 2350, Fall Nov. 7, 2004 Corrected Nov. 10 ANSWERS

PROBLEM SET Practice Problems for Exam #2 Math 2350, Fall 2004 Nov. 7, 2004 Corrected Nov. 10 ANSWERS i Problem 1. Consider the function f(x, y) = xy 2 sin(x 2 y). Find the partial derivatives f x, f y,

### UNIT - I LESSON - 1 The Solution of Numerical Algebraic and Transcendental Equations

UNIT - I LESSON - 1 The Solution of Numerical Algebraic and Transcendental Equations Contents: 1.0 Aims and Objectives 1.1 Introduction 1.2 Bisection Method 1.2.1 Definition 1.2.2 Computation of real root

### Unix Shell Scripts. Contents. 1 Introduction. Norman Matloff. July 30, 2008. 1 Introduction 1. 2 Invoking Shell Scripts 2

Unix Shell Scripts Norman Matloff July 30, 2008 Contents 1 Introduction 1 2 Invoking Shell Scripts 2 2.1 Direct Interpretation....................................... 2 2.2 Indirect Interpretation......................................

### ALGORITHMS -CSE202-FALL 1998 Dynamic Programming and Greedy Method Homework 2 Sample Solutions

ALGORITHMS -CSE202-FALL 1998 Dynamic Programming and Greedy Method Homework 2 Sample Solutions Problem 3-9 in Skiena: Consider the following data compression technique. We have a table of m text strings,

### Discrete Mathematics, Chapter 5: Induction and Recursion

Discrete Mathematics, Chapter 5: Induction and Recursion Richard Mayr University of Edinburgh, UK Richard Mayr (University of Edinburgh, UK) Discrete Mathematics. Chapter 5 1 / 20 Outline 1 Well-founded

### CSE8393 Introduction to Bioinformatics Lecture 3: More problems, Global Alignment. DNA sequencing

SE8393 Introduction to Bioinformatics Lecture 3: More problems, Global lignment DN sequencing Recall that in biological experiments only relatively short segments of the DN can be investigated. To investigate

### 15. Functions and Lists. Example 2: Sorting a List of Numbers. Example 1: Computing the Diameter of a Cloud of Points

15. Functions and Lists Example 1: Computing the Diameter of a Cloud of Points Topics: Subscripting Map Searching a list Example 1: Clouds of points Example 2: Selection Sort 500 Points. Which two are

### vector calculus 2 Learning outcomes

29 ontents vector calculus 2 1. Line integrals involving vectors 2. Surface and volume integrals 3. Integral vector theorems Learning outcomes In this Workbook you will learn how to integrate functions

### Algorithm & Flowchart. Credit: Mr Ainullotfi

Algorithm & Flowchart Credit: Mr Ainullotfi Common Flowchart Symbols Start/Stop Process Input/Output Refers to a separate flowchart Decision Connector Off-page Connector Comments Preparation (for loops

### Operation Stack [bottom top] Instantiate [ ] Push 1 [ 1 ] Push 2 [ 1, 2 ] Push 3 [ 1, 2, 3 ] Pop [ 1, 2 ] Push 4 [ 1, 2, 4 ] Pop [ 1, 2 ]

Debugging Ask a random sample of students enrolled in a computer science course what their favorite aspect of programming is, and very few will respond with debugging. Debugging programs in computer science

### STATUS REPORT ON MAUDE-NPA TOOL

STATUS REPORT ON MAUDE-NPA TOOL Catherine Meadows Santiago Escobar Jose Meseguer September 28, 2006 1 GOAL Extend standard free algebra model of crypto protocol analysis to deal with algebraic properties

### Automata and Computability. Solutions to Exercises

Automata and Computability Solutions to Exercises Fall 25 Alexis Maciel Department of Computer Science Clarkson University Copyright c 25 Alexis Maciel ii Contents Preface vii Introduction 2 Finite Automata

### 2110711 THEORY of COMPUTATION

2110711 THEORY of COMPUTATION ATHASIT SURARERKS ELITE Athasit Surarerks ELITE Engineering Laboratory in Theoretical Enumerable System Computer Engineering, Faculty of Engineering Chulalongkorn University

### 52. The Del Operator: Divergence and Curl

52. The Del Operator: Divergence and Curl Let F(x, y, z) = M(x, y, z), N(x, y, z), P(x, y, z) be a vector field in R 3. The del operator is represented by the symbol, and is written = x, y, z, or = x,

### Reminder: Complexity (1) Parallel Complexity Theory. Reminder: Complexity (2) Complexity-new

Reminder: Complexity (1) Parallel Complexity Theory Lecture 6 Number of steps or memory units required to compute some result In terms of input size Using a single processor O(1) says that regardless of

### Reminder: Complexity (1) Parallel Complexity Theory. Reminder: Complexity (2) Complexity-new GAP (2) Graph Accessibility Problem (GAP) (1)

Reminder: Complexity (1) Parallel Complexity Theory Lecture 6 Number of steps or memory units required to compute some result In terms of input size Using a single processor O(1) says that regardless of

### Repetition and Loops. Additional Python constructs that allow us to effect the (1) order and (2) number of times that program statements are executed.

New Topic Repetition and Loops Additional Python constructs that allow us to effect the (1) order and (2) number of times that program statements are executed. These constructs are the 1. while loop and

### HOMEWORK 4 SOLUTIONS. All questions are from Vector Calculus, by Marsden and Tromba

HOMEWORK SOLUTIONS All questions are from Vector Calculus, by Marsden and Tromba Question :..6 Let w = f(x, y) be a function of two variables, and let x = u + v, y = u v. Show that Solution. By the chain

### Lecture 2: Regular Languages [Fa 14]

Caveat lector: This is the first edition of this lecture note. Please send bug reports and suggestions to jeffe@illinois.edu. But the Lord came down to see the city and the tower the people were building.

### Formal Languages and Automata Theory - Regular Expressions and Finite Automata -

Formal Languages and Automata Theory - Regular Expressions and Finite Automata - Samarjit Chakraborty Computer Engineering and Networks Laboratory Swiss Federal Institute of Technology (ETH) Zürich March

### A Systematic Approach to Factoring

A Systematic Approach to Factoring Step 1 Count the number of terms. (Remember****Knowing the number of terms will allow you to eliminate unnecessary tools.) Step 2 Is there a greatest common factor? Tool

### Sect 6.1 - Greatest Common Factor and Factoring by Grouping

Sect 6.1 - Greatest Common Factor and Factoring by Grouping Our goal in this chapter is to solve non-linear equations by breaking them down into a series of linear equations that we can solve. To do this,

### SOLUTION Trial Test Grammar & Parsing Deficiency Course for the Master in Software Technology Programme Utrecht University

SOLUTION Trial Test Grammar & Parsing Deficiency Course for the Master in Software Technology Programme Utrecht University Year 2004/2005 1. (a) LM is a language that consists of sentences of L continued

### Top-Down Design Example

Top-Down Design Example CS 1025 Computer Science Fundamentals I Stephen M. Watt University of Western Ontario Example of Top-Down Design Write a program to verify that a 9 x 9 grid is a Sudoku solution.

### Practice Problems for Midterm 2

Practice Problems for Midterm () For each of the following, find and sketch the domain, find the range (unless otherwise indicated), and evaluate the function at the given point P : (a) f(x, y) = + 4 y,

### + addition - subtraction and unary minus * multiplication / division mod modulo

Chapter 4 Basic types We examine in this chapter the Caml basic types. 4.1 Numbers Caml Light provides two numeric types: integers (type int) and floating-point numbers (type float). Integers are limited

### Regular Expressions and Automata using Haskell

Regular Expressions and Automata using Haskell Simon Thompson Computing Laboratory University of Kent at Canterbury January 2000 Contents 1 Introduction 2 2 Regular Expressions 2 3 Matching regular expressions

### Visual Logic Instructions and Assignments

Visual Logic Instructions and Assignments Visual Logic can be installed from the CD that accompanies our textbook. It is a nifty tool for creating program flowcharts, but that is only half of the story.

### Normalisation. Why normalise? To improve (simplify) database design in order to. Avoid update problems Avoid redundancy Simplify update operations

Normalisation Why normalise? To improve (simplify) database design in order to Avoid update problems Avoid redundancy Simplify update operations 1 Example ( the practical difference between a first normal

### Factoring - Greatest Common Factor

6.1 Factoring - Greatest Common Factor Objective: Find the greatest common factor of a polynomial and factor it out of the expression. The opposite of multiplying polynomials together is factoring polynomials.

### Phrase-Based Translation Models

Phrase-Based Translation Models Michael Collins April 10, 2013 1 Introduction In previous lectures we ve seen IBM translation models 1 and 2. In this note we will describe phrasebased translation models.

### Relational Database Design

Relational Database Design To generate a set of relation schemas that allows - to store information without unnecessary redundancy - to retrieve desired information easily Approach - design schema in appropriate

### Proofs by induction, Alphabet, Strings [1] Proofs by Induction

Proofs by induction, Alphabet, Strings [1] Proofs by Induction Proposition: If f(0) = 0 and f(n + 1) = f(n) + n + 1 then, for all n N, we have f(n) = n(n + 1)/2 Let S(n) be f(n) = n(n + 1)/2 We prove S(0)

### MA261-A Calculus III 2006 Fall Homework 8 Solutions Due 10/30/2006 8:00AM

MA61-A Calculus III 006 Fall Homework Solutions Due 10/0/006 :00AM 116 # Let f (x; y) = y ln x (a) Find the gradient of f (b) Evaluate the gradient at the oint P (1; ) (c) Find the rate of change of f

### ASSIGNMENT ONE SOLUTIONS MATH 4805 / COMP 4805 / MATH 5605

ASSIGNMENT ONE SOLUTIONS MATH 4805 / COMP 4805 / MATH 5605 (1) (a) (0 + 1) 010 (finite automata below). (b) First observe that the following regular expression generates the binary strings with an even

### CSI 333 Lecture 2 Introduction to C: Part I 2 1 / 16

CSI 333 Lecture 2 Introduction to C: Part I 2 1 / 16 Basics of C Remark: Skim Chapters 1 through 6 of Deitel & Deitel. You will notice the following: C is (more or less) a subset of Java. (So, you are

### TECHNOLOGY Computer Programming II Grade: 9-12 Standard 2: Technology and Society Interaction

Standard 2: Technology and Society Interaction Technology and Ethics Analyze legal technology issues and formulate solutions and strategies that foster responsible technology usage. 1. Practice responsible

### Chapter 1. Logic and Proof

Chapter 1. Logic and Proof 1.1 Remark: A little over 100 years ago, it was found that some mathematical proofs contained paradoxes, and these paradoxes could be used to prove statements that were known

### MACM 101 Discrete Mathematics I

MACM 101 Discrete Mathematics I Exercises on Combinatorics, Probability, Languages and Integers. Due: Tuesday, November 2th (at the beginning of the class) Reminder: the work you submit must be your own.

### Quick Look at Using Bison Top-Down Parsers

Syntax Analysis Part II Quick Look at Using Bison Top-Down Parsers EECS 483 Lecture 5 University of Michigan Wednesday, September 20, 2006 Reading/Announcements Reading: Section 4.4 (top-down parsing)

### Applies to Version 6 Release 5 X12.6 Application Control Structure

Applies to Version 6 Release 5 X12.6 Application Control Structure ASC X12C/2012-xx Copyright 2012, Data Interchange Standards Association on behalf of ASC X12. Format 2012 Washington Publishing Company.

LZ77 The original LZ77 algorithm works as follows: A phrase T j starting at a position i is encoded as a triple of the form distance, length, symbol. A triple d, l, s means that: T j = T [i...i + l] =

### Elementary Number Theory and Methods of Proof. CSE 215, Foundations of Computer Science Stony Brook University http://www.cs.stonybrook.

Elementary Number Theory and Methods of Proof CSE 215, Foundations of Computer Science Stony Brook University http://www.cs.stonybrook.edu/~cse215 1 Number theory Properties: 2 Properties of integers (whole

### Homework Three Solution CSE 355

Homework Three Solution CSE 355 Due: 06 March 2012 Please note that there is more than one way to answer most of these questions. The following only represents a sample solution. Problem 1: Linz 4.1.13

### Efficient parallel string comparison

Efficient parallel string comparison Peter Krusche and Alexander Tiskin Department of Computer Science ParCo 2007 Outline 1 Introduction Bulk-Synchronous Parallelism String comparison 2 Sequential LCS

### Database Design and Normalization

Database Design and Normalization CPS352: Database Systems Simon Miner Gordon College Last Revised: 9/27/12 Agenda Check-in Functional Dependencies (continued) Design Project E-R Diagram Presentations

### RDB-MINER: A SQL-Based Algorithm for Mining True Relational Databases

998 JOURNAL OF SOFTWARE, VOL. 5, NO. 9, SEPTEMBER 2010 RDB-MINER: A SQL-Based Algorithm for Mining True Relational Databases Abdallah Alashqur Faculty of Information Technology Applied Science University

### Introduction to Problem Solving and Programming in Python.

Introduction to Problem Solving and Programming in Python http://cis-linux1.temple.edu/~tuf80213/courses/temple/cis1051/ Overview Repeating Types of loops While loops For loop Nested loops 2 Loops A loops

### The Halting Problem is Undecidable

185 Corollary G = { M, w w L(M) } is not Turing-recognizable. Proof. = ERR, where ERR is the easy to decide language: ERR = { x { 0, 1 }* x does not have a prefix that is a valid code for a Turing machine

### 5 2x 3y= 9 4x+7y=56. 3x+4y=16 4x 7y= x

Systems of Inequalities 1 Given system of inequalities of the form Ax b Goals: determine if system has an integer solution enumerate all integer solutions 2 bounds for x: (2) and (3) Upper bounds for x:

### Questions and Answers in Computer Science. By Yonas Tesfazghi Weldeselassie http://www.ictp.trieste.it/ weldesel

Questions and Answers in Computer Science By Yonas Tesfazghi Weldeselassie http://www.ictp.trieste.it/ weldesel The Questions in this material are collected from Computer Science Subject Graduate Record