;; Equation solver in Lisp
(defun solve-equation (a b c)
  (format t "Solving: ~ax² + ~ax + ~a = 0~%" a b c)
  
  ;; Linear equation (a = 0)
  (if (= a 0)
      (if (= b 0)
          (if (= c 0)
              "Infinite solutions"
            "No solution")
        (format nil "Linear equation: x = ~a" (/ (- c) b)))
    
    ;; Quadratic equation
    (let ((discriminant (- (* b b) (* 4 a c))))
      (format t "Discriminant = ~a~%" discriminant)
      
      (cond
        ((> discriminant 0)
         (let ((x1 (/ (+ (- b) (sqrt discriminant)) (* 2 a)))
               (x2 (/ (- (- b) (sqrt discriminant)) (* 2 a))))
           (format nil "Two real roots: x₁ = ~a, x₂ = ~a" x1 x2)))
        
        ((= discriminant 0)
         (let ((x (/ (- b) (* 2 a))))
           (format nil "One real root: x = ~a" x)))
        
        (t
         (let ((real-part (/ (- b) (* 2 a)))
               (imag-part (/ (sqrt (- discriminant)) (* 2 a))))
           (format nil "Complex roots: x₁ = ~a + ~ai, x₂ = ~a - ~ai" 
                   real-part imag-part real-part imag-part)))))))

;; Test cases
(format t "=== LISP EQUATION SOLVER ===~%")

(let ((test-cases '((1 -3 2)   ; Two real roots
                    (1 2 1)    ; One real root
                    (1 0 1)    ; Complex roots
                    (0 2 -4)   ; Linear equation
                    (0 0 0)    ; Infinite solutions
                    (0 0 5)))) ; No solution
    
    (loop for case in test-cases
          for i from 1
          do (format t "~%Test case ~a:~%" i)
             (let ((result (apply #'solve-equation case)))
               (format t "~a~%" result))))