0 = λf.λx.x
1 = λf.λx.f x
2 = λf.λx.f (f x)
3 = λf.λx.f (f (f x))

successor = λn.λf.λx.f (n f x)
predecessor = λn.λf.λx.n (λg.λh.h (g f)) (λu.x) (λu.u)
subtract = λm.λn.n predecessor m

true = λx.λy.x
false = λx.λy.y

cons = λx.λy.λf.f x y
car = λp.p true
cdr = λp.p false
nil = λx.true
null? = λp.p (λx.λy.false) 

and = λp.λq.p q p
or = λp.λq.p p q
not = λp.λa.λb.p b a
if = λp.λa.λb.p a b 
bicond = λp.λq.and (not (or p q)) (not (or q p))

zero? = λn.n (λx.false) true
leq? = λm.λn.zero? (subtract m n)
eq? = λm.λn.and (leq? m n) (leq? n m)

all = λv:boolean.λp.λl.if (null l) false if (bicond v (p (car l))) (all-bool? (cdr l) p) false
any = λv:boolean.λp.λl.if (null l) false if (or v (p (car l))) true (any-bool? (cdr l) p)
all-true? = all? true
any-true? = any? true

;slots:
; 0: unique id
; 1: who they like
; 2: who they hate
; 3: etc...

Bill = λs.car ((s cdr) (cons 1 (cons 3 (cons 2 nil))))
Bob = λs.car ((s cdr) (cons 2 (cons 3 (cons 1 nil))))
Susie = λs.car ((s cdr) (cons 3 (cons 1 (cons 2 nil))))

; assuming you've formally defined the types 'entity' and 'group'...
likes? = λa:entity.λb:entity.eq? (b 1) (a 0)
likes? = λa:entity.λb:group.all? (λe.eq? (e 1) (a 0)) b
hates? = λa:entity.λb:entity.eq? (b 2) (a 0)
hates? = λa:entity.λb:group.all? (λe.eq? (e 2) (a 0)) b

;now...
; ((likes? Susie) Bill) is true
; ((likes? Susie) Bob) is true
; ((likes? Susie) (cons Bill Bob)) is true
; ((likes? Bob) Susie) is false
; etc...

;likes is a function that takes an entity and returns a function that takes an entity and returns truth
;I've forgotten how to do the type notation correctly, but
; entities are functions that take a number and return a number
; groups are lists of entities
; the function likes takes an entity and a group, and returns truth, exactly like you wanted.