En un proyecto en el que estoy trabajando, he implementado aproximadamente el 80% de lo que quiero que haga mi programa y estoy muy contento con los resultados.

En el 20% restante me enfrento a un problema que me desconcierta un poco sobre cómo resolverlo. Aquí está:

He creado una lista de listas que contienen varios números (longitud arbitraria) Por ejemplo:

listElement[0] = [1, 2, 3]
listElement[1] = [3, 6, 8]
listElement[2] = [4, 9]
listElement[4] = [6, 11]
listElement[n] = [x, y, z...]

donde n podría alcanzar hasta 40,000 o menos.

Suponiendo que cada elemento de la lista es un conjunto de números (en el sentido matemático), lo que me gustaría hacer es derivar todas las combinaciones de conjuntos mutuamente excluyentes; es decir, como el conjunto de potencias de los elementos de la lista anterior, pero con todos los elementos de conjuntos no disociados excluidos.

Entonces, para continuar el ejemplo con n = 4, me gustaría crear una lista que tenga las siguientes combinaciones:

newlistElement[0] = [1, 2, 3]
newlistElement[1] = [3, 6, 8]
newlistElement[2] = [4, 9]
newlistElement[4] = [6, 11] 
newlistElement[5] = [[1, 2, 3], [4, 9]]
newlistElement[6] = [[1, 2, 3], [6, 11]]
newlistElement[7] = [[1, 2, 3], [4, 9], [6, 11]]
newlistElement[8] = [[3, 6, 8], [4, 9]]
newlistElement[9] = [[4, 9], [6, 11]

Un caso no válido, por ejemplo, sería combinación [[1, 2, 3], [3, 6, 8]] porque 3 es común en dos elementos. ¿Hay alguna manera elegante de hacer esto? Estaría extremadamente agradecido por cualquier comentario.

También debo especificar que no me gustaría hacer la función de conjunto de poder, porque la lista inicial podría tener un número bastante grande de elementos (como dije que podría subir a 40000), y tomar el conjunto de poder con tantos elementos nunca terminaría .