Syllogisms

(define all-true (lambda (lst) (apply and lst)))
(define some-true (lambda (lst) (apply or lst)))

; assume the situations constructed have at least one object with each of the properties
(define existential-import (lambda (A B objects) 
                             (and (some-true (map A objects)) (some-true (map B objects)))))

(define all (lambda (A B)
              (if (existential-import A B objects)
                  (all-true (map (lambda (x) (if (A x) (B x) true)) 
                                 objects))
                  false)))

(define some (lambda (A B)
               (if (existential-import A B objects)
                   (some-true (map (lambda (x) (if (A x) (B x) false)) 
                                   objects))
                   false)))

(define none (lambda (A B)
               (if (existential-import A B objects)
                   (all-true (map (lambda (x) (if (A x) (not (B x)) true)) 
                                  objects))
                   false)))

(define not-all (lambda (A B)
                 (if (existential-import A B objects)
                     (some-true (map (lambda (x) (if (A x) (not (B x)) false)) 
                                     objects))
                     false)))


(define (raise-to-power dist alph)
  (list (first dist) (map (lambda (x) (pow x alph)) (second dist))))


; pass strings, which then call functions of the same name
(define (meaning word)
  (case word
        (('all) all)
        (('some) some)
        (('not-all) not-all)
        (('none) none)))

; the reasoner has uninformative prior beliefs about what the conclusion should be
(define (conclusion-prior) (uniform-draw (list 'all 'some 'not-all 'none)))
; rhe reasoner has uninformative prior beliefs about what arguments the experimenter could give
(define (premise-prior) (uniform-draw (list 'all 'some 'not-all 'none)))

; parameter 1: the reasoner's prior beliefs about the rarity of properties
(define br 0.25)
; parameter 2: number of objects in the situation the reasoner imagines
(define objects (list 'o1 'o2 'o3))

(define argument-strength 
  (mem
  ; argument-strength is a function of the argument's premises
   (lambda (premise-one premise-two)
     (enumeration-query
      ; properties map objects to truth-values i.e. whether or not the object has the property
      ; together with the list of objects, these represent situations over which reasoning occurs
      (define A (mem (lambda (x) (flip br))))
      (define B (mem (lambda (x) (flip br))))
      (define C (mem (lambda (x) (flip br))))
      ; the reasoner is also uncertain about what conclusion is true
      (define conclusion (conclusion-prior))
      
      ; what do we want to know? what is the conclusion.
      conclusion
      
      ; condition on the syllogism applying to the situation
      ; notice the form of the syllogism present in this part of the query
      (and
        ; the premise quantifiers apply to: A-B & B-C
            ((meaning premise-one) A B)
            ((meaning premise-two) B C)
        ; the conclusion quantifier is true of terms: A & C
            ((meaning conclusion) A C)
       )))))


(define experimenter
  (mem
  ; the experimenter takes in the conclusion as an argument (i.e. he has a conclusion in mind)
   (lambda (conclusion)
     (enumeration-query
      ; the experimenter draws premises from the premise-prior (uniform) distribution
      (define premise-one (premise-prior))
      (define premise-two (premise-prior))
      
      ; the experimenter produces two premises
      (list premise-one premise-two)
      
      ; the experimenter wants the reasoner to draw a particular conclusion, gives the premises 
      ; parameter 3: "optimality" -- the degree to which the experimenter's argument is optimal for the conclusion
     (equal? conclusion (apply multinomial (raise-to-power (argument-strength premise-one premise-two) 4.75)))))))

(define pragmatic-reasoner 
  (mem
  ; the reasoner takes in two premises as arguments
   (lambda (premise-one premise-two)
     (enumeration-query
      ; the pragmatic reasoner has the exact same generative model as the argument strength model
      (define A (mem (lambda (x) (flip br))))
      (define B (mem (lambda (x) (flip br))))
      (define C (mem (lambda (x) (flip br))))
      (define conclusion (conclusion-prior))
      
      ; the reasoner produces a conclusion
      conclusion
      
      (and
      ; the conclusion quantifier is true of terms: A & C
       ((meaning conclusion) A C)
      ; the premises now serve a different role; the premises are imagined to come from an experimenter
      ; who has a particular conclusion in mind
        (equal? (list premise-one premise-two) (apply multinomial (experimenter conclusion))))
       ))))


; All A are B
; No B are C [cogsci paper, Fig 2 [1]]

;(pragmatic-reasoner 'all 'none)
(argument-strength 'all 'none)
    
; this is a valid syllogism with 2 valid conclusions
; using the argument-strength alone produces no preference among valid conclusions
; the pragmatic reasonser draws the conclusion not only true of the situation
; but also which was intended to be drawn, inferring that "None" is the more likely intended conclusion