Nikos Fertakis

SICP Solutions: Section 2.2.1

2018-03-09T18:06:52+00:00

Section 2.2 - Hierarchical Data and the Closure Property

Section 2.2.1 - Representing Sequences

Exercise 2.17

(define (last-pair items)
    (if (null? (cdr items))
        items
        (last-pair (cdr items))))

Exercise 2.18

This is the iterative version:

(define (reverse items)
    (define (reverse-iter i l)
      (if (null? i)
          l
          (reverse-iter (cdr i) (cons (car i) l))))
    (reverse-iter items nil))

We can use append to create a recursive version:

(define (reverse items)
    (if (null? items)
        nil
        (append (reverse (cdr items)) (list (car items)))))

But this will be more expensive because append will iterate over each subset.

Exercise 2.19

The three procedures are really simple actually, just renaming the list-operating procedures.

(define (first-denomination coin-values)
  (car coin-values))

(define (except-first-denomination coin-values)
  (cdr coin-values))

(define (no-more? coin-values)
  (null? coin-values))

The order of list coin-values does not affect the answer produced by cc. This is because the procedure is not based on any assumption regarding the order of the elements.

Exercise 2.20

(define (same-parity . i)
    (define (iter-parity f l)
      (cond ((null? l) l)
            ((f (car l)) (cons (car l) (iter-parity f (cdr l))))
            (else (iter-parity f (cdr l)))))
    (cond ((null? i) nil)
          ((even? (car i)) (iter-parity even? i))
          ((odd? (car i)) (iter-parity odd? i))))

Exercise 2.21

(define (square-list items)
  (if (null? items)
      nil
      (cons (* (car items) (car items))
            (square-list (cdr items)))))

(define (square-list items)
  (map (lambda (x) (* x x)) items))

Exercise 2.22

Louis’ solution is essentially how we implemented reverse for exercise 2.18. Each iteration creates something like (cons 9 (cons 4 (cons 1 nil))), which is exactly how lists are implemented.

Unfortunately the second solution is no good either, because it is the inverse of how lists are implemented, and results into something like (cons (cons (cons nil 1) 4) 9). The order is correct, but this isn’t how Scheme structures lists from cons cells.

Exercise 2.23

(define (for-each proc items)
  (cond ((null? items) nil)
        (else (proc (car items))
              (my-for-each proc (cdr items)))))

SICP Solutions: Sections 2.1.3 and 2.1.4

2018-03-08T19:24:38+00:00

Section 2.1.3 - What Is Meant by Data?

Exercise 2.4

As the writers tell us, we can use the substitution model to verify that this works:

(car (cons x y))
(car (lambda (m) (m x y)))
((lambda (m) (m x y)) (lambda (p q) p))
((lambda (p q) p) x y)

So it essentially creates an anonymous procedure that accepts two arguments and returns the first. This means that we can implement cdr as:

