# 15 150: Principles of Functional Programming Some Notes on Regular Expression Matching

Save this PDF as:

Size: px
Start display at page:

Download "15 150: Principles of Functional Programming Some Notes on Regular Expression Matching"

## Transcription

1 15 150: Principles of Functional Programming Some Notes on Regular Expression Matching Michael Erdmann Spring Introduction Regular expression matching is a very useful technique for describing commonly-occurring patterns in strings. For example, the Unix shell (and most other command processors) provides a mechanism (called globbing ) for describing a collection of files by patterns such as *.sml or hw[1-3].sml. The emacs text editor provides a richer, but substantially similar, pattern language for its regexp search mechanism. In this note we will describe a simple algorithm for regular expression matching that illustrates a number of important programming concepts. The patterns describable by regular expressions are built up from the following four constructs: 1. Singleton: matching a specific character. 2. Alternation: choice between two patterns. 3. Concatenation: succession of patterns. 4. Iteration: indefinite repetition of patterns. Notably, regular expressions provide no concept of nesting of one pattern inside another. For this we would require a richer formalism, such as that provided by context-free languages. 2 Languages To make precise the informal ideas outlined above, we introduce the concept of a formal language. First, we fix an alphabet Σ, which is any countable set of letters. ThesetΣ is the set of finite-length strings over the alphabet Σ. The empty string is written ɛ, and string concatenation is indicated by juxtaposition. A language L is any subset of Σ that is, any set of finite-length strings over Σ. In practice Σ is SML type char, andσ is the SML type string. We will use SML notation for operations on strings. Observe that the empty string ɛ is represented by the value "" of type string in SML. Modified from a draft by Robert Harper. 1

2 3 Regular Expressions Regular expressions are a notation system for languages. The set of regular expressions over an alphabet Σ is given by the following inductive/recursive definition: 1. If a Σ, then a is a regular expression is a regular expression is a regular expression. 4. If r 1 and r 2 are regular expressions, so is r 1 r If r 1 and r 2 are regular expressions, so is r 1 + r If r is a regular expression, then so is r. The language L(r) of a regular expression r is defined as follows: L(a) = { a } L(1) = { ɛ } L(0) = {} L(r 1 r 2 ) = {s 1 s 2 s 1 L(r 1 ) and s 2 L(r 2 )} L(r 1 + r 2 ) = {s s L(r 1 ) or s L(r 2 )} L(r ) = {s 1...s n s i L(r) for 1 i n, with n 0} By convention, s 1...s n stands for the empty string ɛ if n =0. We say that a string s matches a regular expression r iff s L(r). Thus s never matches 0; s matches 1 iff s = ɛ; s matches a iff s = a; s matches r 1 + r 2 iff it matches either r 1 or r 2 ; s matches r 1 r 2 iff s = s 1 s 2, where s 1 matches r 1 and s 2 matches r 2 ; s matches r iff either s = ɛ, ors = s 1 s 2 where s 1 matches r and s 2 matches r. (The following precedence rules apply when needed: star precedes times precedes plus.) Some simple examples over the alphabet Σ = {a, b}. L(aa) = singleton set containing only aa L((a + b) ) = set of all strings over Σ L((a + b) aa(a + b) ) = set of strings with two consecutive a s L((a + 1)(b + ba) ) = set of strings over Σ without two consecutive a s 2

3 4 A Matching Algorithm We are to define an SML function accept with type regexp -> string -> bool such that accept r s evaluates to true iff s matches r, and evaluates to false otherwise. First we require a representation of regular expressions in SML: datatype regexp = Char of char One Zero Times of regexp * regexp Plus of regexp * regexp Star of regexp The correspondence to the definition of regular expressions should be clear. We will implement the matcher using continuation-passing. We will define an auxiliary function match of type match : regexp -> char list -> (char list -> bool) -> bool which takes a regular expression, a character list, and a continuation, and yields a Boolean value. Informally, the continuation determines how to proceed once an initial segment of the given character list has been determined to match the given regular expression the remaining input is passed to the continuation to determine the final outcome. In order to ensure that the matcher succeeds (yields true) whenever possible, we must be sure to consider all ways in which an initial segment of the input character list matches the given regular expression in such a way that the remaining unmatched input causes the continuation to succeed. Only if there is no way to do so may we yield false. This informal specification may be made precise as follows: (Here we are treating the arguments s, s 1,ands 2 as strings for conceptual simplicity, even though in our implementation they will be character lists, exploded from those strings.) 1. If there exists s 1 and s 2 such that s = s 1 s 2, s 1 L(r), and k(s 2 ) evaluates to true, then match r s k evaluates to true. 2. If for every s 1 and s 2 such that s = s 1 s 2 with s 1 L(r) we have that k(s 2 ) evaluates to false, then match r s k evaluates to false Notice that this specification determines the outcome only for continuations k that always yield either true or false on any input. This is sufficient for our purposes since the continuations that arise will always satisfy this requirement. (That fact is by no means obvious and requires proof. We will however omit the proof in this document.) Notice as well that the specification implies that the result should be false in the case that there is no way to partition the input string s such that an initial segment matches r. Before giving the implementation of match, we can define accept as follows: fun accept r s = match r (String.explode s) List.null Two remarks. We explode the string argument into a list of characters to facilitate sequential processing of the string. The initial continuation yields true or false according to whether the remaining input has been exhausted. Assuming that match satisfies the specification given above, one sees that accept is indeed the required matching algorithm. 3

