(defun split-to-apply-fun-by-space (str num f &optional (result ()))
    (if (< num (length str))
        (if (char= (char str num) #\Space)
            (split-to-apply-fun-by-space str (+ 1 num) f result)
            (split-to-apply-fun-by-space str (+ 1 num) f (cons (funcall f (+ 1 (length result)) (char str num)) result)))
        (reverse result)))

(defun char-bool-to-p-str (num c)
    (if (char= #\0 c) (format nil "¬P_~A" num) (format nil "P_~A" num)))

(defun solve-line (s)
    (if (char= #\0 (aref s (- (length s) 1)))
        nil
        (split-to-apply-fun-by-space (subseq s 0 (- (length s) 1)) 0 #'char-bool-to-p-str)))

(defun join-by-AND (ss)
    (if (null ss) ss
        (format nil "(~{~A~^∧~})" ss)))

(defun solve-lines (n limit)
    (let ((result (make-array limit :initial-element nil)))
        (dotimes (idx limit)
            (setf (aref result idx) (join-by-AND (solve-line (read-line)))))
        result))

(defun output-lines (ss)
    (loop for i from 0
          until (>= i (length ss))
          do (if (> i 0) (format t "∨"))
             (format t (aref ss i))))

(let* ((n (parse-integer (read-line)))
       (m (solve-lines n (expt 2 n)))
       (m2 (remove-if (lambda (x) (null x)) m)))
    (format t "A=")
    (if (= 0 (length m2))
        (format t "⊥")
        (if (= (length m2) (expt 2 n))
            (format t "⊤")
            (output-lines m2)))
    (format t "~%"))