(define (cdr z)
  (z (lambda (p q) q))

Exercise 2.5

We create a helper procedure contains and use it to implement both car and cdr:

(define (cons a b)
  (* (expt 2 a) (expt 3 b)))

(define (car z)
  (contains z 2))

(define (cdr z)
  (contains z 3))

(define (contains z n)
  (define (iter a i)
    (if (> (remainder a n) 0)
        i
        (iter (/ a n) (inc i))))
  (iter z 0))

Exercise 2.6

We will first use substitution to evaluate (add-1 zero) as the authors advise:

(add-1 zero)
(add-1 (lambda (f) (lambda (x) x)))
(lambda (f) (lambda (x) (f ((lambda (f) (lambda (x) x)) f) x)))
(lambda (f) (lambda (x) (f ((lambda (x) x) x))))
(lambda (f) (lambda (x) (f x)))

So this means that zero applies zero times its argument procedure f. Each time we add 1 though, we apply the argument procedure one more time. Essentially the Church numeral is the function itself, composed $n$ times. So this means that we can define one as:

(define one (lambda (f) (lambda (x) (f x))))

and two as:

(define two (lambda (f) (lambda (x) (f (f x)))))

We can then define addition as applying the composition $m + n$ times:

(define (plus m n)
    (lambda (f) (lambda (x) ((m f) ((n f) x)))))

We get our hint for the above from the way add-1 is implemented. Observe the (f ((n f) x)) part. What it essentially does is apply f once (add-1, remember?) to the result of passing consecutively f and x to the supplied function. In the case of zero, the result is x. In the case of one the result would be:

(f ((n f) x))
(f (((lambda (f) (lambda (x) (f x))) f) x))
(f ((lambda (x) (f x)) x))
(f (f x))

and so on and so forth.

Section 2.1.4 - Extended Exercise: Interval Arithmetic

Exercise 2.7

The selectors are simple to implement:

(define (lower-bound interval) (car interval))

(define (upper-bound interval) (cdr interval))

Exercise 2.8

The ordering will not change here:

(define (sub-interval x y)
   (make-interval (- (lower-bound x) (lower-bound y))
                  (- (upper-bound x) (upper-bound y))))

Exercise 2.9

Assume we have intervals $x$ and $y$. Assume also we prefix by $\mathrm{lb-}$ and $\mathrm{ub-}$ the lower and upper bound respectively. The width of the sum $x + y$ will be:

\[\begin{align*} \mathrm{width}(x + y) &= \mathrm{width}([\mathrm{lb-}x + \mathrm{lb-}y, \mathrm{ub-}x + \mathrm{ub-}y])\\ &= \frac{\mathrm{ub-}x + \mathrm{ub-}y - \mathrm{lb-}x - \mathrm{lb-}y}{2}\\ &= \frac{\mathrm{ub-}x - \mathrm{lb-}x}{2} + \frac{\mathrm{ub-}y - \mathrm{lb-}y}{2}\\ &= \mathrm{width}(x) + \mathrm{width}(y) \end{align*}\]

So the width of the sum (and similarly, the difference) of two intervals is a function only of the widths of the intevals being added.

Consider multiplication. Assume we have two intervals $a = (1, 3)$ and $b = (-3, -1)$. Their widths are $\mathrm{width}(a) = 1$ and $\mathrm{width}(b) = 1$. However, their multiplication yields the interval $a \times b = (-9, -1)$ and $\mathrm{width}(a \times b) = 4$. Now if instead of $b$ we use an other interval of width 1, e.g. $d = (5, 7)$ we would have $a \times d = (5, 21)$ and $\mathrm{width}(a \times c) = 8$. So width is not a function only of the widths of the intervals beeing multiplied. Division is exactly similar.

Exercise 2.10

(define (div-interval x y)
  (if (and (<= (lower-bound y) 0) (>= (upper-bound y) 0))
      (error "Cannot divide by interval that spans zero")
      (mul-interval x
                    (make-interval (/ 1.0 (upper-bound y))
                                   (/ 1.0 (lower-bound y))))))

Exercise 2.11

In my mind this is one case where the programmer has to choose between optimization and readable code. So, if you’re starving for resources then by all means, do this.

Each interval can have its numbers both negative, one negative and one positive, or both positive. Hence three times three are the nine cases we need to examine. In each case but the one where both intervals span zero, we do not need to compare anything to arrive at the solution. Finally, in the case where both intervals span zero, we can at least use less arguments in |min| and |max| by observing that each time only two numbers will be positive and two will be negative. Here goes:

(define (mul-interval x y)
  (let ((lbx (lower-bound x))
        (lby (lower-bound y))
        (ubx (upper-bound x))
        (uby (upper-bound y)))
    (cond ((and (> lbx 0) (> lby 0) (> ubx 0) (> uby 0))
           ;; 1) all positive
           (make-interval (* lbx lby) (* ubx uby)))
          ((and (< lbx 0) (< lby 0) (< ubx 0) (< uby 0))
           ;; 2) all negative
           (make-interval (* ubx uby) (* lbx lby)))
          ((and (< lbx 0) (> lby 0) (< ubx 0) (> uby 0))
           ;; 3) x all negative, y all positive
           (make-interval (* lbx uby) (* ubx lby)))
          ((and (> lbx 0) (< lby 0) (> ubx 0) (< uby 0))
           ;; 4) x all positive, y all negative
           (make-interval (* ubx lby) (* lbx uby)))
          ((and (> lbx 0) (< lby 0) (> ubx 0) (> uby 0))
           ;; 5) only lower bound of y negative
           (make-interval (* ubx lby) (* ubx uby)))
          ((and (< lbx 0) (> lby 0) (> ubx 0) (> uby 0))
           ;; 6) only lower bound of x negative
           (make-interval (* lbx uby) (* ubx uby)))
          ((and (< lbx 0) (< lby 0) (< ubx 0) (> uby 0))
           ;; 7) only upper bound of y positive
           (make-interval (* lbx uby) (* lbx lby)))
          ((and (< lbx 0) (< lby 0) (> ubx 0) (< uby 0))
           ;; 8) only upper bound of x positive
           (make-interval (* ubx lby) (* lbx lby)))
          ((and (< lbx 0) (< lby 0) (> ubx 0) (> uby 0))
           ;; 9) lower bounds negative, upper bounds positive
           (let ((neg1 (* lbx uby))
                 (neg2 (* ubx lby))
                 (pos1 (* lbx lby))
                 (pos2 (* ubx uby)))
             (make-interval (min neg1 neg2) (max pos1 pos2)))))))

Exercise 2.12

(define (make-center-percent c p)
  (let ((w (* p c)))
    (make-center-width c w)))

(define (percent i)
  (/ (width i) (center i)))

Exercise 2.13

Assume for intervals $a = (x, p_1)$ and $b = (y, p_2)$, where $p_i$ is the tolerance of the interval. We could rewrite $a$ in terms of bounds as:

\[\begin{align*} (x - p_1x, x + p_1)\\ (x(1 - p_1), x(1 + p_1)) \end{align*}\]

and similarly $b$ is $(y(1 - p_2), y(1 + p_2))$. Since all numbers are positive, the lower bound of their product will be the multiplication of their lower bounds and similarly for the upper bounds. Let’s work it out:

\[\begin{align*} (x(1 - p_1)y(1 - p_2), x(1 + p_1)y(1 + p_2))\\ (xy(1 - (p_1 + p_2 - p_1p_2)), xy(1 + (p_1 + p_2 + p_1p_2))) \end{align*}\]

Assuming small percentage tolerances, e.g. $10^{-2}$, their products will be very small (e.g. $10^{-4}$) and can be ignored. So we can assume that the approximate percentage tolerance of the product of two intervals would be $p_1 + p_2$.

Exercise 2.14

We can demonstrate that Lem is right by choosing intervals $R_1 = (1, 3)$ and $R_2 = (3, 6)$. We have:

> (par1 (make-interval 1 3) (make-interval 3 6))
=>
(mcons 0.3333333333333333 4.5)
;; and
> (par2 (make-interval 1 3) (make-interval 3 6))
=>
(mcons 0.75 2.0)

The issue here is that for algrebraic operations to work correctly (and thus for the two formulas to be equivalent), some equations such as $A/A = 1$ must be respected in our system. However, this is not true for intervals where width is of the same order of magnitude as the center value. As this changes, the value gets closer to one. Observe:

> (div-interval (make-interval 1 2)(make-interval 1 2))
=>
(mcons 0.5 2.0)
;; while
> (div-interval (make-interval 10000 10001)(make-interval 10000 10001))
=>
(mcons 0.9999000099990002 1.0001)

Using center-percent form, we can at least make sure that as the percentage is small, the operations get closer to correctness. Keep in mind, that we designed our system as a way to specify ranges of values, representing error (or tolerance). This value is supposed to be small. But even in real world scenarios such as the resistor of 6.8ohms with 10\% tolerance, our system does not work correctly:

> (div-interval (make-center-percent 6.8 0.1)(make-center-percent 6.8 0.1))
=>
(mcons 0.8181818181818182 1.222222222222222)

Exercises 2.15 & 2.16

Eva Lu Ator has a point. When a variable introduces uncertainty, our system by design transfers this uncertainty to any other variable with which it operates. If we push uncertainty to the edges (i.e. have as few operations as possible) then we should get better results.