4 Now for the code for match: (* match : regexp -> char list -> (char list -> bool) -> bool *) fun match (Char(a)) cs k = (case cs of nil => false (c::cs ) => (a=c) andalso k(cs )) match (One) cs k = k cs match (Zero) = false match (Times(r1,r2)) cs k = match r1 cs (fn cs => match r2 cs k) match (Plus(r1,r2)) cs k = match r1 cs k orelse match r2 cs k match (Star(r)) cs k = k cs orelse match r cs (fn cs => match (Star(r)) cs k) Note that the case of (Star r) could have been written match (Star(r)) cs k = match (Plus (One, Times (r, (Star r)))) cs k but this has the disadvantage of creating a new regular expression during matching. Does match satisfy the specification given above? A natural way to approach the proof is to proceed by induction on the structure of the regular expression. We examine here an abbreviated informal version of that proof for two cases. First, consider the case r = Times(r 1,r 2 ). We have two proof obligations according to whether or not the input may be partitioned in such a way that an initial segment matches r and the continuation succeeds on the corresponding final segment. First, suppose that s = s 1 s 2 with s 1 matching r and k(s 2 ) evaluates to true. Wearetoshow that match r s k evaluates to true. Nowsinces 1 matches r, wehavethats 1 = s 1,1 s 1,2 with s 1,1 matching r 1 and s 1,2 matching r 2. Consequently, by the inductive hypothesis applied to r 2,wehave that match r 2 (s 1,2 s 2 ) k evaluates to true. Therefore the application (fn cs => match r 2 cs k) (s 1,2 s 2 ) evaluates to true, and hence by the inductive hypothesis applied to r 1, the expression match r 1 s (fn cs => match r 2 cs k) evaluates to true, which is enough for the result. Second, suppose that no matter how we choose s 1 and s 2 such that s = s 1 s 2 with s 1 L(r), we have that k(s 2 ) evaluates to false. It suffices to show that match r 1 s (fn cs => match r 2 cs k) evaluates to false. By the inductive hypothesis (applied to r 1 ) it suffices to show that for every s 1,1 and s 2 such that s = s 1,1 s 2 with s 1,1 L(r 1 ), we have that match r 2 s 2 k evaluates to false. By the inductive hypothesis (applied to r 2 ) it suffices to show that for every s 1,2 and s 2 such that s 2 = s 1,2 s 2 with s 1,2 L(r 2 ), we have that k(s 2 ) evaluates to false. But this follows from our assumptions, taking s 1 = s 1,1 s 1,2. This completes the proof for r = r 1 r 2 ; you should carry out the proof for 0, 1, a, andr 1 + r 2. What about iteration? Let r be Star r 1, and suppose that s = s 1 s 2 with s 1 matching r and k(s 2 ) evaluates to true. By our choice of r, there are two cases to consider: either s 1 = ɛ, or s 1 = s 1,1 s 1,2 with s 1,1 matching r 1 and s 1,2 matching r. In the former case the result is the result of k(s), whichisk(s 2 ),whichistrue, as required. In the latter case it suffices to show that match r 1 s (fn cs => match r cs k) evaluates to true. By the inductive hypothesis, it suffices to show that match r s 2 k evaluates to true. It is tempting at this stage to appeal to the inductive hypothesis to complete the proof but we cannot because the regular expression argument is the original regular expression r, and not some sub-expression of it! What to do? In general there are two possibilities: fix the proof or find a counterexample to the theorem. Let s try to fix the proof it will help us to find the counterexample (the theorem as 4

5 stated, i.e., that the matcher behaves correctly on Star, is false). A natural attempt is to proceed by an outer induction on the structure of the regular expression (as we ve done so far), together with an inner induction on the length of the string, the idea being that in the case of iteration we appeal to the inner inductive hypothesis to complete the proof provided that the string s 1,2 s 2 can be shown to be shorter than the string s. This is equivalent to showing that s 1,1 is non-empty but that could be false! For example, r might be 1, in which case our matcher loops forever. What to do? Change the specification. The proof goes through provided that every regular expression is in standard form, by which we mean that if r occurs within a regular expression, then the empty string is not in the language of r. Given this condition, the proof goes through as outlined. You should carry out the proof for the case of iteration to check this claim. Remember that there are two parts to the proof: complete the proof for the case that there is a partitioning that leads to the continuation yielding true (sketched above), and for the case that there is no such partitioning. Consult the proof for the concatenation of regular expressions as a guide. In the next section we will see how to convert any regular expression into standard form, so we can apply the algorithm as given above. Another solution is to rule out matches of r against the empty string when matching r against any string. This never rules out a valid solution, but we can use the idea to force termination (which is the only the problem with the algorithm above). All cases remain the same, except for the case of Star(r). match (Star(r)) cs k = k cs orelse match r cs (fn cs => not (cs = cs ) andalso match (Star(r)) cs k) We fail if cs = cs, which means that the initial segment of s matched by r must have been empty. The correctness proof now works by two nested structural inductions: one on the structure of the regular expression r and one on the structure of the string we match against. This means that either (a) the regular expression has to get smaller (which it does in all cases except the last), or (b) if the regular expression stays the same, then the string has to get smaller. One can see that this is guaranteed in the modified program above since the continuation will always be called on a proper suffix of the original string. 5

