为什么许多编程语言中的集合不是真正的集合

在几种编程语言中，有Set集合，它们被认为是有限集数学概念的实现。

然而，这不一定是真的，例如在C#和Java中，HashSet<T>的两个实现都允许您将任何HashSet<T>集合添加为其自身的成员。根据数学集合的现代定义，这是不允许的。

背景：

根据天真集合论，集合的定义是：

集合是不同对象的集合。

然而，这个定义导致了著名的罗素悖论以及其他悖论。为了方便起见，罗素的悖论是：

设R是不是其自身成员的所有集合的集合。如果R不是其自身的成员，则其定义规定它必须包含自身，如果包含自身，则与自身矛盾定义为不是其自身成员的所有集合的集合。

所以根据现代集合论（参见：ZFC），集合的定义是：

集合是不同对象的集合，没有一个是集合它本身

具体来说，这是正则性公理的结果。

那又怎样？这意味着什么？为什么这个问题出现在StackOverflow上

罗素悖论的含义之一是并非所有集合都是集合。此外，在这一点上，数学家们放弃了集合的定义，认为它是通常的英语定义。所以我相信这个问题在一般的编程语言设计中有很大的分量。

问题：

那么，为什么在某种形式上在设计中使用这些原则的编程语言在其语言库中实现Set时会忽略这些原则呢？

其次，这在数学概念的其他实现中是否常见？

也许我有点挑剔，但如果这些是Set的真正实现，那么为什么要忽略定义的一部分呢？

更新

添加C#和Java代码片段示例行为：

Java代码段：

Set<Object> hashSet = new HashSet<Object>();
hashSet.add(1);
hashSet.add("Tiger");
hashSet.add(hashSet);
hashSet.add('f');
Object[] array = hashSet.toArray();
HashSet<Object> hash = (HashSet<Object>)array[3];
System.out.println("HashSet in HashSet:");       
for (Object obj : hash)
    System.out.println(obj);
System.out.println("'nPrinciple HashSet:");
for (Object obj : hashSet)
    System.out.println(obj);

哪个打印出来：

HashSet in HashSet:
f
1
Tiger
[f, 1, Tiger, (this Collection)]
Principle HashSet:
f
1
Tiger
[f, 1, Tiger, (this Collection)]

C#代码段：

HashSet<object> hashSet = new HashSet<object>();
hashSet.Add(1);
hashSet.Add("Tiger");
hashSet.Add(hashSet);
hashSet.Add('f');
object[] array = hashSet.ToArray();
var hash = (HashSet<object>)array[2];
Console.WriteLine("HashSet in HashSet:");
foreach (object obj in hash)
     Console.WriteLine(obj);
Console.WriteLine("'nPrinciple HashSet:");
foreach (object obj in hashSet)
     Console.WriteLine(obj);

哪个打印出来：

HashSet in HashSet:
1
Tiger
System.Collections.Generic.HashSet`1[System.Object]
f
Principle HashSet:
1
Tiger
System.Collections.Generic.HashSet`1[System.Object]
f

更新2

关于Martijn Courteaux的第二点，即可以以计算效率的名义进行：

我用C#做了两个测试集合。它们是相同的，只是在其中一个的Add方法中——我添加了以下检查：if (this != obj)，其中obj是要添加到集合中的项。

我分别对它们进行了计时，它们将添加100000个随机整数：

带检查：~28毫秒

无检查：~21毫秒

这是一个相当显著的性能提升。