Having said that, an interval-arithmetic package should provide general operations. One option would be to limit operations to variables with small error percentages. However, as we saw with the capacitors, a 10\% error is pretty common. This would render our package useless.

In order for our package to be generic enough so it can be useful, it should respect algebraic axioms such as $0a = 0$, $a/a = 1$, $a(b + c) = ab + ac$, etc. This is what makes the problem difficult.

SICP Solutions: Sections 2.1.1 and 2.1.2

2018-03-08T18:34:39+00:00

Chapter 2

Section 2.1 - Introduction to Data Abstraction

Section 2.1.1 - Example: Arithmetic Operations for Rational Numbers

Exercise 2.1

(define (make-rat n d)
  (let ((g (abs (gcd n d))))
    (cond ((or (and (< n 0) (< d 0))
               (and (> n 0) (< d 0)))
           (cons (/ (* -1 n) g) (/ (* -1 d) g)))
          (else (cons (/ n g) (/ d g))))))

Section 2.1.2 - Abstraction Barriers

Exercise 2.2

(define (make-segment start end) (cons start end))

(define (start-segment segment) (car segment))

(define (end-segment segment) (cdr segment))

(define (make-point x y) (cons x y))

(define (x-point point) (car point))

(define (y-point point) (cdr point))

(define (midpoint-segment segment)
  (make-point (average (x-point (start-segment segment))
                       (x-point (end-segment segment)))
              (average (y-point (start-segment segment))
                       (y-point (end-segment segment)))))

Exercise 2.3

We assume that the rectangle’s height and width are parallel to the x and y axes to simplify computations. We can define the procedures that calcualte area and perimeter as:

(define (rect-perim rect)
  (* 2 (+ (rect-width rect)
          (rect-height rect))))

(define (rect-area rect)
  (* (rect-width rect)
     (rect-height rect)))

Note that these depend only on the rect-width and rect-height selectors. Now we can create a rectangle representation based on its two opposing points:

(define (make-rect a c)
  (cons a c))

(define (rect-width rect)
  (abs (- (x-point (cdr rect))
          (x-point (car rect)))))

(define (rect-height rect)
  (abs (- (y-point (cdr rect))
          (y-point (car rect)))))

And another representation based on its diagonal. Note that we do not change any of the interfaces, just the underlying implementation:

(define (make-rect a c)
  (make-segment a c))

(define (rect-width rect)
  (abs (- (x-point (start-segment rect))
          (x-point (end-segment rect)))))

(define (rect-height rect)
  (abs (- (y-point (start-segment rect))
          (y-point (end-segment rect)))))

Year 2017 - A Retrospective

2018-01-03T09:16:56+00:00

I’ve been meaning to do a retrospective of sorts for the past few years, each time I postponed it until it made no sense any more. Here goes.

2017 was a rough year for me. On the upside:

I got to visit America for the first time.
I visited Barcelona for the excellent Curry On conference.
I read a whole bunch of books.
I listened to a whole lot of music and at last managed to do some music rehearsals once again.
I started the Athenian chapter of Papers We Love with a friend.
We co-organised the Athens Clojure meetup.
I played board games weekly.
I started excercising regurarly and became more strict about my bedtime. This has possibly been the most important thing I did for myself in 2017.
I started writing some posts here.

Best articles and blog posts I read

Thanks to pinboard I can easily look back on articles and blog posts I read in 2017.

The 50 Best Ambient Albums of All Time I’ve been using this list whenever I want something good to listen to while I work or study.
Book Review: Eichmann in Jerusalem by Scott Alexander. I don’t always like Alexander’s style, but his commentary here as well as the parts quoted from the book made me order it instantly.
How we structure our work and teams at Basecamp by Jason Fried. Fried clearly knows what he’s talking about, and I enjoy how he and DHH go against the normal SV ethos of working yourself to death. We tried both 6-week cycles and 4-day summertime weeks at work with (I believe) great success.
Reflecting On One Very, Very Strange Year At Uber by Susan Fowler. I don’t think I need to say much here. Before the Weinstein scandal broke out, we found out how terrible the culture at Uber was.
Recipe for a Great Programmer by Nathan Martz. Martz’s advice is concise and to the point.
The world beyond batch: Streaming 101 by Tyler Akidau. Whenever someone asks me about streaming systems, I recommend they read this blogpost and its followup. Akidau first defines the problem, then the old solutions, and finally gives a very nice description of how the Dataflow model works.
So You Want to Be a Wizard by Julia Evans. In the same as Nathan Martz’s post, Julia Evans gives a really inspiring description of what it takes to be a truly great software engineer.
Reversing the Technical Interview by Kyle Kingsbury. The amazing Kyle Kingsbury (of Jepsen fame) destroys the whole concept of a technical whiteboard interview with this hilarious post.
Once We Listened to the Beatles. Now We Eat Beetles. by Tyler Cowen. I didn’t find the time to read Cowen’s book The Complacent Class, but this article gives the gist of his thinking. I think his arguments about complacency are relevant not only to America, but to the western world in general.
Inside the High Tech Hunt for a Missing Silicon Valley Legend by Steve Silberman. It’s now been more than 10 years since Jim Gray disappeared without trace. This is an old but really excellent article describing how the tech world mobilized in an effort to track him down. Gray’s contributions to computer science cannot be overstated, but this story would be amazing either way.
#define CTO by Greg Brockman. This blog post has really influenced my thought on how the engineering branch of a tech company should be structured.
When the Revolution Came for Amy Cuddy by Susan Dominus. I’ve spent part of the later half of 2017 thinking about experiments, validation, statistical significance, and repeatability. Then the New York Times published an article describing the crisis that has hit behavioral sciences the past few years. Not even Kahneman was immune.

Favorite non-technical books I read

I read 32 books in 2017, 5 more than in 2016. I hope that in 2018 I read more than 40.

