Marxist Philosophy of Science
Matemática · Computación · Método
Conjuntos y Combinatoria en R
Una exploración computacional del producto cartesiano, el conjunto potencia, las permutaciones y las combinaciones
JOSÉ MAURICIO GÓMEZ JULIÁN
Publicado originalmente el 4 de abril de 2021 · Versión revisada y ampliada
Resumen
Este artículo articula definiciones, argumentos de conteo y experimentos reproducibles en R para estudiar construcciones sobre conjuntos finitos. Se examinan el producto cartesiano y el conjunto potencia, las selecciones ordenadas con y sin repetición, las combinaciones y las permutaciones de multiconjuntos. La exposición distingue los objetos matemáticos de sus representaciones informáticas, explica el papel del orden y de las multiplicidades, precisa la relación entre conjunto potencia y σ-álgebra y separa el cálculo de cardinalidades de la enumeración exhaustiva.
Palabras clave: conjuntos finitos; combinatoria; R; RStudio; producto cartesiano; conjunto potencia; σ-álgebra; permutaciones; combinaciones; reproducibilidad.
Contar es establecer qué diferencias hacen que dos objetos deban considerarse distintos. Antes de ejecutar una función o aplicar una fórmula, necesitamos decidir si el orden importa, si un elemento puede reaparecer y si estamos construyendo subconjuntos, secuencias o colecciones con multiplicidades. R ofrece un laboratorio accesible para hacer visibles estas decisiones y confrontar sus consecuencias con resultados que podemos inspeccionar.
La aproximación empírica que aquí se propone consiste en construir ejemplos finitos, comparar representaciones y verificar identidades en casos concretos. Esa actividad tiene valor exploratorio, pedagógico y de control de implementación. Una identidad válida para todos los tamaños exige, además, un argumento general: ejecutar un programa para varios valores no convierte por sí solo una regularidad observada en un teorema.
1. Objetos matemáticos y representaciones en R
Un conjunto es una colección de elementos en la que la pertenencia resulta determinante: repetir la escritura de un elemento o alterar el orden de presentación no produce otro conjunto. Así, {a, b, a} y {b, a} representan el mismo conjunto. En cambio, las secuencias (a, b) y (b, a) son diferentes, y la secuencia (a, a) tiene dos posiciones aunque solo emplee un símbolo distinto.
Un multiconjunto conserva cuántas veces aparece cada tipo de elemento, sin distinguir posiciones. Por ejemplo, {a, a, b} y {a, b, a} describen el mismo multiconjunto, diferente de {a, b, b}. En esta notación, las llaves se usan de manera informal para mostrar multiplicidades; el contexto aclarará cuándo representan un conjunto ordinario y cuándo un multiconjunto.
| Objeto | Orden | Multiplicidad | Ejemplo |
|---|---|---|---|
| Conjunto | No distingue posiciones | Solo pertenencia | {a, b} = {b, a, a} |
| Secuencia o tupla | Sí distingue posiciones | Puede incluir repeticiones | (a, b) ≠ (b, a) |
| Multiconjunto | No distingue posiciones | Sí conserva cantidades | {a, a, b} ≠ {a, b, b} |
Un vector de R posee posiciones y puede tener valores repetidos; por ello, no es automáticamente un conjunto matemático. Para los ejemplos de este artículo, representaremos los conjuntos mediante vectores numéricos finitos o de texto sin duplicados ni valores ausentes. La función unique() elimina valores repetidos; setequal() compara pertenencia ignorando orden y duplicados, mientras que identical() compara de manera estricta los objetos de R. Las operaciones conjuntistas de R se documentan en [1].
x <- c("a", "b", "a")
A <- unique(x)
A
# [1] "a" "b"
setequal(x, c("b", "a"))
# [1] TRUE
identical(c("a", "b"), c("b", "a"))
# [1] FALSE1.1. Operaciones básicas y leyes verificables
La unión A ∪ B reúne elementos presentes en al menos uno de los conjuntos; la intersección A ∩ B conserva los comunes; la diferencia A ∖ B retiene los que pertenecen a A y no a B. El complemento requiere especificar un universo Ω: Ac = Ω ∖ A. Sin universo explícito, la expresión “todo lo que no está en A” no determina un conjunto concreto.
S <- c("a", "b")
T <- c("b", "c")
Omega <- c("a", "b", "c", "d")
union(S, T) # "a" "b" "c"
intersect(S, T) # "b"
setdiff(S, T) # "a"
setdiff(T, S) # "c"
setdiff(Omega, S) # "c" "d"
all(S %in% union(S, T)) # TRUE: S es subconjunto de S unión TPara conjuntos finitos, la identidad |S ∪ T| = |S| + |T| − |S ∩ T| corrige el doble conteo de los elementos compartidos. Las leyes de De Morgan describen cómo interactúan complemento, unión e intersección: (S ∪ T)c = Sc ∩ Tc y (S ∩ T)c = Sc ∪ Tc. Se justifican examinando la pertenencia de un elemento arbitrario; el script también las verifica en este ejemplo.
2. Preparación del entorno y contrato de lectura
R es el lenguaje y entorno de cálculo; RStudio es una interfaz de desarrollo que permite trabajar con R. El código también puede ejecutarse en la consola de R o mediante Rscript. Los ejemplos básicos utilizan R y sus paquetes estándar; las enumeraciones adicionales recurren a gtools, y se conserva rje::powerSet() como alternativa para el conjunto potencia [7].
# Ejecutar una sola vez si no están instalados:
# install.packages(c("gtools", "rje"))
A <- c("a", "b", "c") # Ejemplo pequeño e inspeccionable
B <- c(1, 2, 3)
conjunto <- 1:10 # Caso numérico de referencia
n <- length(conjunto)
k <- 3 # Longitud de selección, cuando correspondaLas salidas precedidas por # son comentarios que anticipan resultados, no instrucciones adicionales. Las secciones siguientes contienen fragmentos didácticos; el script completo reúne las funciones auxiliares y las comprobaciones en un orden ejecutable. Los nombres de paquetes se explicitan con paquete::funcion() para identificar de dónde procede cada operación.
Las representaciones visuales y las tablas se construyen como texto y HTML accesible. Esto permite seleccionar los símbolos, ampliar la página y consultar las fórmulas sin depender de capturas de pantalla.
3. Producto cartesiano: construir pares y tuplas
Dados dos conjuntos A y B, su producto cartesiano A × B es el conjunto de todos los pares ordenados (a, b) tales que a pertenece a A y b pertenece a B. Si ambos son finitos, cada elemento de A puede emparejarse con cada elemento de B:
|A × B| = |A| · |B|
Las barras verticales indican cardinalidad.
El producto cartesiano conserva la posición de las coordenadas. En general, A × B y B × A son conjuntos diferentes, aunque tengan la misma cardinalidad. Si ambos factores son el mismo conjunto, pueden aparecer pares como (a, a): compartir el conjunto de origen no obliga a que las coordenadas sean distintas.
| A / B | 1 | 2 | 3 |
|---|---|---|---|
| a | (a, 1) | (a, 2) | (a, 3) |
| b | (b, 1) | (b, 2) | (b, 3) |
| c | (c, 1) | (c, 2) | (c, 3) |
En R, expand.grid() produce una fila por cada combinación de coordenadas. Aquí, “combinación” en la documentación de la función alude a una configuración de valores de las variables, no a una selección sin orden en el sentido combinatorio de las secciones posteriores. Especificamos stringsAsFactors = FALSE para conservar el texto como texto y omitimos atributos auxiliares con KEEP.OUT.ATTRS = FALSE [2].
producto <- expand.grid(
A = A, B = B,
KEEP.OUT.ATTRS = FALSE,
stringsAsFactors = FALSE
)
nrow(producto)
# [1] 9
producto_10 <- expand.grid(
x = conjunto, y = conjunto,
KEEP.OUT.ATTRS = FALSE,
stringsAsFactors = FALSE
)
nrow(producto_10)
# [1] 100Para k coordenadas elegidas en A, escribimos Ak. Si |A| = n, entonces |Ak| = nk. Para k = 0 se adopta A0 = {()}, el conjunto que contiene la tupla vacía. Esta convención mantiene la cardinalidad igual a 1 incluso cuando A es vacío.
4. Conjunto potencia: todos los subconjuntos
El conjunto potencia de A, escrito 𝒫(A), reúne todos sus subconjuntos, incluidos ∅ y el propio A. Cada elemento de A enfrenta dos posibilidades al construir un subconjunto: se incluye o no se incluye. Para n elementos distintos, el principio multiplicativo da:
|𝒫(A)| = 2n
Para A = {a, b, c}, los ocho subconjuntos pueden agruparse según su tamaño. Esta disposición por niveles hace visible la distribución 1, 3, 3, 1; para representar un diagrama de Hasse completo habría que añadir las relaciones de cobertura entre niveles contiguos.
Podemos construirlo con R estándar enumerando combinaciones de cada tamaño. En el código se emplean índices, para evitar que un vector numérico de longitud uno sea interpretado por combn() como un tamaño de población.
A <- c("a", "b", "c")
PA <- list(A[0]) # Una lista que CONTIENE el subconjunto vacío
for (k in seq_len(length(A))) {
indices <- utils::combn(seq_along(A), k, simplify = FALSE)
PA <- c(PA, lapply(indices, function(i) A[i]))
}
length(PA)
# [1] 8
# Alternativa con el paquete empleado en la versión inicial:
# PA <- rje::powerSet(A)
# P10 <- rje::powerSet(1:10)
# length(P10) # 10244.1. Por qué el conjunto potencia es una σ-álgebra
Una σ-álgebra ℱ sobre un universo Ω es una familia de subconjuntos que contiene Ω, es cerrada bajo complementos relativos a Ω y es cerrada bajo uniones numerables. De estas condiciones se sigue que también contiene ∅. El conjunto potencia 𝒫(Ω) satisface estas condiciones porque contiene todos los subconjuntos posibles de Ω [6].
Sin embargo, “conjunto potencia” y “σ-álgebra” no son sinónimos. Sobre Ω = {a, b, c}, tanto {∅, Ω} como {∅, {a}, {b, c}, Ω} son σ-álgebras; ninguna coincide con los ocho elementos de 𝒫(Ω). La primera solo distingue el evento imposible del seguro; la segunda distingue el bloque {a} del bloque {b, c}.
En un universo finito, toda familia de subconjuntos es finita. Por ello, comprobar cierre por uniones binarias, junto con los demás axiomas, permite establecer cierre por uniones numerables: en una unión numerable solo interviene un número finito de subconjuntos distintos. El script ofrece un verificador para este escenario finito. Tal procedimiento no se extrapola sin más a universos infinitos.
4.2. Relación con las combinaciones
Los subconjuntos de A quedan particionados por sus tamaños. Hay exactamente un subconjunto de tamaño cero, n de tamaño uno y, en general, un número binomial de tamaño k. Por tanto:
El resultado cuenta todos los subconjuntos una vez, incluidos el vacío y el conjunto completo.
La correspondencia entre un subconjunto y su vector de indicadores de pertenencia también establece una biyección entre 𝒫(A) y {0, 1}n. Es una conexión estructural con las secuencias binarias, no una mera coincidencia numérica.
5. Selecciones ordenadas sin repetición
Elegimos k elementos distintos entre n disponibles y asignamos una posición a cada uno. Para la primera posición hay n posibilidades; para la segunda, n − 1; y así sucesivamente. Para 0 ≤ k ≤ n:
Estas construcciones se denominan también variaciones, arreglos o permutaciones parciales sin repetición, según la tradición terminológica. Cuando k = n se obtienen las permutaciones completas: P(n, n) = n!. Si k > n no hay selecciones posibles sin repetición, y para k = 0 hay una única selección vacía.
Con A = {a, b, c} y k = 2 obtenemos seis secuencias: (a, b), (a, c), (b, a), (b, c), (c, a) y (c, b). Una misma pareja de símbolos puede aparecer en dos órdenes distintos.
n <- 10
k <- 3
prod(n - seq_len(k) + 1)
# [1] 720
# Enumeración pequeña; requiere gtools:
# p2 <- gtools::permutations(3, 2, v = A)
# nrow(p2) # 6El producto descendente evita calcular dos factoriales grandes por separado, aunque también puede desbordar para tamaños elevados. La función general del script trata primero k = 0, de modo que no construye intervalos descendentes engañosos.
5.1. Sumar longitudes diferentes
Contar todas las secuencias no vacías de longitudes 1 a n corresponde a sumar P(n, k), no a calcular una sola permutación. Para n = 10, el total es 9.864.100; si incluimos la tupla vacía, asciende a 9.864.101. Las longitudes distinguen objetos: una secuencia de dos posiciones nunca es la misma que una de tres.
n <- 10
conteos <- vapply(seq_len(n), function(k) {
prod(n - seq_len(k) + 1)
}, numeric(1))
sum(conteos)
# [1] 98641006. Selecciones ordenadas con repetición libre
Si un símbolo puede reaparecer en cada posición, siempre hay n opciones y no se reduce el conjunto disponible. Las secuencias de longitud k forman el producto cartesiano Ak:
Para A = {a, b, c} y k = 2, los nueve resultados son (a, a), (a, b), (a, c), (b, a), (b, b), (b, c), (c, a), (c, b) y (c, c). Respecto del apartado anterior, se han añadido los pares de símbolos iguales.
n <- 10
k <- 3
n^k
# [1] 1000
# Con repetición libre, indicado de manera explícita:
# r2 <- gtools::permutations(
# 3, 2, v = A, repeats.allowed = TRUE
# )
# nrow(r2) # 9
# Sin paquetes externos para el caso de dos posiciones:
pares <- expand.grid(x = A, y = A,
KEEP.OUT.ATTRS = FALSE,
stringsAsFactors = FALSE)
nrow(pares)
# [1] 9Para n = 10 y k = 10, el conteo es 10.000.000.000. Aquí conviene calcular la cardinalidad y detenerse: no es un ejemplo razonable para generar de forma exhaustiva en una computadora corriente. La protección de memoria del script impide esa enumeración.
7. Combinaciones sin repetición: elegir subconjuntos
Ahora elegimos k elementos distintos y dejamos de distinguir el orden. Cada subconjunto de tamaño k da lugar a k! secuencias ordenadas. Al dividir el conteo anterior por esa cantidad obtenemos:
Dominio factorial: 0 ≤ k ≤ n. Por convenio combinatorio, C(n, k) = 0 cuando k > n.
Con A = {a, b, c} y k = 2, hay tres subconjuntos: {a, b}, {a, c} y {b, c}. Que un programa escriba {a, b} siguiendo el orden del vector de entrada no significa que el subconjunto tenga posiciones.
choose(10, 3)
# [1] 120
A <- c("a", "b", "c")
indices <- utils::combn(seq_along(A), 2, simplify = FALSE)
subconjuntos <- lapply(indices, function(i) A[i])
length(subconjuntos)
# [1] 3
# Otra representación: cada columna es una combinación.
utils::combn(A, 2)
# [,1] [,2] [,3]
# [1,] "a" "a" "b"
# [2,] "b" "c" "c"choose() calcula cardinalidades; combn() genera selecciones. Por defecto, la segunda organiza los resultados por columnas, mientras que gtools::combinations() los organiza por filas. Confundir estas orientaciones lleva a contar la longitud de la selección en lugar de la cantidad de selecciones [3].
Para un conjunto de diez elementos, sumar las combinaciones de tamaños 1 a 10 da 1.023 subconjuntos no vacíos. Al añadir el vacío obtenemos los 1.024 elementos de su conjunto potencia. La igualdad C(n, k) = C(n, n − k) se explica, además, mediante la biyección que asigna a cada subconjunto su complemento.
8. Combinaciones con repetición: elegir multiplicidades
Tenemos n tipos disponibles, elegimos un total de k unidades y permitimos repetir tipos, sin distinguir posiciones. Un resultado puede describirse mediante multiplicidades enteras no negativas x₁, …, xₙ que satisfacen:
Para n ≥ 1, el método de estrellas y barras representa las k unidades mediante estrellas y separa las n categorías con n − 1 barras. Elegir las posiciones de las estrellas entre k + n − 1 lugares equivale a elegir las multiplicidades:
Con A = {a, b, c} y k = 2, las seis selecciones son {a, a}, {a, b}, {a, c}, {b, b}, {b, c} y {c, c}. En particular, {a, b} y {b, a} representan el mismo resultado. Para n = 10 y k = 3, el conteo asciende a 220.
n <- 10
k <- 3
choose(n + k - 1, k)
# [1] 220
# Enumeración pequeña; requiere gtools:
# m2 <- gtools::combinations(
# 3, 2, v = A, repeats.allowed = TRUE
# )
# nrow(m2) # 6Como ejemplo visual adicional, con los cuatro símbolos {1, 2, 3, 4} y tamaño 2, las selecciones son 11, 12, 13, 14, 22, 23, 24, 33, 34 y 44. Son diez combinaciones con repetición; las secuencias ordenadas serían dieciséis porque distinguirían, por ejemplo, 12 de 21. Un árbol que enumera solo esas diez ramas corresponde a esta sección.
9. APPLE: permutar un multiconjunto fijo
La palabra APPLE tiene cinco posiciones, pero cuatro tipos de letras: A, P, L y E. La letra P aparece dos veces. Si intercambiamos esas dos P, la palabra visible no cambia. Por eso, sus reordenamientos distintos no son 5!, ni tampoco las secuencias libres de cinco letras tomadas de cuatro símbolos.
Cuando n objetos tienen multiplicidades fijadas m₁, …, mᵣ cuya suma es n, cada secuencia visible se contabiliza m₁! ··· mᵣ! veces si distinguimos artificialmente todos los objetos. Al eliminar esa distinción:
NAPPLE = 5!1! · 2! · 1! · 1! = 60
letras <- strsplit("APPLE", "", fixed = TRUE)[[1]]
multiplicidades <- as.numeric(table(letras))
factorial(length(letras)) / prod(factorial(multiplicidades))
# [1] 60La distinción es doble: las combinaciones con repetición eligen las multiplicidades; las permutaciones de un multiconjunto las reciben ya fijadas y cuentan los órdenes posibles. El script verifica el ejemplo APPLE mediante una enumeración pequeña: permuta las cinco posiciones y elimina las palabras repetidas. Esa estrategia es didáctica; resulta ineficiente para multiconjuntos grandes porque genera duplicados antes de descartarlos.
La fórmula correcta depende de qué diferencias conserva el objeto que queremos contar.
10. Cuadro comparativo y totales por longitud
Las siguientes fórmulas responden a problemas diferentes. Para n = 10 y k = 3, su contraste muestra cuánto cambia el conteo al modificar la importancia del orden o la posibilidad de repetición.
| Construcción | Orden | Repetición | Cardinalidad | Resultado |
|---|---|---|---|---|
| Ordenadas sin repetición | Importa | No | n! / (n − k)! | 720 |
| Ordenadas con repetición libre | Importa | Sí | nk | 1.000 |
| Combinaciones sin repetición | No importa | No | C(n, k) | 120 |
| Combinaciones con repetición | No importa | Sí | C(n + k − 1, k) | 220 |
Las dos fórmulas sin repetición requieren k ≤ n para usar la expresión factorial. La fórmula de combinaciones con repetición se aplica directamente para n ≥ 1. Todos los modelos incluyen una selección vacía cuando k = 0.
| Objeto | Contar | Enumerar en ejemplos pequeños |
|---|---|---|
| Producto A × B | length(A) * length(B) | expand.grid() |
| Conjunto potencia | 2^length(A) | potencia() del script; rje::powerSet() |
| Ordenadas sin repetición | contar_ordenadas(n, k) | gtools::permutations() |
| Ordenadas con repetición | n^k | gtools::permutations(..., repeats.allowed = TRUE) |
| Combinaciones sin repetición | choose(n, k) | utils::combn() |
| Combinaciones con repetición | choose(n + k - 1, k) | gtools::combinations(..., repeats.allowed = TRUE) |
10.1. Los once tamaños del caso n = 10
La fila k = 0 resulta indispensable para mantener las identidades que incluyen el objeto vacío. La tabla presenta conteos, sin generar las colecciones correspondientes.
| k | Ordenadas sin repetición | Ordenadas con repetición | Combinaciones sin repetición | Combinaciones con repetición |
|---|---|---|---|---|
| 0 | 1 | 1 | 1 | 1 |
| 1 | 10 | 10 | 10 | 10 |
| 2 | 90 | 100 | 45 | 55 |
| 3 | 720 | 1.000 | 120 | 220 |
| 4 | 5.040 | 10.000 | 210 | 715 |
| 5 | 30.240 | 100.000 | 252 | 2.002 |
| 6 | 151.200 | 1.000.000 | 210 | 5.005 |
| 7 | 604.800 | 10.000.000 | 120 | 11.440 |
| 8 | 1.814.400 | 100.000.000 | 45 | 24.310 |
| 9 | 3.628.800 | 1.000.000.000 | 10 | 48.620 |
| 10 | 3.628.800 | 10.000.000.000 | 1 | 92.378 |
10.2. Totales no vacíos: k de 1 a 10
| Familia | Suma | Total |
|---|---|---|
| Ordenadas sin repetición | ∑ P(10, k) | 9.864.100 |
| Ordenadas con repetición libre | ∑ 10k | 11.111.111.110 |
| Combinaciones sin repetición | 210 − 1 | 1.023 |
| Combinaciones con repetición | C(20, 10) − 1 | 184.755 |
El último resultado se obtiene de la identidad ∑k=0m C(n + k − 1, k) = C(n + m, m), para n ≥ 1. Una justificación consiste en añadir una categoría auxiliar que absorba las unidades faltantes hasta llegar a m: elegir hasta m unidades entre n tipos equivale a distribuir exactamente m unidades entre n + 1 tipos. Quitamos una unidad del conteo final para excluir la selección vacía.
Con repetición libre y al menos un símbolo disponible, dejar crecer k sin cota produce infinitas secuencias y también infinitos multiconjuntos finitos. Por eso debe indicarse el intervalo de tamaños cuando se presenta un “total”.
n <- 10
ks <- 0:n
resumen <- data.frame(
k = ks,
ordenadas_sin = vapply(ks, function(k) {
if (k == 0) 1 else prod(n - seq_len(k) + 1)
}, numeric(1)),
ordenadas_con = n^ks,
combinaciones_sin = choose(n, ks),
combinaciones_con = choose(n + ks - 1, ks)
)
colSums(resumen[-1, -1])
# ordenadas_sin ordenadas_con
# 9864100 11111111110
# combinaciones_sin combinaciones_con
# 1023 18475511. Escalabilidad, límites y precisión numérica
Conocer una cardinalidad no obliga a materializar todos los objetos. Una matriz hipotética con 1010 filas, diez columnas y ocho bytes por celda necesitaría alrededor de 800 GB decimales solo para los datos, antes de contar estructuras auxiliares y copias temporales. Es una estimación para esa representación concreta; el consumo real depende del tipo de dato y del algoritmo.
Por ello, el script establece límites didácticos de 100.000 resultados y 1.000.000 de celdas estimadas antes de enumerar. Esos límites no garantizan que cualquier trabajo admitido sea rápido o que use poca memoria; impiden que los ejemplos más grandes se ejecuten accidentalmente. Para tareas de mayor escala conviene estudiar generación perezosa, recorridos parciales o algoritmos específicos.
11.1. Desbordamiento y aritmética aproximada
Los números de tipo double de R no representan exactamente todos los enteros arbitrariamente grandes. Aun cuando el resultado no sea infinito, puede haber redondeo. El cociente de factoriales tampoco evita ese problema: los factoriales intermedios pueden desbordar aunque el resultado final sea representable.
choose() calcula coeficientes binomiales y lchoose() permite obtener su logaritmo sin formar primero la cantidad completa; lfactorial() cumple una función análoga para factoriales [5]. Para un orden de magnitud:
# Logaritmo decimal de C(2000, 1000):
log10_binomial <- lchoose(2000, 1000) / log(10)
log10_binomial
# Aproximadamente 600.3114
# Logaritmo de P(n, k), dentro del dominio 0 <= k <= n:
n <- 1000
k <- 500
log_P <- lfactorial(n) - lfactorial(n - k)Trabajar con logaritmos reduce problemas de rango numérico; no convierte un cálculo en aritmética entera exacta. Tampoco conviene exponenciar automáticamente un logaritmo enorme, porque puede reaparecer el desbordamiento. Si se necesitan todos los dígitos de un entero grande, hace falta una herramienta de precisión arbitraria elegida y validada para ese propósito.
11.2. Qué verifican las comprobaciones
El script compara conteos con enumeraciones pequeñas, revisa las identidades de suma y comprueba casos frontera. También evita confundir una lista vacía con una lista que contiene la selección vacía. Estas pruebas detectan errores de implementación, convenciones inconsistentes y regresiones. Las explicaciones mediante biyecciones y principios de conteo justifican los resultados más allá de la malla finita comprobada.
12. Interpretación matemática y aplicaciones
Las construcciones anteriores se relacionan mediante funciones y correspondencias concretas. Al olvidar el orden de una secuencia sin repetición de longitud k obtenemos un subconjunto de tamaño k, y cada subconjunto tiene k! preimágenes. Si permitimos repeticiones, olvidar el orden produce un multiconjunto; en ese caso el número de secuencias que corresponde a cada multiconjunto depende de sus multiplicidades.
Esta diferencia explica por qué no es válido dividir nk por k! para obtener, en general, el número de combinaciones con repetición. Para A = {a, b} y k = 2, las secuencias aa y bb tienen cada una un único orden visible, mientras que ab y ba se agrupan en el mismo multiconjunto. El tamaño de los grupos no es uniforme.
12.1. Probabilidad: enumerar no fija la distribución
Supongamos dos extracciones independientes con reemplazo de un mecanismo que produce a y b con probabilidad 1/2 cada uno. Las secuencias aa, ab, ba y bb tienen probabilidad 1/4. Al olvidar el orden, los tres multiconjuntos {a, a}, {a, b} y {b, b} tienen probabilidades 1/4, 1/2 y 1/4. Por tanto, escoger uniformemente un multiconjunto entre los tres no reproduce el mismo experimento.
La fórmula “casos favorables / casos posibles” exige equiprobabilidad de los resultados que se están contando. Definir el espacio muestral, el mecanismo de selección y la distribución es un paso adicional a enumerar objetos.
12.2. Diseño experimental y ciencia de datos
- Producto cartesiano: construir todas las configuraciones de una rejilla de parámetros o todas las combinaciones de niveles de factores. Si los factores tienen tamaños distintos, se multiplican sus cardinalidades.
- Conjunto potencia: describir selecciones posibles de variables. Un conjunto de n variables admite 2n subconjuntos, incluido el modelo sin predictores seleccionados.
- Ordenadas sin repetición: asignar puestos distintos a personas diferentes, con un candidato por puesto y sin reutilización.
- Combinaciones sin repetición: seleccionar comités o subconjuntos de observaciones cuando el orden de selección no forma parte del resultado.
- Combinaciones con repetición: distribuir unidades indistinguibles entre categorías identificadas, con cantidades no negativas y sin límites superiores.
Cada aplicación necesita revisar sus supuestos. La presencia de incompatibilidades entre factores, inventarios limitados, probabilidades desiguales o restricciones adicionales cambia el problema. Una tabla de fórmulas orienta la elección; la definición del objeto y del mecanismo determina cuál es pertinente.
12.3. Alcance epistemológico
La representación informática selecciona qué información retener. Convertir una secuencia en un conjunto elimina orden y multiplicidad; convertirla en un multiconjunto elimina orden, pero conserva frecuencias. Estas transformaciones permiten observar que una abstracción matemática no es un simple cambio de nombre: modifica las distinciones que organizan el problema y, con ellas, los resultados de conteo.
La experimentación computacional resulta más informativa cuando esa selección se vuelve explícita. Definir, representar, deducir, ejecutar y contrastar son momentos complementarios de una investigación reproducible sobre objetos finitos.
13. Script completo reproducible
El siguiente programa integra el artículo. Copiá su contenido en un archivo de texto llamado conjuntos_combinatoria.R, guardalo como UTF-8 y ejecutalo con source("conjuntos_combinatoria.R", encoding = "UTF-8") o con Rscript conjuntos_combinatoria.R. Los paquetes externos se usan solo si están instalados; el programa informa si omite esos bloques.
Las funciones de conteo validan tamaños enteros no negativos. Los enumeradores representan cada selección como un vector dentro de una lista, incluidos los casos vacíos. La protección de tamaño se aplica antes de llamar a los enumeradores. El dominio de representación se limita a vectores numéricos finitos y de texto, sin valores ausentes; para conjuntos de objetos más complejos se necesita diseñar una relación de igualdad adecuada.
Abrir el script completo · funciones, ejemplos y comprobaciones
# CONJUNTOS Y COMBINATORIA EN R
# JOSÉ MAURICIO GÓMEZ JULIÁN
# Script del artículo. Guardar como conjuntos_combinatoria.R (UTF-8).
# Los ejemplos base no requieren paquetes externos.
# install.packages(c("gtools", "rje")) # Solo si se desean los bloques opcionales.
# 1. Validación y funciones de conteo -------------------------------
entero_no_negativo <- function(x, nombre) {
if (!is.numeric(x) || is.complex(x) || length(x) != 1L || is.na(x) ||
!is.finite(x) || x < 0 || x != floor(x)) {
stop(nombre, " debe ser un entero no negativo y finito.")
}
invisible(TRUE)
}
validar_nk <- function(n, k) {
entero_no_negativo(n, "n")
entero_no_negativo(k, "k")
}
normalizar_conjunto <- function(x) {
if ((!is.numeric(x) && !is.character(x)) || is.complex(x) ||
!is.null(dim(x)) || anyNA(x) ||
(is.numeric(x) && any(!is.finite(x)))) {
stop("Usar un vector numérico finito o de texto, sin NA ni dimensiones.")
}
unique(x)
}
contar_ordenadas <- function(n, k, repeticion = FALSE) {
validar_nk(n, k)
if (!is.logical(repeticion) || length(repeticion) != 1L ||
is.na(repeticion)) stop("repeticion debe ser TRUE o FALSE.")
if (k == 0) return(1)
if (repeticion) return(n^k)
if (k > n) return(0)
# Producto descendente: evita formar dos factoriales por separado.
prod(n - seq_len(k) + 1)
}
contar_combinaciones <- function(n, k, repeticion = FALSE) {
validar_nk(n, k)
if (!is.logical(repeticion) || length(repeticion) != 1L ||
is.na(repeticion)) stop("repeticion debe ser TRUE o FALSE.")
if (k == 0) return(1)
if (n == 0) return(0)
if (repeticion) return(choose(n + k - 1, k))
if (k > n) return(0)
choose(n, k)
}
limitar_enumeracion <- function(filas, columnas,
max_filas = 1e5,
max_celdas = 1e6) {
if (!is.finite(filas) || filas > max_filas ||
filas * max(1, columnas) > max_celdas) {
stop("Enumeración detenida por el límite didáctico; calcular solo el conteo.")
}
invisible(TRUE)
}
# Todas las enumeraciones devuelven listas de vectores.
# El caso k=0 devuelve list(x[0]): una lista con un vector vacío.
enumerar_ordenadas <- function(x, k, repeticion = FALSE) {
x <- normalizar_conjunto(x)
n <- length(x)
total <- contar_ordenadas(n, k, repeticion)
limitar_enumeracion(total, k)
if (k == 0) return(list(x[0]))
if (total == 0) return(list())
if (!requireNamespace("gtools", quietly = TRUE)) {
stop("Este enumerador requiere gtools: install.packages('gtools').")
}
m <- gtools::permutations(n, k, v = x,
repeats.allowed = repeticion)
lapply(seq_len(nrow(m)), function(i) unname(m[i, ]))
}
enumerar_combinaciones <- function(x, k, repeticion = FALSE) {
x <- normalizar_conjunto(x)
n <- length(x)
total <- contar_combinaciones(n, k, repeticion)
limitar_enumeracion(total, k)
if (k == 0) return(list(x[0]))
if (total == 0) return(list())
if (!repeticion) {
# Usar índices evita que combn(5, 1) interprete 5 como 1:5.
indices <- utils::combn(seq_len(n), k, simplify = FALSE)
return(lapply(indices, function(i) x[i]))
}
if (!requireNamespace("gtools", quietly = TRUE)) {
stop("Este enumerador requiere gtools: install.packages('gtools').")
}
m <- gtools::combinations(n, k, v = x, repeats.allowed = TRUE)
lapply(seq_len(nrow(m)), function(i) unname(m[i, ]))
}
potencia <- function(x) {
x <- normalizar_conjunto(x)
n <- length(x)
limitar_enumeracion(2^n, n)
resultado <- list(x[0])
for (k in seq_len(n)) {
resultado <- c(resultado, enumerar_combinaciones(x, k))
}
resultado
}
mostrar_familia <- function(F) {
vapply(F, function(x) {
if (length(x) == 0) "{}" else paste0("{", paste(x, collapse = ", "), "}")
}, character(1))
}
# 2. Conjuntos y producto cartesiano -------------------------------
A <- c("a", "b", "c")
B <- c(1, 2, 3)
conjunto <- 1:10
n <- length(conjunto)
stopifnot(
setequal(c("a", "b", "a"), c("b", "a")),
!identical(c("a", "b"), c("b", "a")),
identical(normalizar_conjunto(c(1, 1, 2)), c(1, 2))
)
producto <- expand.grid(A = A, B = B,
KEEP.OUT.ATTRS = FALSE, stringsAsFactors = FALSE)
stopifnot(nrow(producto) == length(A) * length(B))
producto_10 <- expand.grid(x = conjunto, y = conjunto,
KEEP.OUT.ATTRS = FALSE, stringsAsFactors = FALSE)
stopifnot(nrow(producto_10) == 100)
print(producto)
# Operaciones y leyes de conjuntos en un universo explícito.
S <- c("a", "b")
T <- c("b", "c")
Omega <- c("a", "b", "c", "d")
stopifnot(
length(union(S, T)) == length(S) + length(T) - length(intersect(S, T)),
setequal(setdiff(Omega, union(S, T)),
intersect(setdiff(Omega, S), setdiff(Omega, T))),
setequal(setdiff(Omega, intersect(S, T)),
union(setdiff(Omega, S), setdiff(Omega, T)))
)
# 3. Conjunto potencia y sigma-álgebra finita ----------------------
PA <- potencia(A)
P10 <- potencia(conjunto)
stopifnot(length(PA) == 8, length(P10) == 1024,
sum(lengths(PA) == 0) == 1)
print(mostrar_familia(PA))
contiene <- function(x, F) {
any(vapply(F, function(y) setequal(x, y), logical(1)))
}
es_sigma_finita <- function(F, omega) {
if (!is.list(F)) return(FALSE)
if (!all(vapply(F, function(x) all(x %in% omega), logical(1)))) {
return(FALSE)
}
if (!contiene(omega[0], F) || !contiene(omega, F)) return(FALSE)
for (x in F) {
if (!contiene(setdiff(omega, x), F)) return(FALSE)
for (y in F) if (!contiene(union(x, y), F)) return(FALSE)
}
TRUE
}
F_min <- list(A[0], A)
F_intermedia <- list(A[0], "a", c("b", "c"), A)
stopifnot(es_sigma_finita(F_min, A),
es_sigma_finita(F_intermedia, A),
es_sigma_finita(PA, A),
!es_sigma_finita(list(A[0], "a", A), A))
# En un universo finito, cierre por uniones binarias basta aquí:
# cualquier unión numerable solo reúne un número finito de subconjuntos distintos.
# 4. Enumeración base de secuencias pequeñas -----------------------
pares <- expand.grid(x = A, y = A,
KEEP.OUT.ATTRS = FALSE, stringsAsFactors = FALSE)
sin_repeticion <- pares[pares$x != pares$y, , drop = FALSE]
stopifnot(nrow(pares) == 9, nrow(sin_repeticion) == 6,
length(enumerar_combinaciones(A, 2)) == 3)
# 5. Cuadro de conteos para n=10, k=0,...,10 ------------------------
ks <- 0:n
resumen <- data.frame(
k = ks,
ordenadas_sin = vapply(ks, function(k) contar_ordenadas(n, k), numeric(1)),
ordenadas_con = vapply(ks, function(k) contar_ordenadas(n, k, TRUE), numeric(1)),
combinaciones_sin = vapply(ks, function(k) contar_combinaciones(n, k), numeric(1)),
combinaciones_con = vapply(ks, function(k) contar_combinaciones(n, k, TRUE), numeric(1))
)
print(resumen, row.names = FALSE)
stopifnot(sum(resumen$combinaciones_sin) == 2^n,
sum(resumen$combinaciones_sin[-1]) == 1023,
sum(resumen$ordenadas_sin[-1]) == 9864100,
sum(resumen$ordenadas_con[-1]) == 11111111110,
sum(resumen$combinaciones_con[-1]) == 184755)
# Las listas de todas las longitudes se ilustran con n=3.
# No se enumeran millones de secuencias de n=10.
combinaciones_por_k <- lapply(0:length(A), function(k) {
enumerar_combinaciones(A, k)
})
stopifnot(sum(lengths(combinaciones_por_k)) == 8)
# 6. APPLE: permutaciones de un multiconjunto -----------------------
letras <- strsplit("APPLE", "", fixed = TRUE)[[1]]
multiplicidades <- as.numeric(table(letras))
numero_apple <- factorial(length(letras)) /
prod(factorial(multiplicidades))
stopifnot(numero_apple == 60)
# 7. Casos frontera y protección de memoria ------------------------
stopifnot(contar_ordenadas(0, 0) == 1,
contar_ordenadas(0, 0, TRUE) == 1,
contar_ordenadas(0, 2, TRUE) == 0,
contar_ordenadas(2, 3) == 0,
contar_combinaciones(0, 0, TRUE) == 1,
contar_combinaciones(0, 2, TRUE) == 0,
length(potencia(numeric(0))) == 1,
identical(enumerar_combinaciones(5, 1), list(5)),
length(enumerar_combinaciones(A, 0)) == 1)
fallo_esperado <- tryCatch({
limitar_enumeracion(10^10, 10)
FALSE
}, error = function(e) TRUE)
stopifnot(fallo_esperado)
# Conteos grandes: trabajar en escala logarítmica no da aritmética exacta.
log10_binomial <- lchoose(2000, 1000) / log(10)
print(log10_binomial)
# 8. Bloque opcional: gtools ---------------------------------------
if (requireNamespace("gtools", quietly = TRUE)) {
p2 <- enumerar_ordenadas(A, 2)
r2 <- enumerar_ordenadas(A, 2, TRUE)
c2 <- enumerar_combinaciones(A, 2)
m2 <- enumerar_combinaciones(A, 2, TRUE)
stopifnot(length(p2) == 6, length(r2) == 9,
length(c2) == 3, length(m2) == 6)
# Comparar objetos generados y fórmulas en una malla pequeña.
for (nn in 1:4) {
xx <- letters[seq_len(nn)]
for (kk in 0:4) {
for (rr in c(FALSE, TRUE)) {
stopifnot(
length(enumerar_ordenadas(xx, kk, rr)) ==
contar_ordenadas(nn, kk, rr),
length(enumerar_combinaciones(xx, kk, rr)) ==
contar_combinaciones(nn, kk, rr)
)
}
}
}
ordenadas_por_k <- lapply(0:length(A), function(k) {
enumerar_ordenadas(A, k)
})
stopifnot(sum(lengths(ordenadas_por_k)) == 16)
# APPLE: primero distinguir posiciones; después quitar palabras duplicadas.
posiciones <- gtools::permutations(length(letras), length(letras))
palabras <- apply(posiciones, 1, function(i) paste0(letras[i], collapse = ""))
palabras_apple <- unique(palabras)
stopifnot(length(palabras_apple) == numero_apple)
print(head(palabras_apple))
} else {
message("gtools no instalado: se omiten sus ejemplos; los conteos base se ejecutaron.")
}
# 9. Bloque opcional: rje ------------------------------------------
if (requireNamespace("rje", quietly = TRUE)) {
PA_rje <- rje::powerSet(A)
stopifnot(length(PA_rje) == 8,
all(vapply(PA_rje, function(x) contiene(x, PA), logical(1))))
} else {
message("rje no instalado: se usó la construcción base del conjunto potencia.")
}
cat("Comprobaciones ejecutadas sin errores.\n")
sessionInfo()
La salida de sessionInfo() registra la versión de R, la plataforma y los paquetes cargados o asociados al espacio de nombres. Conviene conservarla junto con los resultados. La ausencia de gtools o rje no se interpreta como una comprobación exitosa de sus respectivos bloques: esos ejemplos se omiten con un mensaje explícito.
14. Referencias y documentación
Las referencias siguientes respaldan las funciones utilizadas y la precisión conceptual sobre σ-álgebras. Las explicaciones de conteo se desarrollan en el cuerpo del artículo mediante principios multiplicativos, biyecciones y argumentos de identificación de resultados.
- R Core Team. Set Operations. Documentación oficial del paquete base. Operaciones de unión, intersección, diferencia y comparación de conjuntos. Consultar documentación.
- R Core Team. Create a Data Frame from All Combinations of Factor Variables. Documentación de
expand.grid(). Consultar documentación. - R Core Team. Generate All Combinations of n Elements, Taken m at a Time. Documentación de
utils::combn(). Consultar documentación. - Documentación del paquete gtools. Enumerate the Combinations or Permutations of the Elements of a Vector. Referencia de
combinations(),permutations()y sus argumentos. Consultar documentación en CRAN. - R Core Team. Special Functions of Mathematics. Documentación de
choose(),lchoose(),factorial()ylfactorial(). Consultar documentación. - Kehle, Christoph (2025). Introduction to Functional Analysis. Apuntes de 18.102, Massachusetts Institute of Technology, sección 3.1, definición 3.1 y ejemplo, pp. 25–26. Definición de σ-álgebra y ejemplo del conjunto potencia con medida de conteo. Consultar apuntes.
- Documentación del paquete rje. Miscellaneous Useful Functions for Statistics. Índice de referencia, entrada
powerSet; puede consultarse también desde R conhelp("powerSet", package = "rje"). Consultar índice del paquete.


Leave a Comment/Deja un Comentario