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

Save this PDF as:

Size: px
Start display at page:

## Transcription

1 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 model for a RAM machine does not have negative numbers, but you can verify that allowing signed integers doesn t chance the power of the model. Bitwise operations on registers. Loading a constant into a register. Transfering values between a register and a word in main memory (as addressed by another register). Conditional GOTO. MALLOC increase the size S of main memory by 1. This also increments the word size if the current word size is too small to address all of main memory. HALT. The program counter l {1,..., q}, telling us where we are in the program. statements, the counter increments after each instruction is executed. The space usage S, which starts at the size of the input. Except for GOTO The word size w; the initial word size is log 2 max(n + 1, k + 1), where n is the length of the input and k is the maximum constant appearing in the program or input. A constant number of registers R[0],..., R[r 1], each of which is a w-bit word. Main memory M[0],..., M[S 1], each of which is a w-bit word. The tuple (l, S, w, R, M) gives the configuration of the word-ram. We say that a word-ram solves a computational problem f : Σ 2 N if the machine which starts with input x halts with some output in f(x) as the set of characters in M[0],..., M[R[0] 1]. As we saw with Turing Machines, there are many adjustments we can make to a model which make it easier to reason about without significantly changing its power. Here s one for word-rams: Exercise. We define a 2-D word-ram model: Suppose that main memory, instead of being represented by a one-dimensional array of size S, is represented by a two-dimensional array of size S S. Consequently, saves or loads from main memory require addressing it using two registers; as before, MALLOC increases S by 1 (and consequently the size of memory by 2S + 1). Prove that a computational problem can be solved by a 2-D word-ram model in polynomial time if and only if it can be solved by regular word-ram model in polynomial time. In this problem, provide a formal description of how to convert between the two models. 1

2 Solution. ( = ) Intuition: To simulate a 1-D word-ram by a 2-D one, simply ignore all rows but the first, and whenever addressing some word in main memory, let the second index always equal 0. (That is, we keep one extra register in which we initially load the value 0, and then use that register only for the second index.) Formal description: To turn this idea into a formal description, given a 1-D word-ram program P = (P 1,..., P q ) with r registers, we have to give the code for an equivalent 2-D word-ram program that works along the lines discussed above. Define the following equivalent 2-D word-ram program P = (P 0, P 1,..., P q): P has r + 1 registers, and the instructions of P are obtained largely by those of P in the following way (where we go over all possible instruction schemas, using the ordering in the lecture notes on word-rams): 1. Let P 0 be R[r] = 0 2. For i = 0,..., q: (a) If P i is of the form R[i] m, let P i = P i; (b) If P i is of the form R[i] R[j] + R[k], let P i = P i; (c)... (d) If P i is of the form R[i] R[j]/R[k], let P i = P i. (e) If P i is of the form R[i] M[R[j]], let P i (f) If P i is of the form M[R[j]] R[i], let P i (g) If P i is of the form IF R[i] = 0, GOTO l, let P i (h)... be R[i] M[R[r]][R[j]] be M[R[r]][R[j]] R[i]. be IF R[i] = 0, GOTO l + 1. So, apart from GOTO, which we have to change because we added a new row in the beginning, we only change the instructions having to do with memory access, by modifying them so that they act as if the first row of the 2-D word-ram stands for the memory of the 1-D word-ram. Notice that since MALLOC on the 2-D word-ram restricts to the equivalent of MALLOC on the 1-D word-ram on the first row under our identification, no change is required in the way the MALLOC operation works. Running time and correctness: The fact that P is correct follows by a straightforward induction on the number of instructions: after t + 1 instructions of P have been executed, when we restrict the memory of P to the first row and the registers to the first r registers, we re in the same state as after t instructions of P have been executed. For running time, notice that if P takes t steps to halt on some input, P will take exactly t + 1 steps to halt. The wanted time bound follows directly. ( = ) Intuition: To simulate a 2-D word-ram by a 1-D one, we have to be careful about two things: simulating the MALLOC operation, and simulating the indexing into a two-dimensional array by indexing into a one-dimensional one. For the MALLOC operation, we use an extra register to keep track of the value of S; then, when the 2-D word-ram would do a malloc, we instead load 2S + 1 into a second extra register (we may need a third one to hold the constants for this computation), and make that many MALLOCs in our 1-D simulation, decrementing the register as we go. 2