The Beginning of Infinity: Explanations that Transform the World by David Deutsch. This was, by far, the most influential book I read all year. Deutsch discusses the philosophy of science, creativity, quantum physics, evolution, politics, and art, unified under his theory of optimism and fallibilism. Problems are inevitable, problems are soluble.
The Method: A Personal Account of the Tortures in Greece by Periclis Korovesis. A really important memoir of the brutality of the Greek military junta (1967 - 1974).
The Dream Machine: J.C.R. Licklider and the Revolution That Made Computing Personal by M. Mitchell Waldrop. A truly inspiring description of the history of the personal computer, starting from Turing and going all the way through MIT and ARPA to XEROX PARC and Apple. A shame it is not in print any more.
The Third Wedding by Costas Taktsis. A truly suffocating description of lower middle class families in Greece during the early 20th century. Possibly one of the greatest novels ever written in greek.
Outliers: The Story of Success by Malcolm Gladwell. While I do think that Gladwell tends to oversimplify things a bit so he can fit them under his theory, this is a book full of good stories, and Gladwell is one of the greatest storytellers alive.
High Output Management by Andy Grove. This small book helped me a lot on how to think about management, and how we tend to underestimate its importance.

Favorite technical books I almost read

I spent a good chunk of 2017 studying Structure and Interpretation of Computer Programs. Then I put it on pause to start reading Designing Data-Intensive Applications. Both have helped and influenced me massively, and I do look forward to finishing them in 2018.

Favorite music I listened to

Hüsker Dü - their discography. This was the soundtrack of my 2017.
The Pogues - Rum, Sodomy, and the Lash. This was the soundtrack of my summer.
LCD Soundsystem - American Dream. This was the soundtrack of my visit to NYC.
Lorde - Melodrama.
Kendrick Lamar - DAMN.
Kamasi Washington - Harmony of Difference.
Ex Eye - s/t.
Víkingur Ólafsson - Philip Glass: Piano Works.
Lots and lots of rembetika.

Favorite TV series I watched

Homicide: Life on the Street
Buffy the Vampire Slayer
You’re the Worst
Red Oaks
The Deuce
Seinfeld
Gilmore Girls

Favorite board games I played

Favorite podcasts I listened to

Conversations with Tyler
The Ezra Klein Show
EconTalk
Rationally Speaking
The Arsecast
Shut Up & Sit Down

Looking forward to in 2018

Playing more music. I have a couple projects (rembetika and garage punk - I know) underway, I hope they pan out.
Reading more books. History, software, philosophy, novels, poetry, the backlog is huge!
Organizing monthly Papers We Love meetups.
Learning a new programming language. Haskell probably. Or OCaml?
Playing board games. I swear this is what keeps me sane, at times at least.
Learning some chess.
Open sourcing a bunch of code.
Writing more blog posts.
Watching the final two seasons of the Leftovers.
Travelling a bit more. In Greece, Europe, and hopefuly America.

SICP Solutions: Section 1.3.4

2017-08-28T16:32:00+00:00

Section 1.3.4 - Procedures as Returned Values

Exercise 1.40

cubic will create and return procedures that should be solved using Newton’s method:

(define (cubic a b c)
  (lambda (x) (+ (cube x)
                 (* a (square x))
                 (* b x)
                 c)))

Exercise 1.41

Defining double is quite simple:

(define (double f)
  (lambda (x) (f (f x))))

All the fun comes when trying to calculate something like ((double (double double)) inc).

(double double) essentially returns a procedure that applies the original prodecure 4 times. Therefore (double (double double)) will apply what it receives receives $4 * 4 = 16$ times. So if we start from $5$:

> (((double (double double)) inc) 5)
; => 21

Exercise 1.42

(define (compose f g)
  (lambda (x) (f (g x))))

Exercise 1.43

(define (repeated f n)
  (if (= n 1)
      f
      (repeated (compose f f) (dec n))))

Exercise 1.44

Using the definition of dx from above:

(define (smooth f)
  (lambda (x) (/ (+ (f (- x dx)) (f x) (f (+ x dx)))
                 3.0)))

(define (n-fold-smoothed f n)
  (repeated (smooth f) n))

Exercise 1.45

So the general function would be something like:

(define (root-n x n damps)
  (fixed-point-of-transform
    (lambda (y) (/ x (expt y (- n 1))))
    (repeated average-damp damps)
    1.0))

The parameter damps controls the number of repeated average damps. Experimenting a bit showed that with 2 average damps we can calculate up to the 7th root. 3 average damps lets us calculate up to the 31st root. Using 4 damps we were able to calculate at least up to the 512th root with no problems.

Exercise 1.46

We first define iterative-improve. Note that it returns an anonymous procedure that itself creates and executes a recursive procedure:

(define (iterative-improve good-enough? improve)
  (lambda (guess)
    (define (iter last-guess)
      (if (good-enough? last-guess)
        last-guess
        (iter (improve last-guess))))
    (iter guess)))

Now we can implement sqrt and fixed-point:

(define (sqrt x)
  ((iterative-improve
    (lambda (guess)
      (< (abs (- (square guess) x)) 0.001))
    (lambda (guess)
      (average guess (/ x guess))))
   1.0))

(define (fixed-point f first-guess)
  ((iterative-improve
    (lambda (guess)
      (< (abs (- guess (f guess))) tolerance))
    (lambda (guess) (f guess)))
   first-guess))

This concludes Chapter 1. Onwards to Chapter 2 then!

SICP Solutions: Sections 1.3.2 and 1.3.3

2017-08-26T07:42:00+00:00

Section 1.3.2 - Constructing Procedures Using Lambda

Exercise 1.34

It will blow up trying to use the number 2 in the function position. Observe:

(f f)
(f 2)
(2 2)

Section 1.3.3 - Procedures as General Methods

Exercise 1.35

We already know that:

\[\phi^2 = \phi + 1\]

and dividing both parts by $2$:

\[\phi = 1 + \frac{1}{\phi}\]

So:

(define (phi x)
  (fixed-point (lambda (y) (+ 1 (/ 1 y))) x))

Exercise 1.36

Here is fixed-point now:

(define (fixed-point f first-guess)
  (define (close-enough? v1 v2)
    (< (abs (- v1 v2)) tolerance))
  (define (try guess)
    (report-approx guess)
    (let ((next (f guess)))
      (if (close-enough? guess next)
          next
          (try next))))
  (try first-guess))

