Lisp - 文法のアクセスできない要素と非生産的要素を排除するための中間結果

Question

文法（Vn; Vt; P; S）から、非生産的またはアクセス不可能な要素を決定する問題を実装しました。 Vt-端末およびP-生産ルール、およびS-開始記号。

;;; Defining a grammar 
(defvar *VN* '(A B C D S)) ; non-terminal variables 
(defvar *VT* '(k m n)) ; terminal 
(defvar *P* '((S A B) ; set of production rules 
       (S C D) 
       (S A k) 
       (A k) 
       (B m) 
       (B D m D) 
       (C n))) 

;;; FINDING PRODUCTIVE ELEMENTS 

(defun PROD-STEP (VT P PRODS) 
    ;;(format t "P = ~S~%" P) 
    ;;(format t "PRODS = ~S~%" PRODS) 
    (if (null P) 
     PRODS 
     (if (subsetp (rest (first P)) (union VT PRODS)) 
      (PROD-STEP VT (rest P) (union (cons (first (first P)) nil) PRODS)) 
      (PROD-STEP VT (rest P) PRODS)))) 

(defun PROD-AUX (VT P PRODS oldLength) 
    (if (= (length PRODS) oldLength) 
     PRODS 
     (PROD-AUX VT P (PROD-STEP VT P PRODS) (length PRODS)))) 

(defun PROD (VT P) 
    (PROD-AUX VT P nil -1)) 

;;; END OF FINDING PROD ELEMENTS 

(trace PROD-STEP) 
(trace PROD-AUX) 
(trace PROD) 
(PROD *VT* *P*) 

;;; FINDING ACCESSIBLE ELEMENTS 

(defun ACCESS-STEP (P ACC) 
    ;;(format t "Pacc = ~S~%" P) 
    ;;(format t "ACC = ~S~%" ACC) 
    (if (null P) 
     ACC 
     (if (member (first (first P)) ACC) 
      (ACCESS-STEP (rest P) (union (rest (first P)) ACC)) 
      (ACCESS-STEP (rest P) ACC)))) 

(defun ACCESS-AUX (P ACC oldLength) 
    (if (= (length ACC) oldLength) 
     ACC 
     (ACCESS-AUX P (ACCESS-STEP P ACC) (length ACC)))) 

(defun ACCESS (P S) 
    ;;(format t "Paccess = ~S~%" P) 
    (ACCESS-AUX P (cons S nil) 0)) 

;;; END OF FINDING ACCESSIBLE ELEMENTS 

(trace ACCESS-STEP) 
(trace ACCESS-AUX) 
(trace ACCESS) 
(ACCESS *P* 'S) 

;;; REMOVING INACCESSIBLE AND NOT PRODUCTIVE ELEMENTS 

(defun BuildRules-AUX (VT ACCS PRODS P newP) 
    ;;(format t "newP = ~S~%" newP) 
    (if (null P) 
     newP 
     ;; VN' = (ACCESS(G) INTERSECT PROD(G)) 
     ;; VT' = (VT INTERSECT ACCESS(G)) 
     ;; DACA REGULA ESTE A->X, A = (first (first P)) SI X = (rest (first P)) 
     ;; VERIFICAM DACA A APARTINE VN' SI X APARTINE (VT' UNION VN') 
     (if (and (member (first (first P)) (intersection PRODS ACCS)) 
       (subsetp (rest (first P)) 
         (union (intersection ACCS PRODS) 
           (intersection VT ACCS)))) 
      (BuildRules-AUX VT ACCS PRODS (rest P) (union newP 
                 (cons (first P) nil))) 
      (BuildRules-AUX VT ACCS PRODS (rest P) newP)))) 

(defun BuildRules (VT ACCS PRODS P) 
    (BuildRules-AUX VT ACCS PRODS P nil)) 

(trace BuildRules-AUX) 
(trace BuildRules) 

(BuildRules *VT* (ACCESS *P* 'S) (PROD *VT* *P*)*P*) 

(defun SIMPL-AUX (VN VT P S ACCS PRODS) 
    (setq ACCS (ACCESS P S)) 
    (setq PRODS (PROD VT P)) 
    (if (and (null (set-difference (union VN VT) ACCS)) 
      (null (set-difference VN PRODS))) 
     (cons VN (cons VT (cons P S))) 
     (SIMPL-AUX (intersection ACCS PRODS) 
       (intersection VT ACCS) 
       (BuildRules VT ACCS PRODS P) 
       S 
       ACCS 
       PRODS))) 

(defun SIMPL (VN VT P S) 
    (SIMPL-AUX *VN* *VT* *P* 'S nil nil)) 

;;; END OF REMOVING INACCESSIBLE AND NOT PRODUCTIVE ELEMENTS 

;;; GETTING THE RESULTS 

(SIMPL *VN* *VT* *P* 'S) 

しかし、今私はいくつかの中間結果を得ようとしています。

生産性とアクセスのために、それは私がPRODとACCESSを使用するであろうことは明らかだ、

(PROD *VT* *P*) 
(ACCESS *P* 'S) 

が、私はのためにいくつかの中間結果を取得するかどうかはわかりません。

1. 非生産的
を
2. アクセス不可能

(BuildRules *VT* (ACCESS *P* 'S) (PROD *VT* *P*) *P*) 

あなたはこれを理解するのを手伝ってもらえますか？

Answer 1

build-rulesという置換えを使用するだけで、1種類の述語をフィルタリングすることができます。ところで、それはremove-if-notを使ってもっとはっきりと書くことができました。