(defn filtered-accumulate [predicate comb null-val term next a b]
  (defn iter [a result]
    (if (> a b)
      result
      (iter (next a) (cond
                       (predicate a b) (comb (term a) result)
                       result))))
  (iter a null-val))

(defn prime? [n x]
  (defn random [k]
    (math/floor (* (math/random) k)))
  (defn square [k]
    (* k k))
  (defn even? [k]
    (= (mod k 2) 0))
  (defn expmod [base exp m]
    (defn squaring-test [k]
      (cond
        (and
          (not (= k 1))
          (not (= k (- m 1)))
          (= (mod (square k) m) 1)) 0
        (mod (square k) m)))
    (cond
      (= exp 0) 1
      (even? exp) (squaring-test (expmod base (/ exp 2) m))
      (mod (* base (expmod base (- exp 1) m)) m)))
  (defn miller-rabin-test [k]
    (defn try-it [a]
      (cond
        (= (expmod a (- k 1) k) 0) false
        true))
    (try-it (+ 1 (random (- k 1)))))
  (defn iter [k times]
    (cond
      (= times 0) true
      (miller-rabin-test k) (iter k (- times 1))
      false))
  (iter n 100))

(defn rel-prime? [a b]
  (defn gcd [x y]
    (if (= y 0)
      x
      (gcd y (mod x y))))
  (cond
    (= (gcd a b) 1) true
    false))

(defn prime-sum [a b]
  (defn identity [n] n)
  (defn next [n] (+ n 1))
  (defn add [a b] (+ a b))
  (filtered-accumulate prime? add 0 identity next a b))

(defn rel-prime-sum [n]
  (defn identity [n] n)
  (defn next [n] (+ n 1))
  (defn mul [a b] (* a b))
  (filtered-accumulate rel-prime? mul 1 identity next 1 n))

(print (prime-sum 2 5))
(print (rel-prime-sum 6))