(define (report-approx a)
  (display " *** ")
  (display a)
  (newline))

And we can define $x^x$ as:

(define (x-on-x first-guess)
  (fixed-point (lambda (x) (/ (log 1000) (log x))) first-guess))

(define (x-on-x-dumping first-guess)
  (fixed-point (lambda (x) (+ (/ (log 1000) (* 2 (log x)))
                                (/ x 2))) first-guess))

Now we can call both:

(x-on-x 1.1)
=>
*** 1.1
*** 72.47657378429035
*** 1.6127318474109593
*** 14.45350138636525
*** 2.5862669415385087
*** 7.269672273367045
*** 3.4822383620848467
*** 5.536500810236703
*** 4.036406406288111
*** 4.95053682041456
*** 4.318707390180805
*** 4.721778787145103
*** 4.450341068884912
*** 4.626821434106115
*** 4.509360945293209
*** 4.586349500915509
*** 4.535372639594589
*** 4.568901484845316
*** 4.546751100777536
*** 4.561341971741742
*** 4.551712230641226
*** 4.558059671677587
*** 4.55387226495538
*** 4.556633177654167
*** 4.554812144696459
*** 4.556012967736543
*** 4.555220997683307
*** 4.555743265552239
*** 4.555398830243649
*** 4.555625974816275
*** 4.555476175432173
*** 4.555574964557791
*** 4.555509814636753
*** 4.555552779647764
*** 4.555524444961165
*** 4.555543131130589
*** 4.555530807938518
4.555538934848503

34 steps. Now with dampening:

(x-on-x-dumping 1.1)
=>
*** 1.1
*** 36.78828689214517
*** 19.352175531882512
*** 10.84183367957568
*** 6.870048352141772
*** 5.227224961967156
*** 4.701960195159289
*** 4.582196773201124
*** 4.560134229703681
*** 4.5563204194309606
*** 4.555669361784037
*** 4.555558462975639
*** 4.55553957996306
4.555536364911781

13 steps. Dampening helps a lot in this case.

Exercise 1.37

We can define cont-frac as such:

(define (cont-frac n d k)
  (cont-frac-iter n d k 1))

(define (cont-frac-iter n d k i)
  (if (= i k)
      (/ (n i) (d i))
      (/ (n i)
         (+ (d i) (cont-frac-iter n d k (inc i))))))

It takes 11 iterations to reach four-digit accuracy:

(cont-frac (lambda (i) 1.0) (lambda (i) 1.0) 11)
=>
0.6180555555555556

This was of course a recursive process. We can write an iterative now:

(define (cont-frac n d k)
  (cont-frac-iter n d k k 0))

(define (cont-frac-iter n d k i)
  (if (= i 0)
    res
    (let ((next (/ (n i) (+ (d i) res))))
      (cont-frac-iter n d k (dec i) next))))

Note that the iterative solution has to calculate the result from the ground up, starting from $k$ all the way up to $1$.

Exercise 1.38

We need to define d:

(define (d i)
  (if (= (remainder (+ i 1) 3) 0)
    (* (/ (+ i 1) 3) 2)
     1))

(define (euler k)
  (+ 2 (cont-frac (lambda (i) 1.0) d k)))

For $k = 8$ the approximation is accurate to 4 decimal places.

Exercise 1.39

Again, using cont-frac:

(define (tan-cf x k)
  (cont-frac
   (lambda (i) (if (= i 1) x (- (* x x))))
   (lambda (i) (- (* 2 i) 1))
   k))

SICP Solutions: Section 1.3.1

2017-06-17T08:15:15+00:00

Section 1.3 - Formulating Abstractions With Higer-Order Procedures

Section 1.3.1 - Procedures as Arguments

Exercise 1.29

Here is the implementation of Simpson’s Rule. Note that we defined h as a procedure with no arguments since we haven’t learned about let yet.

(define (integral-simon f a b n)
  (define (h) (/ (- b a) n))
  (define (y k) (* (f (+ a (* k (h))))
                   (cond ((or (= k 0) (= k n)) 1)
                         ((even? k) 2)
                         (else 4))))
  (* (sum y 0 inc n)
     (/ (h) 3.0)))

And running it we can see that it converges faster than the previous solution:

> (integral-simon cube 0.0 1 100)
0.24999999999999992
> (integral-simon cube 0.0 1 1000)
0.2500000000000003

Exercise 1.30

(define (sum-iter term a next b)
  (define (iter a result)
    (if (> a b)
        result
        (iter (next a) (+ result (term a)))))
  (iter a 0))

Exercise 1.31

product is very similar to sum:

(define (inc n) (+ 1 n))

(define (product term a next b)
  (if (> a b)
      1
      (* (term a)
         (product term (next a) next b))))

;; We can use it:

(define (factorial n)
  (product identity 1 inc n))

(define (wallis n)
  (define (term a) (if (even? a)
                       (/ (+ a 2) (+ a 1))
                       (/ (+ a 1) (+ a 2))))
  (* (product term 1.0 inc n) 4))

;; Let's try
(wallis 100)

And we can write the iterative version:

(define (product term a next b)
  (define (iter a result)
    (if (> a b)
        result
        (iter (next a) (* result (term a)))))
  (iter a 1))

Exercise 1.32

This is a recursive version of accumulate:

(define (accumulate combiner null-value term a next b)
  (if (> a b)
      null-value
      (combiner (term a)
                (accumulate combiner null-value term (next a) next b))))

We can use it to build sum and product:

(define (sum term a next b)
  (accumulate + 0 term a next b))

(define (product term a next b)
  (accumulate * 1 term a next b))

And we can write the iterative version:

(define (accumulate combiner null-value term a next b)
  (define (iter a result)
    (if (> a b)
        result
        (iter (next a) (combiner result (term a)))))
  (iter a null-value))

Exercise 1.33

We just skip the combiner if the predicate is not satisfied:

(define (filtered-accumulate f combiner null-value term a next b)
  (if (> a b)
      null-value
      (if (f a)
          (combiner
           (term a)
           (filtered-accumulate f combiner null-value term (next a) next b))
          (filtered-accumulate f combiner null-value term (next a) next b))))

