Execute LISP Online

(defun resolution(1c)

(cond 
((null(second 1c))  (cond ((equal (first 1c) '(NIL NIL)) nil)     ; (NIL NIL) contradiction case
                          ((eql (first (first 1c)) 'nil)  nil)  ; <- A case
                          (t                    t)      ; ow, not a contradiction 

                        ) )

(t (resolution(append (list(ResolveClauses (first 1c) (second 1c) )) (rest(rest 1c)) ))); append resolution of two clauses to end of list, run until only one list left

  )



    )
(defun ResolveClauses(x y)

    (print x)
    (print y)
    (print(first x))
    (print (second y))
    (print(second x))
    (print(first y))
    (print(first(second x)))
    (print(not (null (member (first(second x)) (first y)))))
   ; (print(append x (list(ResolveClauseMembers (first x)(second y))
    
    ;)))
    (print (ResolveClauseMembers(first x)(second y))) ;clause 1
    (print (mirror(ResolveClauseMembers(second x)(first y)))   ) ;clause 2
  ;  (print(append(first (ResolveClauseMembers (first x)(second y)) )
   ;              (first (ResolveClauseMembers(first y)(second x)))
    
    ;  )
    ;)
    
  ;  (print(append(second (ResolveClauseMembers (first x)(second y)) )
   ;              (second (ResolveClauseMembers(first y)(second x)))
    ;
     ; )
    ;)
    (print '(CLAUSES))
   (print (ResolveClauseMembers(first x)(second y))) ;clause 1
   (print (mirror(ResolveClauseMembers(second x)(first y)))) ;clause 2
    
    
    ;grab result without duplicates
    (setf z nil)
    
    ;(list(first(ResolveClauseMembers(first x)(second y))))
    
    
              ;  (print                 (append z (list(first(ResolveClauseMembers(first x)(second y))))))

;(if (null (first(ResolveClauseMembers(first x)(second y))) )
 ;   (setf z (append z (list nil)))

    (if (null (member z  (first(ResolveClauseMembers(first x)(second y)))) )
                 (setf z (append z (first(ResolveClauseMembers(first x)(second y)))))
                 
                 
            )

;)

;(if  (null (mirror(ResolveClauseMembers(second x)(first y))))
 ;       (setf z (append z (list nil)))
           ; (print(null (list (member z  (first(ResolveClauseMembers(first x)(second y)))) )))
            (if (null (member z (first (mirror(ResolveClauseMembers(second x)(first y)))) ))
                  (setf z (append z (first(mirror(ResolveClauseMembers(second x)(first y))))))
                 
            )
;)
    
    (setf v nil)
            
       ; (setf v (list(second(mirror(ResolveClauseMembers(second x)(first y))))))

;(if (null(second(mirror(ResolveClauseMembers(second x)(first y)))))
 ;   (setf v (append v (list nil)))
        (if (null (member v (second(mirror(ResolveClauseMembers(second x)(first y))))))
        (setf v (append v (second(mirror(ResolveClauseMembers(second x)(first y))))))
                 
            )

;)
;(if (null (second (ResolveClauseMembers(first x)(second y))) )
 ;   (setf v (append v (list nil)))
    (if (null (member v  (second (ResolveClauseMembers(first x)(second y))) ))
        (setf v (append v (second(ResolveClauseMembers(first x)(second y)))))
                 
            )
;)
            
                 ;(print z)
                 ;(print v)
                ; (print  (append z (list(first(mirror(ResolveClauseMembers(second x)(first y)))))))
                 ;(print (append z v)) ;result without duplicates
               
               
               (print 'ZVCombination)
               (print (append (list (RemoveDuplicateAtoms z)) (list (RemoveDuplicateAtoms v))))
               ;(print (eliminateDuplicates v))
               ;(print v)
               
                (cond 
                
                  (t (append (list (RemoveDuplicateAtoms z)) (list (RemoveDuplicateAtoms v))))
                )
                 
    ;combine result
   ; (print (append (list(append(first (ResolveClauseMembers (first x)(second y)) )
;                 (first (mirror(ResolveClauseMembers(second x)(first y))))))
;                 (list (append(second (ResolveClauseMembers (first x)(second y)) )
;                (second (mirror(ResolveClauseMembers(second x)(first y))))
;      ))
 ;     )
 ;   )
;TO-DO: Append combine result to end of 1c list
;       Check all cases for resolveclausemembers
)

(defun ResolveClauseMembers(x y )

;(print x)
;(print y)
(setf xval x)
(setf yval y)

;Iterate through clause x looking for matching members in clause y
(loop for x1 in x

      
      if (member x1 y) ;remove atom from both clauses, if match occurs
      do (progn (setf xval (RemoveAtomFromList x1 xval)) (setf yval (RemoveAtomFromList x1 yval)))
      
      )
      
      ;return value in ((X)(Y)) form
    (append (list xval) (list yval))
)




(defun mirror(e)
       (cond 
		( (null e)    '()) ;check if e is the empty list or nil
		((atom e) e) ;check if e is a single atom
		((append (mirror(rest e)) (cons(mirror(first e)) '())))  ;Otherwise, Reverse items in any sublist and append these lists in reverse order
		

	)
  )

; change this
(defun RemoveAtomFromList (atom array)
   (cond
      ((null array) ())
        ((eq (first array) atom) (RemoveAtomFromList atom (rest array)))
      (t (append (list (first array) ) (RemoveAtomFromList atom (rest array))))
    )

)

;change this
(defun RemoveDuplicateAtoms (array)
  (cond 
        ((null array) array)
        ((member (first array) (rest array)) (RemoveDuplicateAtoms (rest array)))
        (t (append (list (first array)) (RemoveDuplicateAtoms (rest array))))
    
    )
)
    

    
    
(print  (resolution '( ((C)()) (()(C))  )))