3 A convenient way to deal with the second problem, meanwhile, when the dimensions S S are fixed, would be to let the entry M 2 [i][j] correspond to the entry M 1 [is + j]. However, S is not fixed in general, so if we want to keep with that nice formula we d have to reorganize the memory contents every time we MALLOC. To avoid this, we can index our 1-dimensional array in another way: let the cell [0][0] correspond to the cell 0, and then, think of expanding the square representing the 2-dimensional memory inductively, by increasing its current sidelength S by one, and appending the new cells [S][0], [S][1],..., [S][S], [S 1][S],..., [0][S] to the 1-dimensional memory in this order. We can write down concrete formulas for this identification: the cell [i][j] is represented by [i 2 + j] if i j and [j 2 + j + (j i)] otherwise. Formal description: We proceed in a way similar to what we did for easy direction; only now things require more careful adjusting. So, to turn our idea into a formal description, given a 1-D word-ram program P = (P 1,..., P q ) with r registers, we have to give the code for an equivalent 2-D word-ram program P that works along the lines discussed above. One trickier thing we have to deal with, and one that our high-level discussion ignored, is GOTO statements: since we ll be substituting single instructions to the 2-D word-ram with blocks of several instructions to the 1-D word-ram, we have to be careful about the numbering of lines in our program. So as we are converting the instructions (of which there are only constantly many, as we re working with a fixed program), we must keep track of how many of each kind we ve seen so far, and with how many instructions we re replacing each, so that we know at which line we are, and to which line we want to get. Since we ll be replacing each instruction to the 2-D word-ram of a given form with the same number of instructions to the 1-D word-ram, this is a very doable task that we can do even before we ve started conversion, just by counting the instructions of various types present in P. We ll assume we ve done that, and suppress the explicit formulas for conversion in the code below, by letting f(l) stand for the function giving the number of line l from the 2-D word-ram program in the 1-D word-ram program, and L stand for the current line number in the 1-D word-ram program (you can think of these functions as of lookup tables). We define the following 1-D word-ram program P : P has r + 7 registers, and the instructions of P are obtained from those of P in the following way (where we go over all possible instruction schemas, using the ordering in the lecture notes on word-rams): 1. Let P 0 2. Let P 1 3. Let P 2 be R[r] R[1] (initialize current memory usage S, as R[1] holds n) be R[r + 5] 0 (keep the constant 0 for ease of control flow) be R[r + 6] 1 (keep the constant 1) 4. For i = 0,..., q: (replace instructions of P by suitable equivalents) (a) If P i is of the form R[i] m, append P i to the current program P ; touch memory, or MALLOC, or GOTO, are left intact) (instructions that don t (b) If P i is of the form R[i] R[j] + R[k], append P i to the current program P (c)... (d) If P i is of the form R[i] R[j]/R[k], append P i to the current program P. 3

4 (e) If P i is of the form M[R[i]][R[j]] R[k] or R[k] M[R[i]][R[j]], we append the following several instructions to the current program P : i. R[r + 1] R[i] (prepare temporary variables) ii. R[r + 2] R[j] iii. R[r + 3] R[r + 1]/R[r + 2] (test if i < j) iv. IF R[r + 3] = 0, GOTO L + 4 computation) (in this case, i < j, so we skip ahead to the relevant v. R[r + 3] R[r + 1] R[r + 1] (this branch computes R[i] 2 + R[j] vi. R[r + 3] R[r + 3] + R[r + 2] vii. IF R[r + 5] = 0, GOTO L + 5 (this will always be true, as we keep R[r + 5] = 0) viii. R[r + 3] R[r + 2] R[r + 2] ix. R[r + 3] R[r + 3] + R[r + 2] x. R[r + 3] R[r + 3] + R[r + 2] xi. R[r + 3] R[r + 3] R[r + 1] (this branch computes R[j] 2 + R[j] + (R[j] R[i])) xii. M[R[r + 3]] R[k], or R[k] M[R[r + 3]], according to which the form of the command we re replacing. (f) If P i is of the form IF R[i] = 0, GOTO l, append IF R[i] = 0, GOTO f(l) to the current program P. (g) If P i is of the form MALLOC, append the following several instructions to the program: i. R[r + 4] R[r] (copy current memory usage S of the 2-D RAM, and increment it) ii. R[r] R[r] + R[r + 6]. (recall R[r + 6] = 1) iii. R[r + 4] R[r + 4] + R[r + 4] (compute 2S + 1) iv. R[r + 4] R[r + 4] + R[r + 6] v. IF R[r + 4] = 0, GOTO L + 4 (loop to do 2S + 1 MALLOC-s on 1-D word-ram) vi. MALLOC vii. R[r + 4] R[r + 4] R[r + 6] viii. IF R[r + 5] = 0, GOTO L 3 Running time and correctness: Correctness follows in a similar way as before; now the claim is that after t instructions in P, and the corresponding t instructions in P, the two machines are in the same state under our identification between the 2-dimensional memory and the 1-dimensional memory via the formulas we wrote down in the beginning. For running time, each instruction of P is simulated in O(1) instructions of P, except for MALLOC, which takes O(S) instructions, where S is the current sidelength of the square representing the memory of P. Since S can increase by at most 1 for each step of P, S is never more than the running time T (n) of P, hence the running time of P is never more than O(T (n) O(T (n))) = O(T 2 (n)). 4

5 2 Turing Machines Formally, a Turing machines is a 6-tuple M = (Q, Σ, Γ, δ, q 0, q halt ), where Q is a finite set of states. This means you can use your states to do finite counting (e.g. modulo 2), but not counting to arbitrarily large numbers. Sometimes, instead of having a single q halt state, people will talk about having a q reject and q accept state. Σ is the input alphabet. Γ is the tape alpabet, with Σ Γ and Γ Σ. δ : Q Γ Q Γ {L, R} is the transition function. As we saw in class, we can simulate a multiple tape Turing machine with a single tape ; in this case, if we have k tapes, the transition function is δ : Q Γ k Q Γ k {L, R} k. We ll often also allow an S for staying still; this does not change the power of the TM. q 0, q accept, q reject Q are the start state, accept state, and reject state. respectively A Turing machine configuration is a string uqv Γ QΓ that encodes (i) the state q of M, (ii) the tape contents uv ignoring trailing blanks, and (iii) the location of the head within the tape. The starting configuration is q 0 x. We say that a Turing Machine solves a computational problem f : Σ 2 (Γ/ ) if the Turing machine which starts with input x halts with some output in f(x) as the set of characters before the first. The extended Church-Turing Thesis says that every reasonable model of computation can be simulated on a Turing machine with only a polynomial slowdown. Exercise. Give the state diagram for a Turing machine which converts unary to binary (that is, given the input 1 x, it should return the binary representation of x). Solution. We give a two-tape Turing machine, which does the following: Adds a special start symbol \$ to the beginning of the tape and shifts the input 1 character right (q 0 q S... q S q 1 ). Going left until it hits the \$, counts the number of 1 s by incrementing on the second tape, keeping the answer written in reverse on the second tape (q 1 q 2 q 3 q 1 ). Each time it returns to q 1, the head of the second tape is at the first character after the \$. It removes the \$ at the start of the first tape and scrolls the head of the second tape to the end of its string (q 1 q m q r ). It copies the second tape backwards onto the first tape, halting when it reaches the \$ at the start of the second tape (q r q halt ). 5

6 , Γ,, L, L q halt, \$,, S, S 1, Γ 1,, R, S, Γ, Γ, S, R q 0 1, Γ \$, \$, R, R q S q 1 q m, Γ 1,, S, S \$, Γ, Γ, L, R,,, S, L q r 1, Γ, Γ, L, S Γ, \$ Γ, \$, S, R,,, R, L q 2 q 3 Γ, 0 or Γ, 1, S, L Γ, 1 Γ, 0, S, R Γ, Γ \$ Γ, Γ \$, S, L The runtime of this machine is O(n log n), where n is the length of the input. Note that in the diagram above, we have omitted impossible arrows, e.g. ones that the machine will never follow given a valid input. Often, when we talk about computational problems, we talk about decision problems, where the output is in {0, 1}; this is the same idea as deciding whether the given string is in some language L Σ. However, in many cases the problem of finding a solution is not necessarily more difficult than the problem of determining whether there exists one. You re asked to prove a few of these on your homework; we ll look at one more of them here. Exercise. Show that there is a polynomial-time algorithm for 3-Satisfiability (given a boolean formula in 3-CNF form, determine whether there exists a satisfying assignment) if and only if the computational problem of finding a satisfying assignment (or returning nothing if none exists) is in P. For this problem, you can use high-level algorithm descriptions. Solution. ( = ) Clearly, if we can find a satisfying assignment, then we can determine whether there exists one. ( = ) Now suppose we have an algorithm A that decides in polynomial time whether a given 3-CNF formula φ has a satisfying assignment. How can we use A to find such an assignment? The idea is to set the variables one by one, and make sure that the remaining formula still has a satisfying assignment along the way. Algorithm: So, let φ i1,...,i t stand for the formula φ with partial assignment x 1 = i 1,..., x t = i t ; then φ i1,...,i t can easily be written in 3-CNF form (why? there is a detailed explanation in the more formal solution given below). If A(φ) returns FALSE, we return nothing. Otherwise, we run A(φ 1 ). If that gives 6

7 TRUE, we assign x 1 = 1 and repeat with the formula φ 1 instead of φ; if it gives FALSE, it must be the case that A(φ 0 ) is TRUE, so we repeat with φ 0 instead of φ. In the end we have a formula φ i1,...,i n which is satisfiable, but is also a constant, therefore x j = i j gives a satisfying assignment. Correctness and running time: From the above discussion, correctness is clear. The running time will be O(nT (n)) where T (n) is the running time of the decider for satisfiability, hence it is polynomial. More detail: TM implementation. Here s a more low-level solution to give you more practice with TMs: Suppose that we have some Turing Machine M, which, given an input, determines whether there exists a satisfying assignment. We go about actually finding a satisfying assignment as follows: Simulate M on the input (after copying the input to a second tape); if M returns false, then halt and return nothing. Now, try setting x 1 = 1 in the formula, e.g. copy the formula onto a second tape, removing any clauses which are satisfied (i.e. contain x 1 ) and removing any instances of x 1. If the latter results in any empty clauses, e.g. saying that this is not a satisfying assignment, set x 1 = 0. Run M on the output of the previous step; if M returns true, then set x 1 = 1 in the original copy of the formula. Otherwise, set x 1 = 0. Repeat the previous two steps with x 2,..., x n in sequence. solution. The final result will be a satisfying Here, we see that we simulate M at most n times, and that the length of the input to M is no more than the length of the input to our original problem. Meanwhile, all the other steps (copying the formula, setting the value of variable) take no more than linear time and run only polynomially many times, so they also run in polynomial time. Hence, this entire algorithm runs in polynomial time. There are many details that we don t address in the solution above because we are working at a higher level (e.g. clearing a tape so that we can reuse it in multiple simulations of M); however, you should convince yourself that all of these are doable, and none of these have a significant affect on the runtime. 7

### Turing Machine as Transducer. Turing Machines. Computation with Turing Machines. Computation with Turing Machines. Computation with Turing Machines

Turing Machine as Transducer Turing Computation and programming Transducer -- any device that converts a signal from one form to another Turning machine Converts input to output Start with string on the

### 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

### 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

### 4.1 Review - the DPLL procedure

Applied Logic Lecture 4: Efficient SAT solving CS 4860 Spring 2009 Thursday, January 29, 2009 The main purpose of these notes is to help me organize the material that I used to teach today s lecture. They

### 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

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

Harvard School of Engineering and Applied Sciences CS 152: Programming Languages Lecture 21 Tuesday, April 15, 2014 1 Static program analyses For the last few weeks, we have been considering type systems.

### 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

### 1. (a) O(log n) algorithm for finding the logical AND of n bits with n processors

1. (a) O(log n) algorithm for finding the logical AND of n bits with n processors on an EREW PRAM: See solution for the next problem. Omit the step where each processor sequentially computes the AND of

### More Simulations. CS154 Chris Pollett Apr 25, 2007.

More Simulations CS154 Chris Pollett Apr 25, 2007. Outline Multi-tape Turing Machines RAMS k-tape Turing Machine One way you might try to improve the power of a TM is to allow multiple tapes. Definition

### Lecture 4: 3SAT and Latin Squares. 1 Partial Latin Squares Completable in Polynomial Time

NP and Latin Squares Instructor: Padraic Bartlett Lecture 4: 3SAT and Latin Squares Week 4 Mathcamp 2014 This talk s focus is on the computational complexity of completing partial Latin squares. Our first

### Diagonalization. The cardinality of a finite set is easy to grasp: {1,3,4} = 3. But what about infinite sets?

Diagonalization Cardinalities The cardinality of a finite set is easy to grasp: {1,3,4} = 3. But what about infinite sets? We say that a set S has at least as great cardinality as set T, written S T, if

### 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

### CS422 - Programming Language Design

1 CS422 - Programming Language Design Denotational Semantics Grigore Roşu Department of Computer Science University of Illinois at Urbana-Champaign 2 Denotational semantics, alsoknownasfix-point semantics,

### 6. Advanced Topics in Computability

227 6. Advanced Topics in Computability The Church-Turing thesis gives a universally acceptable definition of algorithm Another fundamental concept in computer science is information No equally comprehensive

### On the computability of graph Turing machines

On the computability of graph Turing machines Nathanael Ackerman Harvard University Cambridge, MA 02138, USA nate@math.harvard.edu Cameron Freer Remine Falls Church, VA 22043, USA cameron@remine.com Abstract

### Lecture 10 Notes Linked Lists

Lecture 10 Notes Linked Lists 15-122: Principles of Imperative Computation (Summer 1 2015) Frank Pfenning, Rob Simmons, André Platzer 1 Introduction In this lecture we discuss the use of linked lists to

### Lecture 10 Notes Linked Lists

Lecture 10 Notes Linked Lists 15-122: Principles of Imperative Computation (Spring 2016) Frank Pfenning, Rob Simmons, André Platzer 1 Introduction In this lecture we discuss the use of linked lists to

### Turing Machines Part Two

Turing Machines Part Two Recap from Last Time The Turing Machine A Turing machine consists of three parts: A finite-state control that issues commands, an infinite tape for input and scratch space, and

### An Interesting Way to Combine Numbers

An Interesting Way to Combine Numbers Joshua Zucker and Tom Davis October 12, 2016 Abstract This exercise can be used for middle school students and older. The original problem seems almost impossibly

### Insertion Sort: an algorithm for sorting an array

Insertion Sort: an algorithm for sorting an array Let s use arrays to solve a problem that comes up often in programming, namely sorting. Suppose we have an array of objects that is in no particular order

### CS152: Programming Languages. Lecture 7 Lambda Calculus. Dan Grossman Spring 2011

CS152: Programming Languages Lecture 7 Lambda Calculus Dan Grossman Spring 2011 Where we are Done: Syntax, semantics, and equivalence For a language with little more than loops and global variables Now:

### Excerpt from "Art of Problem Solving Volume 1: the Basics" 2014 AoPS Inc.

Chapter 5 Using the Integers In spite of their being a rather restricted class of numbers, the integers have a lot of interesting properties and uses. Math which involves the properties of integers is

### 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

### Lec-5-HW-1, TM basics

Lec-5-HW-1, TM basics (Problem 0)-------------------- Design a Turing Machine (TM), T_sub, that does unary decrement by one. Assume a legal, initial tape consists of a contiguous set of cells, each containing

### COMP combinational logic 1 Jan. 18, 2016

In lectures 1 and 2, we looked at representations of numbers. For the case of integers, we saw that we could perform addition of two numbers using a binary representation and using the same algorithm that

### Basic Triangle Congruence Lesson Plan

Basic Triangle Congruence Lesson Plan Developed by CSSMA Staff Drafted August 2015 Prescribed Learning Outcomes: Introduce students to the concept of triangle congruence and teach them about the congruency

### Microcontroller Systems

µcontroller systems 1 / 43 Microcontroller Systems Engineering Science 2nd year A2 Lectures Prof David Murray david.murray@eng.ox.ac.uk www.robots.ox.ac.uk/ dwm/courses/2co Michaelmas 2014 µcontroller

SharePoint Designer Advanced SharePoint Designer Advanced (1:00) Thank you for having me here today. As mentioned, my name is Susan Hernandez, and I work at Applied Knowledge Group (http://www.akgroup.com).

### Finite Automata Theory and Formal Languages TMV027/DIT321 LP4 2016

Finite Automata Theory and Formal Languages TMV027/DIT321 LP4 2016 Lecture 15 Ana Bove May 23rd 2016 More on Turing machines; Summary of the course. Overview of today s lecture: Recap: PDA, TM Push-down

### Languages and Models of Computation

Computer Science 52 Languages and Models of Computation Spring Semester, 2018 Computer scientists use languages in (at least) two ways. They design and use programming languages, and they study formal

### Functional abstraction. What is abstraction? Eating apples. Readings: HtDP, sections Language level: Intermediate Student With Lambda

Functional abstraction Readings: HtDP, sections 19-24. Language level: Intermediate Student With Lambda different order used in lecture section 24 material introduced much earlier sections 22, 23 not covered

### Name: CS 341 Practice Final Exam. 1 a 20 b 20 c 20 d 20 e 20 f 20 g Total 207

Name: 1 a 20 b 20 c 20 d 20 e 20 f 20 g 20 2 10 3 30 4 12 5 15 Total 207 CS 341 Practice Final Exam 1. Please write neatly. You will lose points if we cannot figure out what you are saying. 2. Whenever

### (How Not To Do) Global Optimizations

(How Not To Do) Global Optimizations #1 One-Slide Summary A global optimization changes an entire method (consisting of multiple basic blocks). We must be conservative and only apply global optimizations

### COMP MIPS instructions 2 Feb. 8, f = g + h i;

Register names (save, temporary, zero) From what I have said up to now, you will have the impression that you are free to use any of the 32 registers (\$0,..., \$31) in any instruction. This is not so, however.

### CS402 - Theory of Automata Glossary By

CS402 - Theory of Automata Glossary By Acyclic Graph : A directed graph is said to be acyclic if it contains no cycles. Algorithm : A detailed and unambiguous sequence of instructions that describes how

### 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:

### 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

### 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

### Working with recursion

Working with recursion Readings: HtDP, sections 11, 12, 13 (Intermezzo 2). We can extend the idea of a self-referential definition to defining the natural numbers, which leads to the use of recursion in

### Rational Numbers CHAPTER Introduction

RATIONAL NUMBERS Rational Numbers CHAPTER. Introduction In Mathematics, we frequently come across simple equations to be solved. For example, the equation x + () is solved when x, because this value of

### Fixed Parameter Algorithms

Fixed Parameter Algorithms Dániel Marx Tel Aviv University, Israel Open lectures for PhD students in computer science January 9, 2010, Warsaw, Poland Fixed Parameter Algorithms p.1/41 Parameterized complexity

### Starting Boolean Algebra

Boolean Algebra March 2, 27 Diagram for FunChip2 Here is a picture of FunChip2 that we created more or less randomly in class on /25 (used in various Activities): Starting Boolean Algebra Boolean algebra

### LR Parsing E T + E T 1 T

LR Parsing 1 Introduction Before reading this quick JFLAP tutorial on parsing please make sure to look at a reference on LL parsing to get an understanding of how the First and Follow sets are defined.

### 19 Much that I bound, I could not free; Much that I freed returned to me. Lee Wilson Dodd

19 Much that I bound, I could not free; Much that I freed returned to me. Lee Wilson Dodd Will you walk a little faster? said a whiting to a snail, There s a porpoise close behind us, and he s treading

### 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

### 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,

### 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

### 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

### Whereweare. CS-XXX: Graduate Programming Languages. Lecture 7 Lambda Calculus. Adding data structures. Data + Code. What about functions

Whereweare CS-XXX: Graduate Programming Languages Lecture 7 Lambda Calculus Done: Syntax, semantics, and equivalence For a language with little more than loops and global variables Now: Didn t IMP leave

### 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,,,

### Directed Graph for Finite-State Machine

Directed Graph for Finite-State Machine Tito D. Kesumo Siregar (13511018) 1 Program Studi Teknik Informatika Sekolah Teknik Elektro dan Informatika Institut Teknologi Bandung, Jl. Ganesha 10 Bandung 40132,

### (p 300) Theorem 7.27 SAT is in P iff P=NP

pp. 292-311. The Class NP-Complete (Sec. 7.4) P = {L L decidable in poly time} NP = {L L verifiable in poly time} Certainly all P is in NP Unknown if NP is bigger than P (p. 299) NP-Complete = subset of

### Special Section: Building Your Own Compiler

cshtp6_19_datastructures_compiler.fm Page 1 Tuesday, February 14, 2017 10:31 AM 1 Chapter 19 Special Section: Building Your Own Compiler In Exercises8.31 8.33, we introduced Simpletron Machine Language

### Divisibility Rules and Their Explanations

Divisibility Rules and Their Explanations Increase Your Number Sense These divisibility rules apply to determining the divisibility of a positive integer (1, 2, 3, ) by another positive integer or 0 (although

### Discrete Optimization. Lecture Notes 2

Discrete Optimization. Lecture Notes 2 Disjunctive Constraints Defining variables and formulating linear constraints can be straightforward or more sophisticated, depending on the problem structure. The

### Parameterized Complexity of Independence and Domination on Geometric Graphs

Parameterized Complexity of Independence and Domination on Geometric Graphs Dániel Marx Institut für Informatik, Humboldt-Universität zu Berlin, Unter den Linden 6, 10099 Berlin, Germany. dmarx@informatik.hu-berlin.de

### Lecture 5: Suffix Trees

Longest Common Substring Problem Lecture 5: Suffix Trees Given a text T = GGAGCTTAGAACT and a string P = ATTCGCTTAGCCTA, how do we find the longest common substring between them? Here the longest common

### CMSC 336: Type Systems for Programming Languages Lecture 4: Programming in the Lambda Calculus Acar & Ahmed 22 January 2008.

CMSC 336: Type Systems for Programming Languages Lecture 4: Programming in the Lambda Calculus Acar & Ahmed 22 January 2008 Contents 1 Announcements 1 2 Solution to the Eercise 1 3 Introduction 1 4 Multiple

### 9.1 Cook-Levin Theorem

CS787: Advanced Algorithms Scribe: Shijin Kong and David Malec Lecturer: Shuchi Chawla Topic: NP-Completeness, Approximation Algorithms Date: 10/1/2007 As we ve already seen in the preceding lecture, two

### Stanford University Computer Science Department Solved CS347 Spring 2001 Mid-term.

Stanford University Computer Science Department Solved CS347 Spring 2001 Mid-term. Question 1: (4 points) Shown below is a portion of the positional index in the format term: doc1: position1,position2

### Longest Common Subsequence, Knapsack, Independent Set Scribe: Wilbur Yang (2016), Mary Wootters (2017) Date: November 6, 2017

CS161 Lecture 13 Longest Common Subsequence, Knapsack, Independent Set Scribe: Wilbur Yang (2016), Mary Wootters (2017) Date: November 6, 2017 1 Overview Last lecture, we talked about dynamic programming

### If Statements, For Loops, Functions

Fundamentals of Programming If Statements, For Loops, Functions Table of Contents Hello World Types of Variables Integers and Floats String Boolean Relational Operators Lists Conditionals If and Else Statements

### 6. Hoare Logic and Weakest Preconditions

6. Hoare Logic and Weakest Preconditions Program Verification ETH Zurich, Spring Semester 07 Alexander J. Summers 30 Program Correctness There are many notions of correctness properties for a given program

### CIS 500 Software Foundations Midterm I

CIS 500 Software Foundations Midterm I October 11, 2006 Name: Student ID: Email: Status: Section: registered for the course not registered: sitting in to improve a previous grade not registered: just taking

### Computing intersections in a set of line segments: the Bentley-Ottmann algorithm

Computing intersections in a set of line segments: the Bentley-Ottmann algorithm Michiel Smid October 14, 2003 1 Introduction In these notes, we introduce a powerful technique for solving geometric problems.

### 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

### 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

### Context Free Languages and Pushdown Automata

Context Free Languages and Pushdown Automata COMP2600 Formal Methods for Software Engineering Ranald Clouston Australian National University Semester 2, 2013 COMP 2600 Context Free Languages and Pushdown

### 1 Achieving IND-CPA security

ISA 562: Information Security, Theory and Practice Lecture 2 1 Achieving IND-CPA security 1.1 Pseudorandom numbers, and stateful encryption As we saw last time, the OTP is perfectly secure, but it forces

### 1 Computer arithmetic with unsigned integers

1 Computer arithmetic with unsigned integers All numbers are w-bit unsigned integers unless otherwise noted. A w-bit unsigned integer x can be written out in binary as x x x w 2...x 2 x 1 x 0, where x

### (Refer Slide Time 3:31)

Digital Circuits and Systems Prof. S. Srinivasan Department of Electrical Engineering Indian Institute of Technology Madras Lecture - 5 Logic Simplification In the last lecture we talked about logic functions

### Foundations, Reasoning About Algorithms, and Design By Contract CMPSC 122

Foundations, Reasoning About Algorithms, and Design By Contract CMPSC 122 I. Logic 101 In logic, a statement or proposition is a sentence that can either be true or false. A predicate is a sentence in

### Chapter 13. The ISA of a simplified DLX Why use abstractions?

Chapter 13 The ISA of a simplified DLX In this chapter we describe a specification of a simple microprocessor called the simplified DLX. The specification is called an instruction set architecture (ISA).

### Implementation of a Sudoku Solver Using Reduction to SAT

Implementation of a Sudoku Solver Using Reduction to SAT For this project you will develop a Sudoku solver that receives an input puzzle and computes a solution, if one exists. Your solver will: read an

### Complexity Theory. Compiled By : Hari Prasad Pokhrel Page 1 of 20. ioenotes.edu.np

Chapter 1: Introduction Introduction Purpose of the Theory of Computation: Develop formal mathematical models of computation that reflect real-world computers. Nowadays, the Theory of Computation can be

### CSC 373: Algorithm Design and Analysis Lecture 4

CSC 373: Algorithm Design and Analysis Lecture 4 Allan Borodin January 14, 2013 1 / 16 Lecture 4: Outline (for this lecture and next lecture) Some concluding comments on optimality of EST Greedy Interval

### Lattice Tutorial Version 1.0

Lattice Tutorial Version 1.0 Nenad Jovanovic Secure Systems Lab www.seclab.tuwien.ac.at enji@infosys.tuwien.ac.at November 3, 2005 1 Introduction This tutorial gives an introduction to a number of concepts

### And Parallelism. Parallelism in Prolog. OR Parallelism

Parallelism in Prolog And Parallelism One reason that Prolog is of interest to computer scientists is that its search mechanism lends itself to parallel evaluation. In fact, it supports two different kinds

### Module 2 Congruence Arithmetic pages 39 54

Module 2 Congruence Arithmetic pages 9 5 Here are some excellent websites that can help you on this topic: http://mathcentral.uregina.ca/qq/database/qq.09.98/kupper1.html http://nrich.maths.org/public.viewer.php?obj_id=50

### CSE Qualifying Exam, Spring February 2, 2008

CSE Qualifying Exam, Spring 2008 February 2, 2008 Architecture 1. You are building a system around a processor with in-order execution that runs at 1.1 GHz and has a CPI of 0.7 excluding memory accesses.

### Abstract Thinking, Intro to the Theory of Computation. SC/COSC Lecture Notes

Abstract Thinking, Intro to the Theory of Computation SC/COSC 2 3. Lecture Notes Jeff Edmonds Winter 99-, Version.2 Contents Preface 2 2 Computational Problems and Models of Computation 5 2. History of

### 4 Dynamic Programming

4 Dynamic Programming Dynamic Programming is a form of recursion. In Computer Science, you have probably heard the tradeoff between Time and Space. There is a trade off between the space complexity and

### 1 Definition of Reduction

1 Definition of Reduction Problem A is reducible, or more technically Turing reducible, to problem B, denoted A B if there a main program M to solve problem A that lacks only a procedure to solve problem

### What is a Graphon? Daniel Glasscock, June 2013

What is a Graphon? Daniel Glasscock, June 2013 These notes complement a talk given for the What is...? seminar at the Ohio State University. The block images in this PDF should be sharp; if they appear

### 15-122: Principles of Imperative Computation, Fall 2015

15-122 Programming 5 Page 1 of 10 15-122: Principles of Imperative Computation, Fall 2015 Homework 5 Programming: Clac Due: Thursday, October 15, 2015 by 22:00 In this assignment, you will implement a

### Technische Universität München Zentrum Mathematik

Question 1. Incidence matrix with gaps Technische Universität München Zentrum Mathematik Prof. Dr. Dr. Jürgen Richter-Gebert, Bernhard Werner Projective Geometry SS 2016 www-m10.ma.tum.de/projektivegeometriess16

### Decision Procedures in the Theory of Bit-Vectors

Decision Procedures in the Theory of Bit-Vectors Sukanya Basu Guided by: Prof. Supratik Chakraborty Department of Computer Science and Engineering, Indian Institute of Technology, Bombay May 1, 2010 Sukanya

### In this chapter you ll learn:

Much that I bound, I could not free; Much that I freed returned to me. Lee Wilson Dodd Will you walk a little faster? said a whiting to a snail, There s a porpoise close behind us, and he s treading on

### 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.

### CIS 194: Homework 6. Due Monday, February 25. Fibonacci numbers

CIS 194: Homework 6 Due Monday, February 25 Files you should submit: Fibonacci.hs This week we learned about Haskell s lazy evaluation. This homework assignment will focus on one particular consequence

### An interesting related problem is Buffon s Needle which was first proposed in the mid-1700 s.

Using Monte Carlo to Estimate π using Buffon s Needle Problem An interesting related problem is Buffon s Needle which was first proposed in the mid-1700 s. Here s the problem (in a simplified form). Suppose

### Statistics Case Study 2000 M. J. Clancy and M. C. Linn

Statistics Case Study 2000 M. J. Clancy and M. C. Linn Problem Write and test functions to compute the following statistics for a nonempty list of numeric values: The mean, or average value, is computed

### 0.1 Welcome. 0.2 Insertion sort. Jessica Su (some portions copied from CLRS)

0.1 Welcome http://cs161.stanford.edu My contact info: Jessica Su, jtysu at stanford dot edu, office hours Monday 3-5 pm in Huang basement TA office hours: Monday, Tuesday, Wednesday 7-9 pm in Huang basement

### 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

### 6.001 Notes: Section 31.1

6.001 Notes: Section 31.1 Slide 31.1.1 In previous lectures we have seen a number of important themes, which relate to designing code for complex systems. One was the idea of proof by induction, meaning

### Type Inference: Constraint Generation

Type Inference: Constraint Generation sk and dbtucker 2002-11-11 1 Inferring Types We ve seen the value of having explicit polymorphism in our language it lets us write programs that work on may different

### CS 360: Programming Languages Lecture 12: More Haskell

CS 360: Programming Languages Lecture 12: More Haskell Geoffrey Mainland Drexel University Adapted from Brent Yorgey s course Introduction to Haskell. Section 1 Administrivia Administrivia Homework 5 due

### 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