Then we can define the procedure that generates the sum of squares of primes between a and b, and the procedure that generates the product of relative primes less than n:

(define (sum-square-primes a b)
  (filtered-accumulate prime? + 0 square a inc b))

(define (product-relative-primes n)
  (define (relative-prime? a) (= (gcd a n) 1))
  (filtered-accumulate relative-prime? * 1 identity 1 inc (- n 1)))

SICP Solutions: Sections 1.2.3 and 1.2.4

2017-06-16T14:23:35+00:00

Section 1.2.3 - Orders of Growth

Exercise 1.14

The tree is big :)

The recursive process reaches maximum depth when the denomination is a penny, for example (cc 11 1) will be $11$. This means that the growth of space will be $\Theta(n)$, where $n$ is the amount we want to change.

For each denomination sub-tree, the maximum steps we will need to calculate is where the only remaining denomination is the penny, and the steps required will be exactly $n$. Since we have $5$ denominations, the time complexity will be $O(n^5)$.

Exercise 1.15

a.

The procedure p will be applied each time angle is greater than $0.1$. Between iterations, angle will be divided by $3$. This means that with a starting angle of $12.15$ we will have p applied for $12.15, 4.16, 1.38, 0.46$ and finally for $0.15$. So p will be applied $5$ times.

b.

The space required will be growing on the order of $O(\log_3(n))$, because each step will require to remember its parent to return to. Similarly, the time required will be $O(\log_3(n))$ as well.

Section 1.2.4 - Exponentiation

Exercise 1.16

Using the definition of even? from before:

(define (fast-expr b n)
  (fast-expr-iter b n 1))

(define (fast-expr-iter b n a)
  (cond ((= n 1) a)
        ((even? n) (fast-expr-iter b
                                   (/ n 2)
                                   (* a (* b b))))
        (else (fast-expr-iter b (- n 1) (* a b)))))

(fast-expr 2 3)

Exercise 1.17

A recursive process:

(define (double a) (* 2 a))

(define (halve a) (/ a 2))

(define (fast-multi a b)
  (cond ((= a 1) b)
        ((even? a) (fast-multi (halve a) (double b)))
        (else (+ b (fast-multi (- a 1) b)))))

(fast-multi 5 8)

Exercise 1.18

Similarly to exercise 1.16, we will use a variable as accumulator:

(define (double a) (* 2 a))

(define (halve a) (/ a 2))

(define (fast-mult a b)
  (fast-mult-iter a b 0))

(define (fast-mult-iter a b n)
  (cond ((= a 0) n)
        ((even? a) (fast-mult-iter (halve a) (double b) n))
        (else (fast-mult-iter (- a 1) b (+ b n)))))

(fast-multi 5 8)

Exercise 1.19

First, we need to apply $T$ twice, to compute $T^2$. We start with:

\[\begin{align*} a &\leftarrow bq + aq + ap\\ b &\leftarrow bp + aq \end{align*}\]

Which will then become:

\[\begin{align*} a &\leftarrow (bp + aq)q + (bp + aq + ap)q + (bq + aq + ap)p\\ b &\leftarrow (bp + aq)p + (bp + aq + ap)q \end{align*}\]

Let’s expand the first one:

\[\begin{align*} a &\leftarrow (bp + aq)q + (bp + aq + ap)q + (bq + aq + ap)p\\ &= bpq + aq^2 + bq^2 + aq^2 + apq + bpq + apq + ap^2 \\ &= b(2pq + q^2) + a(2pq + q^2) + a(q^2 + p^2) \end{align*}\]

And in the same manner the second one:

\[\begin{align*} b &\leftarrow (bp + aq)p + (bp + aq + ap)q\\ &= bp^2 + apq + bq^2 + aq^2 + apq\\ &= b(p^2 + q^2) + a(2pq + q^2) \end{align*}\]

So it turns out that we can name variables $p'$ and $q'$:

\[\begin{align*} p' &= p^2 + q^2\\ q' &= 2pq + q^2 \end{align*}\]

These values will essentially square $T$. So the logarithimic version of the Fibonacci procedure can be written as:

(define (square n) (* n n))

(define (fib n)
  (fib-iter 1 0 0 1 n))

(define (fib-iter a b p q count)
  (cond ((= count 0) b)
        ((even? count)
         (fib-iter a
                   b
                   (+ (square p) (square q))
                   (+ (* 2 p q) (square q))
                   (/ count 2)))
        (else (fib-iter (+ (* b q) (* a q) (* a p))
                        (+ (* b p) (* a q))
                        p
                        q
                        (- count 1)))))

(fib 9)

SICP Solutions: Sections 1.2.5 and 1.2.6

2017-06-16T14:23:35+00:00

Section 1.2.5 - Greatest Common Divisors

Exercise 1.20

The difference between applicative and normal order is that applicative first evaluates the arguments and then applies the procedure. In contrast, normal order first expands the procedure and then reduces it. Also note that if is a special form, where which (and whether) procedure is evaluated depends on the predicate.

Let’s first see the applicative order:

(gcd 206 40) ;; apply if, second branch produces
(gcd 40 (remainder 206 40)) ;; remember, we evaluate arguments first
(gcd 40 6)
(gcd 40 (remainder 40 6)) ;; 2nd time we need remainder
(gcd 6 4)
(gcd 4 (remainder 4 6)) ;; 3rd time
(gcd 4 2)
(gcd 2 (remainder 4 2)) ;; 4th time
(gcd 2 0) ;; the predicate is true
2

In the normal order, we first expand and then apply only as needed. So:

(gcd 206 40) ;; apply if, second branch produces
(gcd 40 (remainder 206 40)) ;; the if will be as follows
;; apply gcd
(if (= (remainder 206 40) 0) ;; this gets evaluated, so 1 call
    40
    (gcd (remainder 206 40)
         (remainder 40 (remainder 206 40))))
