是否可以在 Ocaml 中实现罗素悖论？

Question

I recently learned about Russell's Paradox in naive set theory, where when considering the set of all sets that are not members of themselves, the set appears to be a member of itself iff it is not a member of itself, which creates the paradox. I was wondering if a function that asks whether a set is a member of itself is implementable, in a functional language such as Ocaml, since Russell's Paradox has no definite answer in itself, and if so, would like any hints on how to tackle the problem. In addition, I am interested in learning if any of these mathematical paradoxes are implementable in general.

Answer 1

I am neither a logician nor a type or set theorist. But if you turn on -rectypes you can write a function that tests whether a list is a member of itself:

$ ocaml -rectypes
        OCaml version 4.10.0

let f x = List.mem x x;;
val f : ('a list as 'a) -> bool = <fun>

You can create a list that is a member of itself:

# let rec mylist = [mylist];;
val mylist : 'a list as 'a = [<cycle>]
# f mylist;;
- : bool = true

I suspect this is only faintly related to Russell's paradox, unfortunately.

Update

Say you define a set as a function that returns true for elements of the set and false for elements not in the set. Then you can create Russell's paradox to a pretty reasonable degree.

The empty set is a set that always returns false:

$ rlwrap ocaml -rectypes
        OCaml version 4.10.0

# let empty x = false;;
val empty : 'a -> bool = <fun>

Here is a singleton set that contains itself:

# let rec just_self x = x == just_self;;
val just_self : 'a -> bool as 'a = <fun>

You can try various tests of these values and get reasonable answers:

# empty empty;;
- : bool = false

The empty set doesn't contain anything, including itself.

# just_self empty;;
- : bool = false

The set just_self only contains itself, not the empty set.

# just_self just_self;;
- : bool = true

So then the Russell set is the set that contains sets that don't contain themselves:

# let russell s = not (s s);;
val russell : ('a -> bool as 'a) -> bool = <fun>

The Russell set contains the empty set (because it doesn't contain itself):

# russell empty;;
- : bool = true

The Russell set does not contain just_self , because that set contains itself:

# russell just_self;;
- : bool = false

Now the big payoff. Does the Russell set contain itself?

# russell russell;;
Stack overflow during evaluation (looping recursion?).

This is what you should expect. Ie, the computation diverges. (Also a very fitting result for this website.)