6 5 Standardization If we do not want to change the program, we can restrict the input to be in standard form. But have we lost something by making this restriction? Are there non-standard regular expressions of interest? What have we left out? The answer is nothing, because any regular expression can be brought into standard form! The idea is that before matching commences we rewrite the regular expression into another regular expression defining the same language and in standard form. Here is how it is done. We rely on the equation L(r) =L(δ(r) +r ), where δ(r) is either 1 or 0 according to whether or not L(r) contains the empty string, and where r is defined so that L(r )=L(r) \{ɛ }. The functions δ(r) andr are defined as follows. δ(0) = 0 δ(1) = 1 δ(a) = 0 δ(r 1 + r 2 ) = δ(r 1 ) δ(r 2 ) δ(r 1 r 2 ) = δ(r 1 ) δ(r 2 ) δ(r ) = 1 We define r 1 r 2 to be 1 if either r 1 or r 2 is 1, and0 otherwise. We define r 1 r 2 to be 0 if either r 1 or r 2 is 0, and1 otherwise. Finally, we define r as follows: 0 = 0 1 = 0 a = a (r 1 + r 2 ) = (r 1 r 2 ) = r1 + r 2 δ(r 1 ) r2 + r 1 δ(r 2)+r1 r 2 (r ) = r (r ) The last two deserve comment. The non-empty strings matching r 1 r 2 are (1) the non-empty strings in r 2, in the case that r 1 contains the empty string, (2) the non-empty strings in r 1, in the case that r 2 contains the empty string, and (3) the concatenation of a non-empty string in r 1 followed by a non-empty string in r 2. Check that the given equation expresses these three conditions as a regular expression! The clause for iteration is motivated by the observation that the non-empty strings in the iteration r are simple the non-zero iterations of the non-empty strings in r. As an exercise, prove that δ(r)andr have the required properties (stated above), that δ(r)+r is in standard form, and that L(r) =L(δ(r) +r ). We thus can replace r by δ(r) +r without losing any matching ability and without needing to change our code from the first implementation of match given on page 4. 6

7 6 Conclusion The example of regular expression matching illustrates a number of important programming concepts: 1. Continuation-passing: the use of higher-order functions as continuations. 2. Proof-directed debugging: the use of a breakdown in a proof attempt to discover an error in the code. 3. Change of specification: once we isolated the error, we had the choice of changing the code or changing the specification. Moral: debugging isn t always a matter of hacking! 4. Pre-processing: to satisfy the more stringent specification we pre-processed the regular expression so that it satisfied the additional assumption required for correctness, without losing the generality of the matcher. 7

### 15 212: Principles of Programming. Some Notes on Continuations

15 212: Principles of Programming Some Notes on Continuations Michael Erdmann Spring 2011 These notes provide a brief introduction to continuations as a programming technique. Continuations have a rich

### Continuation Passing Style. Continuation Passing Style

161 162 Agenda functional programming recap problem: regular expression matcher continuation passing style (CPS) movie regular expression matcher based on CPS correctness proof, verification change of

### Logic and Computation Lecture 20 CSU 290 Spring 2009 (Pucella) Thursday, Mar 12, 2009

Logic and Computation Lecture 20 CSU 290 Spring 2009 (Pucella) Thursday, Mar 12, 2009 Note that I change the name of the functions slightly in these notes from what I used in class, to be consistent with

### Fundamental mathematical techniques reviewed: Mathematical induction Recursion. Typically taught in courses such as Calculus and Discrete Mathematics.

Fundamental mathematical techniques reviewed: Mathematical induction Recursion Typically taught in courses such as Calculus and Discrete Mathematics. Techniques introduced: Divide-and-Conquer Algorithms

### Lecture 3: Recursion; Structural Induction

15-150 Lecture 3: Recursion; Structural Induction Lecture by Dan Licata January 24, 2012 Today, we are going to talk about one of the most important ideas in functional programming, structural recursion

### DVA337 HT17 - LECTURE 4. Languages and regular expressions