;; apply gcd
(if (= (remainder 40 (remainder 206 40)) 0) ;; 2 calls
    (remainder 206 40)
    (gcd (remainder 40 (remainder 206 40))
         (remainder
           (remainder 206 40
             (remainder 40 (remainder 206 40))))))
;; apply gcd
(if (= (rem (rem 206 40) (rem 40 (rem 206 40))) 0) ;; 4 calls
    (rem 40 (rem 206 40))
    (gcd (rem (rem 206 40) (rem 40 (rem 206 40)))
         (rem
           (rem 40 (rem 206 40))
           (rem (rem 206 40) (rem 40 (rem 206 40))))))
;; apply gcd
;; this time the predicate will be b from the previous
;; iteration which contains 7 calls to remainder but
;; evaluates to 0 so we evaluate a from the previous
;; iteration (4 calls to remainder) and we are done.

So in summary, the normal order will need: $1 + 2 + 4 + 7 + 4 = 18$ calls to remainder.

Section 1.2.6 - Example: Testing for Primality

Exercise 1.21

> (smallest-divisor 199)
199
> (smallest-divisor 1999)
1999
> (smallest-divisor 19999)
7

So while $199$ and $1999$ are primes, $19999$ is not.

Exercise 1.22

$\sqrt{10} = 3.17$. This means that we expect time to roughly triple between orders of magnitude. Our results are:

;; Greater than 1,000
;; 1009 *** 3
;; 1013 *** 2
;; 1019 *** 2
;; Greater than 10,000
;; 10007 *** 6
;; 10009 *** 6
;; 10037 *** 6
;; Greater than 100,000
;; 100003 *** 17
;; 100019 *** 18
;; 100043 *** 18
;; Greater than 1,000,000
;; 1000003 *** 59
;; 1000033 *** 59
;; 1000037 *** 59

The results roughly confirm our calculations. We wouldn’t expect exact results since the actual timing depends on a lot of things.

Exercise 1.23

(define (next n)
  (if (= n 2)
      3
      (+ n 2)))

;; 1009 *** 6
;; 1013 *** 6
;; 1019 *** 6
;; 10007 *** 9
;; 10009 *** 8
;; 10037 *** 8
;; 100003 *** 16
;; 100019 *** 15
;; 100043 *** 16
;; 1000003 *** 41
;; 1000033 *** 40
;; 1000037 *** 40

Essentially the steps taken by the algorithm will now be limited by $\sqrt{n}/2$. This means that $\sqrt{n}$ will still dominate the algorithm, but given a large-enough input the time will be roughly halved.

Exercise 1.24

;; 1009 *** 13
;; 1013 *** 13
;; 1019 *** 13
;; 10007 *** 15
;; 10009 *** 14
;; 10037 *** 14
;; 100003 *** 21
;; 100019 *** 16
;; 100043 *** 16
;; 1000003 *** 17
;; 1000033 *** 18
;; 1000037 *** 19

We would expect the time to test primes near $1,000,000$ to be roughly the triple of the time to test primes near $1,000$. We do not obseve even that kind of change, probably due to fast hardware, but we do observe that the runtime grows very slowly.

Exercise 1.25

While conceptually Alyssa is correct, in practice the call to fast-expt will result in dealing with big numbers, and trying to find their remainder. Our expmod method will always find the remainder of small numbers, multiply them together, find their remainder, etc. See footnote 46. Bear in mind also that primality checks are usually done for very large numbers.

The results are pretty grave in practice:

;; 1009 *** 92
;; 1013 *** 102
;; 1019 *** 83
;; 10007 *** 3071
;; 10009 *** 3192
;; 10037 *** 2880

Exercise 1.26

By rewriting the expmod procedure to use explicit multiplication, Louis has changed it into a tree recursive process from a linear one. This means that in each steps two subtrees will be created, and the amount of calls grow exponentially. So $2^{\log n} = n$.

Exercise 1.27

We create a procedure congruent? as such:

(define (congruent? n)
  (congruent-iter n 0))

(define (congruent-iter n a)
  (cond ((= a n) true)
        ((= (expmod a n n) a) (congruent-iter n (+ a 1)))
        (else false)))

Calling the procedure for the Carmichael numbers of footnote 47 (561, 1105, 1729, 2465, 2821 and 6601) we always get #t. The fast-prime? procedure would be fooled. However, we can use the prime? procedure to confirm that these numbers are not primes.

Exercise 1.28

First we create the function that performs the check and short-circuits the computation:

(define (miller-rabin-check a m)
  (if (and (not (= a 1))
           (not (= a (- m 1)))
           (= (remainder (square a) m) 1))
      0
      a))

We want to use the above before squaring the result of each iteration. Since we cannot store variables yet, what we can do is wrap the expmod call to itself inside a miller-rabin-check call. miller-rabin-check will get the result of the previous iteration as input, and check whether it is a non-trivial square root of 1. If it is, it will return 0, essentially short-circuting the result. If it is not, it will return the result, thus letting expmod continue as usual.

(define (miller-rabin-expmod base exp m)
  (cond ((= exp 0) 1)
        ((even? exp)
         (remainder
          (square
           (miller-rabin-check
            (miller-rabin-expmod base (/ exp 2) m) m)) m))
        (else
         (remainder (* base
          (miller-rabin-expmod base (- exp 1) m))
          m))))

Finally, we can run the check for half the size of the input to make sure we produce the correct answer:

(define (miller-rabin-test n)
  (define (try-it a)
    (= (miller-rabin-expmod a (- n 1) n) 1))
  (try-it (+ 1 (random (- n 1)))))

(define (miller-rabin-prime? n)
  (define (test-prime times)
    (cond ((<= times 0) true)
          ((miller-rabin-test n) (test-prime (- times 1)))
          (else false)))
  (test-prime (/ n 2)))

We can use both the prime numbers we found and the Carmichael numbers to confirm that our new procedure always produces the correct result and is not fooled.

SICP Solutions: Sections 1.2.1 and 1.2.2

2017-06-16T10:53:44+00:00

Section 1.2

Section 1.2.1

Exercise 1.9

First procedure:

