Определить функцию предикатного типа, которая определяет, что два S-выражения эквивалентны

(define myf(lambda (list list2)
             (cons
          ((myf`(car list)`(car list)))
             ((eq? (car list)(car list2))#t)
             ((myf (cdr list)(cdr list2)))
              (#f #f))))
 
(myf `(a b c)`(a b c))

(define mys (lambda (a b)
             (cond
                ((eq? b `())0)
                (#t(equal? (cdr a)(cdr b))))))

(define comp-exps
 (lambda (x1 x2)
  (cond ((or (atom? x1) (atom? x2)) (eq? x1 x2))
        (#t (and (comp-exps (car x1) (car x2))
                 (comp-exps (cdr x1) (cdr x2)))))))  
                
(display (comp-exps '(1 (2 3)) '(1 (2 3))))

(defun comp-exps (w v)
  (if (atom w) (eq w v) 
      (and (comp-exps (car w) (car v))
           (comp-exps (cdr w) (cdr v)))))
 
> (comp-exps '(1 (2 3)) '(1 (2 3)))
T
> (comp-exps '(1 (2 3)) '(1 (2 2)))
NIL

(define atom? (lambda (x) (cond ((pair? x) #f) ((list? x) #f) (#t #t))))
(define and? (lambda (x y) (cond ((eq? x #f) #f) ((eq? y #f) #f) (#t #t))))
(define or? (lambda (x y) (cond (x #t) (y #t) (#t #f))))
(define not? (lambda (x) (cond (x #f)(#t #t))))
 
(define equals? (lambda (x y)(cond
  ((eq? x y) #t)
  ((or? (eq? x '()) (eq? y '())) #f)
  ((or? (atom? x) (atom? y)) #f)
 
  ((and? (and? (pair? x) (pair? y)) (and? (pair? (car x)) (eq? (cdr x) '()))) (equals? (car x) y))
  ((and? (and? (pair? x) (pair? y)) (and? (pair? (car y)) (eq? (cdr y) '()))) (equals? x (car y)))
  ((not? (equals? (car x) (car y))) #f)
  (#t (equals? (cdr x) (cdr y))))))
 
(equals? `(1  2)`(1 . (2)))
(equals? `(1)`(2))
 
(equals? `(1  2)`(1 . (2))) ;; тут говорит что #t а должно писать #f.  Все остальные проверки работают