**Write a binary-predicate list test**

A binary-predicate is a function that tests a relation between two arguments. A binary-predicate has the general signature:

- : 'a -> 'a -> bool =

As examples `=`

and `&&`

are both symmetric binary-predicates:

# (=);; - : 'a -> 'a -> bool =# (&&);; - : bool -> bool -> bool =

**a)** Implement `exists_symmetric`

that tests if `list`

contains distinct items `x`

and `y`

such that `pred x y = pred y x = true`

.

let exists_symmetric pred list = ... ;; val exists_symmetric : ('a -> 'a -> bool) -> 'a list -> bool =

**b)** There also exists asymmetric binary-predicates such as `<`

and `>`

:

# (>);; - : 'a -> 'a -> bool =

Implement `exists_asymmetric`

that tests if `list`

contains distinct items `x`

and `y`

such that `(pred x y) or (pred y x) = true`

.

let exists_asymmetric pred list = ... ;; val exists_asymmetric : ('a -> 'a -> bool) -> 'a list -> bool =

**c)** Let `pattern`

be the following declared type:

type pattern = ... ;;

A sub-pattern is a less general, more specific pattern.

Two patterns are said to be unifiable iff there exist one pattern object that is a sub-pattern of both of them.

Let `unifiable`

be the unifiability test:

let unifiable pat1 pat2 = ... ;; val unifiable : pattern -> pattern -> bool =

A choice is a list of patterns.

A choice is said to be determinist iff there exist no pattern object that is a sub-pattern of more than one pattern within the choice. That is iff there doesn't exist two patterns within the choice that are unifiable. Using `exists_symmetric`

, implement `determinist_choice`

that tests if a `pat_list`

choice is determinist:

let determinist_choice pat_list = ... ;; val determinist_choice : pattern list -> bool =