DVA337 HT17 - LECTURE 4 Languages and regular expressions 1 SO FAR 2 TODAY Formal definition of languages in terms of strings Operations on strings and languages Definition of regular expressions Meaning

### Variants of Turing Machines

November 4, 2013 Robustness Robustness Robustness of a mathematical object (such as proof, definition, algorithm, method, etc.) is measured by its invariance to certain changes Robustness Robustness of

### Chapter Seven: Regular Expressions

Chapter Seven: Regular Expressions Regular Expressions We have seen that DFAs and NFAs have equal definitional power. It turns out that regular expressions also have exactly that same definitional power:

### 15 212: Principles of Programming. Some Notes on Grammars and Parsing

15 212: Principles of Programming Some Notes on Grammars and Parsing Michael Erdmann Spring 2011 1 Introduction These notes are intended as a rough and ready guide to grammars and parsing. The theoretical

### Chapter 3. Set Theory. 3.1 What is a Set?

Chapter 3 Set Theory 3.1 What is a Set? A set is a well-defined collection of objects called elements or members of the set. Here, well-defined means accurately and unambiguously stated or described. Any

### NP-Hardness. We start by defining types of problem, and then move on to defining the polynomial-time reductions.

CS 787: Advanced Algorithms NP-Hardness Instructor: Dieter van Melkebeek We review the concept of polynomial-time reductions, define various classes of problems including NP-complete, and show that 3-SAT

### CS 161 Computer Security

Wagner Spring 2014 CS 161 Computer Security 1/27 Reasoning About Code Often functions make certain assumptions about their arguments, and it is the caller s responsibility to make sure those assumptions

### Comparing sizes of sets

Comparing sizes of sets Sets A and B are the same size if there is a bijection from A to B. (That was a definition!) For finite sets A, B, it is not difficult to verify that there is a bijection from A

### Harvard School of Engineering and Applied Sciences CS 152: Programming Languages

Harvard School of Engineering and Applied Sciences CS 152: Programming Languages Lecture 19 Tuesday, April 3, 2018 1 Introduction to axiomatic semantics The idea in axiomatic semantics is to give specifications

### These are not polished as solutions, but ought to give a correct idea of solutions that work. Note that most problems have multiple good solutions.

CSE 591 HW Sketch Sample Solutions These are not polished as solutions, but ought to give a correct idea of solutions that work. Note that most problems have multiple good solutions. Problem 1 (a) Any

### Cache-Oblivious Traversals of an Array s Pairs

Cache-Oblivious Traversals of an Array s Pairs Tobias Johnson May 7, 2007 Abstract Cache-obliviousness is a concept first introduced by Frigo et al. in [1]. We follow their model and develop a cache-oblivious

### The Encoding Complexity of Network Coding

The Encoding Complexity of Network Coding Michael Langberg Alexander Sprintson Jehoshua Bruck California Institute of Technology Email: mikel,spalex,bruck @caltech.edu Abstract In the multicast network

### Lists. Michael P. Fourman. February 2, 2010

Lists Michael P. Fourman February 2, 2010 1 Introduction The list is a fundamental datatype in most functional languages. ML is no exception; list is a built-in ML type constructor. However, to introduce

### Lecture 6: Sequential Sorting

15-150 Lecture 6: Sequential Sorting Lecture by Dan Licata February 2, 2012 Today s lecture is about sorting. Along the way, we ll learn about divide and conquer algorithms, the tree method, and complete

### 09 B: Graph Algorithms II

Correctness and Complexity of 09 B: Graph Algorithms II CS1102S: Data Structures and Algorithms Martin Henz March 19, 2010 Generated on Thursday 18 th March, 2010, 00:20 CS1102S: Data Structures and Algorithms

### Discrete Mathematics and Probability Theory Fall 2009 Satish Rao,David Tse Note 8

CS 70 Discrete Mathematics and Probability Theory Fall 2009 Satish Rao,David Tse Note 8 An Introduction to Graphs Formulating a simple, precise specification of a computational problem is often a prerequisite

### Propositional Logic Formal Syntax and Semantics. Computability and Logic

Propositional Logic Formal Syntax and Semantics Computability and Logic Syntax and Semantics Syntax: The study of how expressions are structured (think: grammar) Semantics: The study of the relationship

### CS 125 Section #4 RAMs and TMs 9/27/16

CS 125 Section #4 RAMs and TMs 9/27/16 1 RAM A word-ram consists of: A fixed set of instructions P 1,..., P q. Allowed instructions are: Modular arithmetic and integer division on registers; the standard

### Announcements. CS243: Discrete Structures. Strong Induction and Recursively Defined Structures. Review. Example (review) Example (review), cont.

