Find the sum of all the multiples of 3 or 5 below 1000.
Let us generalize again to a finite set of factors.
There is a formula for the power of finite sets
which can be generalized to a finite number of finite sets
or in a somewhat less understandable, but concise notation
Here is a measure (i.e. it commutes with the union sign) and can be replaced with  power of a set sign or, if we are in the natural numbers space, with the sum of elements sign, as in our case. is not a multiindex, but a subset of the natural numbers cut from to .
Now by we denote the set of all the multiples of factors , less than certain number N, where i varies from 1 to n (each is respectively the set of multiples of a factor ). We use the abovementioned formula to compute the measure of the union via measures of all and measures of all finite intersections of them.
Suppose, we have a number , prime or not, and the set of all it's multiples (they include only numbers less than N). Power of this set is of course (div operation) and the sum of its members can be calculated by the wellknown formula for the sum of an arithmetic progression.
As regards all the intersections, it is understandable that we ought to calculate the least common multiple (LCM) of taken factors, and the setintersection of their multiples will be just a set of its multiples. However, the current version of the solution assumes that we take primes as factors, then the LCM of them is just their product. When I calculate proper LCM in Problem 5 (up to now there is a bruteforce version), I will switch the temp version to it.
Let's see the solution. New util functions:

(define (mullist list) (foldleft * 1 list))

(define (^ base power) (expt base power))

(define (sumarithmeticprogression first step n) (/ (* n (+ (* 2 first) (* step ( n 1)))) 2))
The function that calculates subsets of a set:

(define (subsets set)

(define (recursion set rest) (if (null? set) (list rest)

(let ([head (car set)] [tail (cdr set)])

(append (recursion tail rest) (recursion tail (cons head rest))))))

(recursion set '()))
Important thing about this function is that it returns the empty set as the first element and the full set as the last element of a result list, all other subsets are in between. The number of subsets of a finite subset is just , so the complexity is  it would be better visible with an imperativeiterative version of this function (I'm not posting it here). As regards memory, the function generates all the subsets as lists which in whole contain elements (strange, this neat formula isn't on Wikipedia yet, I should add it there), that is the memory load is . This is a notsogood idea to load everything into memory, as we can rewrite this function (and the function that is down here in the post) iteratively with O(n) memory complexity  taking advantage of combinadics, but for now I am satisfied enough with this version.
Using the formula above the solution now as simple as

(define (summultipleslessthan n divisors)

(define (sumofone factor) (sumarithmeticprogression factor factor (div n factor)))

(define (lcmtemp factors) (if (null? factors) 0 (mullist factors)))

(define (measure subset) (* (^ ( 1) (+ (length subset) 1)) (sumofone (lcmtemp subset))))

(sumlist (map measure (cdr (subsets divisors)))))
With that (cdr) I cut off the empty subset, whose measure is zero (otherwise the (sumofone) function has to be a bit more complex).
Let's be careful with notation: n here is actually not the same n, as in the (subsets) function, but the number up there, the maximum of our multiplessets. The performance complexity depends on k and N, but we are interested only in complexity, depending on N. Let's assume that k is small comparing to N, which should be the usual case. Then the complexity is roughly speaking O(1), doesn't depend on N, as we wanted (I remind that in the previous version we had O(N) complexity).
The final touches are the regression tests:

(assert (=

(sumlist (multipleslessthanbruteforce 10 '(3 5)))

(summultipleslessthan 10 '(3 5))))

(assert (=

(sumlist (multipleslessthanbruteforce 1000 '(3 5)))

(summultipleslessthan 1000 '(3 5))))

(assert (=

(sumlist (multipleslessthanbruteforce 10000 '(3 5 7 19)))

(summultipleslessthan 10000 '(3 5 7 19))))

;(assert (=

; (sumlist (multipleslessthanbruteforce 1000 '(3 5 15)))

; (summultipleslessthan 1000 '(3 5 15))))
The last commented one breaks, of course, as 15 is not prime  the LCM algo should be updated still.