[Back]

4.4 逻辑程序设计

4.55

A) (supervisor ?x (Ben Bitdiddle))

B) (job ?x (accounting . ?type)

C) (address ?x (Slumerville ?y ?z))

4.56

A) (and (address ?x ?y)

(supervisor ?x (Ben Bitdiddle))

B) (or (salary (Ben Bitdiddle) ?x)

(and (salary ?person ?y)

(lisp-value < ?y ?x)))

C) (and (job ?x (not (computer .?type)))

(supervisior ?x ?y))

4.57

(rule (replace ?x ?y)
    (and (job ?x ?job1)
         (job ?y ?job2)
         (or (same? ?job1 ?job2)
             (can-do-job ?job1 ?job2))))
(and (rule ?x ?y)
    (salary ?x ?s1)
    (salary ?y ?s2)
    (replace ?x ?y)
    (lisp-value < ?s1 ?s2))

4.58

(rule (big-wheel ?x ?dep)
    (and (job ?x (?dep .?type))
         (not (supervisior ?x ?y))))

4.59

(rule (meeting-time ?person ?day-and-time)
    (or (meeting whole-company ?day-and-time)
         (and (job ?person (?dep . ?type))
              (meeting ?dep ?day-and-time))))

4.60

搁置

4.61

(1 next-to (2 3) in (1 (2 3) 4))
((2 3) next-to 4 in (1 (2 3) 4))

(2 next-to 1 in (2 1 3 1))
(3 next-to 1 in (2 1 3 1))

4.62

(rule (last-pair (?x) (?x)))
(rule (last-pair (?u . ?v) (?x)) 
        (last-pair ?v (?x)))

这个程序不能逆向推断

4.63

(rule (father ?s ?f) 
        (or (son ?f ?s) 
            (and (son ?w ?s) 
                (wife ?f ?w))))
  
(rule (grandson ?g ?s) 
        (and (father ?s ?f) 
            (father ?f ?g)))

4.64

可以看出这个规则系统一定要是尾递归的,因为这样会使得Ben不断在staff-person和middlemanager之间做替换。

4.65

因为他同时作为了多个管理者的管理者,在合并流的时候并不会去重

4.66

问题一样出在去重上,一个值会被累积多次。加一个去重过滤器,方法是检验第一个值是否在余下的流之中出现。

4.67

搁置

4.68

(rule (reverse `() `()))
(rule (reverse (?u . ?v) ?y)
    (append-to-form ?v ?u ?y))

4.69

(rule (end-in-grandson (grandson))) 
(rule (end-in-grandson (?x . ?rest)) 
       (end-in-grandson ?rest)) 
(rule ((grandson) ?x ?y) 
       (grandson ?x ?y)) 
(rule ((great . ?rel) ?x ?y) 
       (and (end-in-grandson ?rel) 
            (son ?x ?z) 
            (?rel ?z ?y)))

4.70

因为这样会把数据流全部求值

4.71

这就是之前所提到过的一些无限循环的规则,如果不delay的话,就会产生无穷流而没有输出。

4.72

同样,是为了防止一个流是无穷流的情况

4.73

同4.72

4.74

Stream-car
(lambda (s) (not (stream-null? S)))

4.75

(define (uniquely-asserted pattern frame-stream) 
  (stream-flatmap 
   (lambda (frame) 
    (let ((stream (qeval (negated-query pattern) 
                    (singleton-stream frame)))) 
         (if (singleton-stream? stream) 
             stream 
             the-empty-stream))) 
   frame-stream)) 
(put 'unique 'qeval uniquely-asserted) 
  
(define (singleton-stream? s) 
  (and (not (stream-null? s)) 
       (stream-null? (stream-cdr s)))) 

4.76

直接调用合一规则即可

4.77

搁置

4.78

搁置

4.79

见SOFTWARE FOUNDATIONS

一个问题求解系统往往基于数理逻辑的一个规则预载,并且尝试着将它们与目前输入的推断做匹配。

当然这个问题是永无止境的,我们甚至可以在环境中搭载自己所定义的新断言,然后试着做蕴含推理。