Announcements CS43: Discrete Structures Strong Induction and Recursively Defined Structures Işıl Dillig Homework 4 is due today Homework 5 is out today Covers induction (last lecture, this lecture, and

### Reasoning about programs. Chapter 9 of Thompson

Reasoning about programs Chapter 9 of Thompson Proof versus testing A proof will state some property of a program that holds for all inputs. Testing shows only that a property holds for a particular set

### 6. Lecture notes on matroid intersection

Massachusetts Institute of Technology 18.453: Combinatorial Optimization Michel X. Goemans May 2, 2017 6. Lecture notes on matroid intersection One nice feature about matroids is that a simple greedy algorithm

### Chapter 3. The While programming language

Chapter 3 The While programming language 1 Contents 3 The While programming language 1 3.1 Big-step semantics........................... 2 3.2 Small-step semantics.......................... 9 3.3 Properties................................

### Definition For vertices u, v V (G), the distance from u to v, denoted d(u, v), in G is the length of a shortest u, v-path. 1

Graph fundamentals Bipartite graph characterization Lemma. If a graph contains an odd closed walk, then it contains an odd cycle. Proof strategy: Consider a shortest closed odd walk W. If W is not a cycle,

### P Is Not Equal to NP. ScholarlyCommons. University of Pennsylvania. Jon Freeman University of Pennsylvania. October 1989

University of Pennsylvania ScholarlyCommons Technical Reports (CIS) Department of Computer & Information Science October 1989 P Is Not Equal to NP Jon Freeman University of Pennsylvania Follow this and

### Greedy Algorithms and Matroids. Andreas Klappenecker

Greedy Algorithms and Matroids Andreas Klappenecker Greedy Algorithms A greedy algorithm solves an optimization problem by working in several phases. In each phase, a decision is made that is locally optimal

### Lexical Analysis 1 / 52

Lexical Analysis 1 / 52 Outline 1 Scanning Tokens 2 Regular Expresssions 3 Finite State Automata 4 Non-deterministic (NFA) Versus Deterministic Finite State Automata (DFA) 5 Regular Expresssions to NFA

### CS 161 Lecture 11 BFS, Dijkstra s algorithm Jessica Su (some parts copied from CLRS) 1 Review

1 Review 1 Something I did not emphasize enough last time is that during the execution of depth-firstsearch, we construct depth-first-search trees. One graph may have multiple depth-firstsearch trees,

### Lecture 15 : Review DRAFT

CS/Math 240: Introduction to Discrete Mathematics 3/10/2011 Lecture 15 : Review Instructor: Dieter van Melkebeek Scribe: Dalibor Zelený DRAFT Today slectureservesasareviewofthematerialthatwillappearonyoursecondmidtermexam.

### CS 3512, Spring Instructor: Doug Dunham. Textbook: James L. Hein, Discrete Structures, Logic, and Computability, 3rd Ed. Jones and Barlett, 2010

CS 3512, Spring 2011 Instructor: Doug Dunham Textbook: James L. Hein, Discrete Structures, Logic, and Computability, 3rd Ed. Jones and Barlett, 2010 Prerequisites: Calc I, CS2511 Rough course outline:

### 1 Finite Representations of Languages

1 Finite Representations of Languages Languages may be infinite sets of strings. We need a finite notation for them. There are at least four ways to do this: 1. Language generators. The language can be

### 3.4 Deduction and Evaluation: Tools Conditional-Equational Logic

3.4 Deduction and Evaluation: Tools 3.4.1 Conditional-Equational Logic The general definition of a formal specification from above was based on the existence of a precisely defined semantics for the syntax

### A quick introduction to SML

A quick introduction to SML CMSC 15300 April 9, 2004 1 Introduction Standard ML (SML) is a functional language (or higherorder language) and we will use it in this course to illustrate some of the important

### Chapter 3: Propositional Languages

Chapter 3: Propositional Languages We define here a general notion of a propositional language. We show how to obtain, as specific cases, various languages for propositional classical logic and some non-classical

Cuckoo Hashing for Undergraduates Rasmus Pagh IT University of Copenhagen March 27, 2006 Abstract This lecture note presents and analyses two simple hashing algorithms: Hashing with Chaining, and Cuckoo

### Lexical Analysis. Chapter 2

Lexical Analysis Chapter 2 1 Outline Informal sketch of lexical analysis Identifies tokens in input string Issues in lexical analysis Lookahead Ambiguities Specifying lexers Regular expressions Examples

### 4 Generating functions in two variables

4 Generating functions in two variables (Wilf, sections.5.6 and 3.4 3.7) Definition. Let a(n, m) (n, m 0) be a function of two integer variables. The 2-variable generating function of a(n, m) is F (x,

### MISCELLANEOUS SHAPES

MISCELLANEOUS SHAPES 4.1. INTRODUCTION Five generic shapes of polygons have been usefully distinguished in the literature: convex, orthogonal, star, spiral, and monotone. 1 Convex polygons obviously do

### CS40-S13: Functional Completeness

CS40-S13: Functional Completeness Victor Amelkin victor@cs.ucsb.edu April 12, 2013 In class, we have briefly discussed what functional completeness means and how to prove that a certain system (a set)

### Solution to Problem 1 of HW 2. Finding the L1 and L2 edges of the graph used in the UD problem, using a suffix array instead of a suffix tree.

Solution to Problem 1 of HW 2. Finding the L1 and L2 edges of the graph used in the UD problem, using a suffix array instead of a suffix tree. The basic approach is the same as when using a suffix tree,

### Regular Languages and Regular Expressions

Regular Languages and Regular Expressions According to our definition, a language is regular if there exists a finite state automaton that accepts it. Therefore every regular language can be described

### 2. CONNECTIVITY Connectivity

2. CONNECTIVITY 70 2. Connectivity 2.1. Connectivity. Definition 2.1.1. (1) A path in a graph G = (V, E) is a sequence of vertices v 0, v 1, v 2,..., v n such that {v i 1, v i } is an edge of G for i =

### Recursion defining an object (or function, algorithm, etc.) in terms of itself. Recursion can be used to define sequences

Section 5.3 1 Recursion 2 Recursion Recursion defining an object (or function, algorithm, etc.) in terms of itself. Recursion can be used to define sequences Previously sequences were defined using a specific

### Recursive Definitions and Structural Induction

Recursive Definitions and Structural Induction Introduction If it is difficult to define an object explicitly, it may be easy to define this object in terms of itself (i.e., the current term could be given

### CS Bootcamp Boolean Logic Autumn 2015 A B A B T T T T F F F T F F F F T T T T F T F T T F F F

1 Logical Operations 1.1 And The and operator is a binary operator, denoted as, &,, or sometimes by just concatenating symbols, is true only if both parameters are true. A B A B F T F F F F The expression

### A Brief Introduction to Standard ML

A Brief Introduction to Standard ML Specification and Verification with Higher-Order Logic Arnd Poetzsch-Heffter (Slides by Jens Brandt) Software Technology Group Fachbereich Informatik Technische Universität

### 1.7 The Heine-Borel Covering Theorem; open sets, compact sets

1.7 The Heine-Borel Covering Theorem; open sets, compact sets This section gives another application of the interval halving method, this time to a particularly famous theorem of analysis, the Heine Borel

### Goals: Define the syntax of a simple imperative language Define a semantics using natural deduction 1

Natural Semantics Goals: Define the syntax of a simple imperative language Define a semantics using natural deduction 1 1 Natural deduction is an instance of first-order logic; that is, it is the formal

### Algorithms for Data Science

Algorithms for Data Science CSOR W4246 Eleni Drinea Computer Science Department Columbia University Thursday, October 1, 2015 Outline 1 Recap 2 Shortest paths in graphs with non-negative edge weights (Dijkstra

### CHAPTER 4. COMPUTABILITY AND DECIDABILITY

CHAPTER 4. COMPUTABILITY AND DECIDABILITY 1. Introduction By definition, an n-ary function F on N assigns to every n-tuple k 1,...,k n of elements of N a unique l N which is the value of F at k 1,...,k

### 1 Variations of the Traveling Salesman Problem

Stanford University CS26: Optimization Handout 3 Luca Trevisan January, 20 Lecture 3 In which we prove the equivalence of three versions of the Traveling Salesman Problem, we provide a 2-approximate algorithm,

### 1 Undirected Vertex Geography UVG

Geography Start with a chip sitting on a vertex v of a graph or digraph G. A move consists of moving the chip to a neighbouring vertex. In edge geography, moving the chip from x to y deletes the edge (x,

### STUDENT OUTLINE. Lesson 8: Structured Programming, Control Structures, if-else Statements, Pseudocode

STUDENT OUTLINE Lesson 8: Structured Programming, Control Structures, if- Statements, Pseudocode INTRODUCTION: This lesson is the first of four covering the standard control structures of a high-level

### Cardinality of Sets. Washington University Math Circle 10/30/2016

Cardinality of Sets Washington University Math Circle 0/0/06 The cardinality of a finite set A is just the number of elements of A, denoted by A. For example, A = {a, b, c, d}, B = {n Z : n } = {,,, 0,,,

### The second statement selects character number 1 from and assigns it to.

Chapter 8 Strings 8.1 A string is a sequence A string is a sequence of characters. You can access the characters one at a time with the bracket operator: The second statement selects character number 1

### C++ Programming: From Problem Analysis to Program Design, Third Edition

C++ Programming: From Problem Analysis to Program Design, Third Edition Chapter 5: Control Structures II (Repetition) Why Is Repetition Needed? Repetition allows you to efficiently use variables Can input,

### CSE 105 THEORY OF COMPUTATION

CSE 105 THEORY OF COMPUTATION Spring 2016 http://cseweb.ucsd.edu/classes/sp16/cse105-ab/ Today's learning goals Sipser Ch 3.2, 3.3 Define variants of TMs Enumerators Multi-tape TMs Nondeterministic TMs

### Topic: Local Search: Max-Cut, Facility Location Date: 2/13/2007

CS880: Approximations Algorithms Scribe: Chi Man Liu Lecturer: Shuchi Chawla Topic: Local Search: Max-Cut, Facility Location Date: 2/3/2007 In previous lectures we saw how dynamic programming could be

### We assume uniform hashing (UH):

We assume uniform hashing (UH): the probe sequence of each key is equally likely to be any of the! permutations of 0,1,, 1 UH generalizes the notion of SUH that produces not just a single number, but a

### Fall 2017 Discussion 7: October 25, 2017 Solutions. 1 Introduction. 2 Primitives

CS 6A Scheme Fall 207 Discussion 7: October 25, 207 Solutions Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write

### MATH 54 - LECTURE 4 DAN CRYTSER

MATH 54 - LECTURE 4 DAN CRYTSER Introduction In this lecture we review properties and examples of bases and subbases. Then we consider ordered sets and the natural order topology that one can lay on an

### Implementation of Lexical Analysis

Implementation of Lexical Analysis Outline Specifying lexical structure using regular expressions Finite automata Deterministic Finite Automata (DFAs) Non-deterministic Finite Automata (NFAs) Implementation

### MIT Specifying Languages with Regular Expressions and Context-Free Grammars

MIT 6.035 Specifying Languages with Regular essions and Context-Free Grammars Martin Rinard Laboratory for Computer Science Massachusetts Institute of Technology Language Definition Problem How to precisely

### Ramsey s Theorem on Graphs

Ramsey s Theorem on Graphs 1 Introduction Exposition by William Gasarch Imagine that you have 6 people at a party. We assume that, for every pair of them, either THEY KNOW EACH OTHER or NEITHER OF THEM

### Counting. Chapter Basic Counting. The Sum Principle. We begin with an example that illustrates a fundamental principle.

Chapter 1 Counting 1.1 Basic Counting The Sum Principle We begin with an example that illustrates a fundamental principle. Exercise 1.1-1 The loop below is part of an implementation of selection sort,

### General Computer Science (CH ) Fall 2016 SML Tutorial: Practice Problems

General Computer Science (CH08-320101) Fall 2016 SML Tutorial: Practice Problems November 30, 2016 Abstract This document accompanies the traditional SML tutorial in GenCS. It contains a sequence of simple

### Infinite locally random graphs

Infinite locally random graphs Pierre Charbit and Alex D. Scott Abstract Motivated by copying models of the web graph, Bonato and Janssen [3] introduced the following simple construction: given a graph

### Polygon Triangulation

Polygon Triangulation Definition Simple Polygons 1. A polygon is the region of a plane bounded by a finite collection of line segments forming a simple closed curve. 2. Simple closed curve means a certain

### Microsoft Visual Basic 2005: Reloaded

Microsoft Visual Basic 2005: Reloaded Second Edition Chapter 4 Making Decisions in a Program Objectives After studying this chapter, you should be able to: Include the selection structure in pseudocode

### Lecture 5 Sorting Arrays

Lecture 5 Sorting Arrays 15-122: Principles of Imperative Computation (Spring 2018) Frank Pfenning, Rob Simmons We begin this lecture by discussing how to compare running times of functions in an abstract,

### Recursive Definitions Structural Induction Recursive Algorithms

Chapter 4 1 4.3-4.4 Recursive Definitions Structural Induction Recursive Algorithms 2 Section 4.1 3 Principle of Mathematical Induction Principle of Mathematical Induction: To prove that P(n) is true for

### Limitations of Algorithmic Solvability In this Chapter we investigate the power of algorithms to solve problems Some can be solved algorithmically and

Computer Language Theory Chapter 4: Decidability 1 Limitations of Algorithmic Solvability In this Chapter we investigate the power of algorithms to solve problems Some can be solved algorithmically and

### Section 1.7 Sequences, Summations Cardinality of Infinite Sets

Section 1.7 Sequences, Summations Cardinality of Infinite Sets Definition: A sequence is a function from a subset of the natural numbers (usually of the form {0, 1, 2,... } to a set S. Note: the sets and

### Verification of Selection and Heap Sort Using Locales

Verification of Selection and Heap Sort Using Locales Danijela Petrović September 19, 2015 Abstract Stepwise program refinement techniques can be used to simplify program verification. Programs are better

### Type Checking and Type Inference

Type Checking and Type Inference Principles of Programming Languages CSE 307 1 Types in Programming Languages 2 Static Type Checking 3 Polymorphic Type Inference Version: 1.8 17:20:56 2014/08/25 Compiled

### Objectives. Chapter 4: Control Structures I (Selection) Objectives (cont d.) Control Structures. Control Structures (cont d.) Relational Operators

Objectives Chapter 4: Control Structures I (Selection) In this chapter, you will: Learn about control structures Examine relational and logical operators Explore how to form and evaluate logical (Boolean)

### Shared Variables and Interference

Illinois Institute of Technology Lecture 24 Shared Variables and Interference CS 536: Science of Programming, Spring 2018 A. Why Parallel programs can coordinate their work using shared variables, but

### Warmup : Name that tune!

Warmup : Name that tune! Write, using a loop, Java code to print the lyrics to the song 99 Bottles of Beer on the Wall 99 bottles of beer on the wall. 99 bottles of beer. Take one down, pass it around,

### 3.15: Applications of Finite Automata and Regular Expressions. Representing Character Sets and Files

3.15: Applications of Finite Automata and Regular Expressions In this section we consider three applications of the material from Chapter 3: searching for regular expressions in files; lexical analysis;

### Turing Machines. A transducer is a finite state machine (FST) whose output is a string and not just accept or reject.

Turing Machines Transducers: A transducer is a finite state machine (FST) whose output is a string and not just accept or reject. Each transition of an FST is labeled with two symbols, one designating

### C++ Programming: From Problem Analysis to Program Design, Fourth Edition. Chapter 4: Control Structures I (Selection)

C++ Programming: From Problem Analysis to Program Design, Fourth Edition Chapter 4: Control Structures I (Selection) Objectives In this chapter, you will: Learn about control structures Examine relational

### Lecture 7: General Loops (Chapter 7)

CS 101: Computer Programming and Utilization Jul-Nov 2017 Umesh Bellur (cs101@cse.iitb.ac.in) Lecture 7: General Loops (Chapter 7) The Need for a More General Loop Read marks of students from the keyboard

### CS2 Language Processing note 3

CS2 Language Processing note 3 CS2Ah 5..4 CS2 Language Processing note 3 Nondeterministic finite automata In this lecture we look at nondeterministic finite automata and prove the Conversion Theorem, which

### Solutions to relevant spring 2000 exam problems

Problem 2, exam Here s Prim s algorithm, modified slightly to use C syntax. MSTPrim (G, w, r): Q = V[G]; for (each u Q) { key[u] = ; key[r] = 0; π[r] = 0; while (Q not empty) { u = ExtractMin (Q); for

### A Semantics to Generate the Context-sensitive Synchronized Control-Flow Graph (extended)

A Semantics to Generate the Context-sensitive Synchronized Control-Flow Graph (extended) Marisa Llorens, Javier Oliver, Josep Silva, and Salvador Tamarit Universidad Politécnica de Valencia, Camino de

### Lecture 5: The Halting Problem. Michael Beeson

Lecture 5: The Halting Problem Michael Beeson Historical situation in 1930 The diagonal method appears to offer a way to extend just about any definition of computable. It appeared in the 1920s that it

### Section 2.4 Sequences and Summations

Section 2.4 Sequences and Summations Definition: A sequence is a function from a subset of the natural numbers (usually of the form {0, 1, 2,... } to a set S. Note: the sets and {0, 1, 2, 3,..., k} {1,

### MATH 1A MIDTERM 1 (8 AM VERSION) SOLUTION. (Last edited October 18, 2013 at 5:06pm.) lim

MATH A MIDTERM (8 AM VERSION) SOLUTION (Last edited October 8, 03 at 5:06pm.) Problem. (i) State the Squeeze Theorem. (ii) Prove the Squeeze Theorem. (iii) Using a carefully justified application of the

### Semantic Forcing in Disjunctive Logic Programs

Semantic Forcing in Disjunctive Logic Programs Marina De Vos and Dirk Vermeir Dept of Computer Science Free University of Brussels, VUB Pleinlaan 2, Brussels 1050, Belgium Abstract We propose a semantics

### 9.5 Equivalence Relations

9.5 Equivalence Relations You know from your early study of fractions that each fraction has many equivalent forms. For example, 2, 2 4, 3 6, 2, 3 6, 5 30,... are all different ways to represent the same

### Verifying Safety Property of Lustre Programs: Temporal Induction

22c181: Formal Methods in Software Engineering The University of Iowa Spring 2008 Verifying Safety Property of Lustre Programs: Temporal Induction Copyright 2008 Cesare Tinelli. These notes are copyrighted

### The Resolution Width Problem is EXPTIME-Complete

The Resolution Width Problem is EXPTIME-Complete Alexander Hertel & Alasdair Urquhart November 24, 2007 Abstract The importance of width as a resource in resolution theorem proving has been emphasized

### Isometric Cycles, Cutsets, and Crowning of Bridged Graphs

Isometric Cycles, Cutsets, and Crowning of Bridged Graphs Tao Jiang, 1 Seog-Jin Kim, 2 and Douglas B. West 3 1 DEPARTMENT OF MATHEMATICS AND STATISTICS MIAMI UNIVERSITY OXFORD, OHIO 45056 E-mail: jiangt@muohio.edu

### Greedy Algorithms and Matroids. Andreas Klappenecker

Greedy Algorithms and Matroids Andreas Klappenecker Giving Change Coin Changing Suppose we have n types of coins with values v[1] > v[2] > > v[n] > 0 Given an amount C, a positive integer, the following