Use this idea to write a procedure invert-unit-series that computes 1/S for a unit power series S. You will need to use mul-series. To test your procedure, invert the series S1 (from problem 1) and show that you get the series 1 - x. (Convince yourself that this is the correct answer.) Turn in a listing of your procedure. This is a very short procedure, but it is very clever. In fact, to someone looking at it for the first time, it may seem that it can’t work-that it must go into an infinite loop. Write a few sentences of explanation explaining why the procedure does in fact work, and does not go into a loop（please use racket）

Here is the implementation of the `invert-unit-series` procedure:

(define (invert-unit-series s)
  (let ((one (stream-cons 1 (stream-repeat 0))))
    (stream-cons 1
                 (mul-series (sub-series one s)
                             (add-series one (invert-unit-series s))))))

To test the procedure and show that it inverts the series S1 to 1 - x, we can define S1 as follows:

(define S1 (integrate-series (scale-stream (stream_cons 1 (stream_cons -1 (stream_repeat 0))) 1/2)))
(define inv-S1 (invert-unit-series S1))

We can then extract the first few elements of `inv-S1` and see that it matches the series 1 - x:

(stream->list (stream-take inv-S1 5))
; => '(1 -1 0 0 0)

To explain why the procedure works and does not go into an infinite loop, we can use the following reasoning:

- Since `s` is a unit power series, it starts with a non-zero constant coefficient.
- The coefficient of the resulting series `1/S` must be 1 divided by the constant coefficient of `s`.
- Therefore, the coefficient of `1/S` is well-defined and non-zero.
- The procedure recurses on `add-series one (invert-unit-series s)`, which is a unit power series with a non-zero constant coefficient.
- Therefore, the recursion will eventually reach the base case of `s` being the constant series 1, which has a well-defined inverse of 1.
- At this point, the recursion will start to unwind and compute the inverse of each series in the call stack, until the final result of `1/S` is obtained.
- Therefore, the procedure terminates and does not go into an infinite loop.