(+ 4 5)
(inc (+ 3 5))
(inc (inc (+ 2 5)))
(inc (inc (inc (+ 1 5))))
(inc (inc (inc (inc (+ 0 5)))))
(inc (inc (inc (inc 5))))
(inc (inc (inc 6)))
(inc (inc 7))
(inc 8)
9

Second procedure:

(+ 4 5)
(+ 3 6)
(+ 2 7)
(+ 1 8
(+ 0 9)
9

The first process is a linear recursive process. The second process is a linear iterative process.

Hint: try to see whether calling itself is absolutely the last thing a procedure does.

Exercise 1.10

Expression (A 1 10):

(A 1 10)
(A 0
   (A 1 9))
(A 0
   (A 0
      (A 1 8
(A 0
   (A 0
      (A 0
         (A 1 7))))
(A 0
   (A 0
      (A 0
         (A 0
            (A 1 6)))))
(A 0
   (A 0
      (A 0
         (A 0
            (A 0
               (A 1 5))))))
(A 0
   (A 0
      (A 0
         (A 0
            (A 0
               (A 0
                  (A 1 4)))))))
(A 0
   (A 0
      (A 0
         (A 0
            (A 0
               (A 0
                  (A 0
                     (A 1 3))))))))
(A 0
   (A 0
      (A 0
         (A 0
            (A 0
               (A 0
                  (A 0
                     (A 0
                        (A 1 2)))))))))
(A 0
   (A 0
      (A 0
         (A 0
            (A 0
               (A 0
                  (A 0
                     (A 0
                        (A 0
                           (A 1 1))))))))))
(A 0
   (A 0
      (A 0
         (A 0
            (A 0
               (A 0
                  (A 0
                     (A 0
                        (A 0 2)))))))))
(A 0
   (A 0
      (A 0
         (A 0
            (A 0
               (A 0
                  (A 0
                     (A 0 4))))))))
 (A 0
    (A 0
       (A 0
          (A 0
             (A 0
                (A 0
                   (A 0 8)))))))
 (A 0
    (A 0
       (A 0
          (A 0
             (A 0
                (A 0 16))))))
(A 0
   (A 0
      (A 0
         (A 0
            (A 0 32)))))
(A 0
   (A 0
      (A 0
         (A 0 64))))
(A 0
   (A 0
      (A 0 128)))
(A 0
   (A 0 256))
(A 0 512)
1024

So (A 1 x) is $2^x$.

Expression (A 2 4) :

(A 2 4)
(A 1
   (A 2 3))
;; So this is 2^(A 2 3), let's see
(A 2 3)
(A 1
   (A 2 2))
;; So 2^(2^(A 2 2))
(A 2 2)
(A 1
   (A 2 1))
;; So 2^(2^(2^(A 2 1)))
(A 2 1)
2
;; So finally 2^(2^(2^2))
;; Or 2^(2^4)
;; Or 2^16
;; 65,636

So (A 2 x) is 2 to the power of 2, to the power of 2 .. x times.

Expression (A 3 3):

(A 3 3)
(A 2
   (A 3 2))
;; We know what (A 2 x) is, 2 to the power of 2 x times.
;; Let's see where (A 3 2) takes us:
(A 3 2)
(A 2
   (A 3 1))
(A 2 2)
;; Which is 2^2
;; and the starting expression is (A 2 4)
;; Which is exactly the same as before.

So again (A 3 3) equals $2^{16} = 65,636$.

(f n) computes $2n$.
(g n) computes $2^n$.
(h n) computes 2 to the power of 2, to the power of 2 .. x times.

Section 1.2.2

Exercise 1.11

Recursive process:

(define (f n)
  (if (< n 3)
      n
      (+ (f (- n 1))
         (* 2 (f (- n 2)))
         (* 3 (f (- n 3))))))

(f 4)

Iterative process:

(define (f n)
  (if (< n 3)
      n
      (f-iter 2 1 0 (- n 2))))

(define (f-iter a b c count)
  (if (= count 0)
      a
      (f-iter (+ a (* 2 b) (* 3 c)) a b (- count 1))))

(f 4)

Exercise 1.12

We define a procedure pascal that accepts a row and a column as arguments:

(define (pascal x y)
  (if (or (= y 0) (= x y))
      1
      (+ (pascal (- x 1) (- y 1))
         (pascal (- x 1) y))))

(pascal 3 2)

Exercise 1.13

First, the induction.

The base step, for $n = 0$:

\[\mathrm{Fib}(0) = (\phi^0 - \psi^0) / \sqrt{5} = 0 \textrm{, it holds.}\]

Assume it is true for $n$, we will prove that it is true for $n + 1$:

\[\begin{align*} \mathrm{Fib}(n+1) &= \frac{\phi^{n+1} - \psi^{n+1}}{\sqrt{5}}\\ \frac{\phi^{n+1} - \psi^{n+1}}{\sqrt{5}} &= \mathrm{Fib}(n) + \mathrm{Fib}(n - 1)\\ \frac{\phi^{n+1} - \psi^{n+1}}{\sqrt{5}} &= \frac{\phi^n - \psi^n}{\sqrt{5}} + \frac{\phi^{n-1} - \psi^{n-1}}{\sqrt{5}}\\ \phi^{n+1} - \psi^{n+1} &= \phi^n - \psi^n + \phi^{n-1} - \psi^{n-1}\\ \phi^{n-1}(\phi^2 - \phi - 1) &= \psi^{n-1}(\psi^2 - \psi - 1) \end{align*}\]

By definition, $\phi^2 = \phi + 1$. Notice that also $\psi^2 = \psi + 1$. This means that both sides of the equation are $0$, and the induction holds.

We have proven that

\[\begin{equation*} \mathrm{Fib}(n) = \frac{\phi^n - \psi^n}{\sqrt{5}} \end{equation*}\]

Now we need to prove that $\vert\frac{\psi^n}{\sqrt{5}}\vert < \frac{1}{2}$.

Notice that $\psi < \frac{1}{2}$, and hence $\vert\psi^{n+1}\vert < \vert\psi^n\vert, \forall n \in N$. Since $\vert\frac{\psi^0}{\sqrt{5}}\vert < \frac{1}{2}$, it holds for all the rest values of $n$.