Explication of Scheme code for permutations - scheme

Question

Here is a Scheme code to produce the permutations of a list of elements:
(define (remove x lst) (cond
((null? lst) '())
((= x (car lst)) (remove x (cdr lst)))
(else (cons (car lst) (remove x (cdr lst))))))
(define (permute lst) (cond
((= (length lst) 1) (list lst))
(else (apply append
(map (lambda (i)
(map (lambda (j) (cons i j))
(permute (remove i lst)))) lst)))))
I do understand each part of the code if we take the code apart, but what I can’t understand is how this all leads to generating the permutations?
Let’s say we take the list ‘(a b), how does it generate ‘(a b) and ‘(b a)?
We start by removing a from the list and b stays, but where is written that you now have to cons a to b? b is a single element, but in my interpretation of the code, b will also be removed and there is nothing left…

Answer 1

I would read the main part like this (in the order indicated by numbers)
(map (lambda (i) ;(1) for each i in...
(map (lambda (j) ;(3) for each j in...
(cons i j)) ;(6) append i to front (of this shorter permutation)
(permute ;(4) ...the list of all permutations...
(remove i lst)))) ;(5) ...of the input list with i removed
lst) ;(2) ... the input list

Answer 2

(TL;DR: the verbal explanation is at the very end of this answer.)
Let's try following the definitions with let*-rewrites. The definitions are
(define (remove x lst) (cond
((null? lst) '())
((= x (car lst)) (remove x (cdr lst)))
(else (cons (car lst) (remove x (cdr lst))))))
(define (permute lst) (cond
((= (length lst) 1) (list lst))
(else (apply append
(map (lambda (i)
(map (lambda (j) (cons i j))
(permute (remove i lst)))) lst)))))
We try
(permute '(a b))
≡
(let* ((lst '(a b)))
(apply append
(map (lambda (i)
(map (lambda (j) (cons i j))
(permute (remove i lst))))
lst)))
≡
(let* ((lst '(a b))
(r (map (lambda (i)
(map (lambda (j) (cons i j))
(permute (remove i lst))))
lst)))
(apply append r))
≡
(let* ((lst '(a b))
(i1 'a)
(r1 (map (lambda (j) (cons i1 j))
(permute (remove i1 lst))))
(i2 'b)
(r2 (map (lambda (j) (cons i2 j))
(permute (remove i2 lst))))
(r (list r1 r2)))
(apply append r))
≡
(let* ((lst '(a b))
(i1 'a)
(t1 (permute (remove i1 lst)))
(r1 (map (lambda (j) (cons i1 j)) t1))
(i2 'b)
(t2 (permute (remove i2 lst)))
(r2 (map (lambda (j) (cons i2 j)) t2))
(r (list r1 r2)))
(apply append r))
≡
(let* ((i1 'a)
(t1 (permute '(b)))
(r1 (map (lambda (j) (cons i1 j)) t1))
(i2 'b)
(t2 (permute '(a)))
(r2 (map (lambda (j) (cons i2 j)) t2))
(r (list r1 r2)))
(apply append r))
≡
(let* ((i1 'a)
(t1 '( (b) ))
(r1 (map (lambda (j) (cons i1 j)) t1))
(i2 'b)
(t2 '( (a) ))
(r2 (map (lambda (j) (cons i2 j)) t2))
(r (list r1 r2)))
(apply append r))
and so we get
(let* ((r1 (map (lambda (j) (cons 'a j)) '( (b) )))
(r2 (map (lambda (j) (cons 'b j)) '( (a) )))
(r (list r1 r2)))
(apply append r))
≡
(let* ((r1 (list (cons 'a '(b))))
(r2 (list (cons 'b '(a))))
(r (list r1 r2)))
(apply append r))
≡
(let* ((r1 (list '(a b)))
(r2 (list '(b a)))
(r (list r1 r2)))
(apply append r))
≡
(let* ((r1 '((a b)))
(r2 '((b a)))
(r (list r1 r2)))
(apply append r))
≡
(apply append (list '((a b)) '((b a))))
≡
( append '((a b)) '((b a)) )
≡
'( (a b) (b a) )
Follow the same technique if you need to convince yourself in the validity of the intermediate results.
In hindsight, we could simplify it a bit more aggressively, like
(let* ((lst '(a b))
(i1 'a)
(r1 (map (lambda (j) (cons i1 j))
(permute (remove i1 lst))))
(i2 'b)
(r2 (map (lambda (j) (cons i2 j))
(permute (remove i2 lst))))
(r (list r1 r2)))
(apply append r))
≡
(let* ((lst '(a b))
(i1 'a)
(t1 (permute (remove i1 lst)))
(r1 (map (lambda (j) (cons i1 j)) t1))
(i2 'b)
(t2 (permute (remove i2 lst)))
(r2 (map (lambda (j) (cons i2 j)) t2)))
(apply append (list r1 r2)))
≡
(let* ((t1 (permute '(b)))
(r1 (map (lambda (j) (cons 'a j)) t1))
(t2 (permute '(a)))
(r2 (map (lambda (j) (cons 'b j)) t2)))
(append r1 r2))
≡
(let* ((r1 (map (lambda (j) (cons 'a j)) '( (b) )))
(r2 (map (lambda (j) (cons 'b j)) '( (a) )))
)
(append r1 ; one row for each elt '( a
r2 ; of the input list, b
)) ; spliced in place by append )
etc., in the end revealing the structure of the computation in the more visually apparent manner:
for each element of the input list,
find all the permutations of the remainder,
prepend that element to each of them,
and join together the results from thus processing each element in the input list, by appending all those results together.
(thus justifying my other, pseudocode-based answer here).

Answer 3

(apply append (map f xs)) == (flatmap f xs).
Re-writing your code in an equational pattern-matching pseudocode,
remove x [x, ...ys] = remove x ys ; skip this x, and go on removing
; ( consider skipping just this one occurrence instead:
; = ys )
remove x [y, ...ys] = [y, ...remove x ys] ; (or else x /= y, so keep this y)
remove x [] = [] ; until the list is exhausted
permute [x] = [[x]]
permute xs =
xs ; ( with (xs |> f) == (f xs) )
|> flatmap (x => ; for each x in xs,
permute (remove x xs) ; for each permutation p of xs w/o x,
|> map (p => [x, ...p]) ) ; prepend x to p and
; splice the results in place of x
Is this clearer?
No? So, let's see how permute [a,b] is calculated.
First, what is permute [a]?
permute [a] = ...
( permute [x] = [[x]] )
... = [[a]]
(it doesn't matter how we call the first element of a single-element list, it's still its first and only element). Similarly,
permute [b] = ...
( permute [x] = [[x]] )
... = [[b]]
OK, but how does it help us see what's the result of permute [a,b]? Let's work with it step by step:
permute [ a, b ] =
;; for each x in (xs==[a,b])
;; a b ; <<- the value of x
;; remove x from xs
;; [b] [a] ; <<- xs with x removed
;; prepend x to each permutation of the above
;; [[ b]] [[ a]] ; <<- permutations
;; [[a,b]] [[b,a]] ; <<- prefixed with x
;; splice them in by `apply append`
[ [a,b] , [b,a] ]
So then, permute [b,c] == [[b,c],[c,b]], etc. And, armed with this knowledge,
permute [ a, b, c ] =
;; for each x in (xs==[a,b,c])
;; remove x from xs
;; [b,c] [a,c] [a,b]
;; prepend x to each permutation of the above
;; [[ b,c],[ c,b]] [[ a,c],[ c,a]] [[ a,b],[ b,a]]
;; [[a,b,c],[a,c,b]] [[b,a,c],[b,c,a]] [[c,a,b],[c,b,a]]
;; splice them in by `apply append`
[ [a,b,c],[a,c,b], [b,a,c],[b,c,a], [c,a,b],[c,b,a] ]
Is that clearer?