El dominio es de dónde parte la función, el codominio es donde puede llegar y la imagen es donde realmente llega. Distinguir estos tres conceptos es esencial para entender el comportamiento de cualquier función.
Al escribir f : A → B, los conjuntos A y B tienen papeles distintos y bien definidos. A veces se confunden entre sí o con la imagen, lo que lleva a errores conceptuales frecuentes.
En este tema precisamos cada uno de estos tres conjuntos, analizamos sus diferencias y aprendemos a calcularlos a partir de los pares de la función.
El dominio de una función f : A → B es el conjunto A: el conjunto de todas las entradas posibles. Para que f sea una función, todo elemento del dominio debe tener exactamente una imagen.
El dominio no es el conjunto de valores que aparecen en los pares: es el conjunto completo de entradas que la función debe cubrir. Si algún elemento queda sin imagen, la función no está bien definida.
El codominio de f : A → B es el conjunto B: el conjunto donde viven todas las posibles salidas. El codominio es parte de la definición de la función y no se deduce de los pares: debe declararse explícitamente.
El codominio puede ser más grande que el conjunto de valores que la función realmente alcanza. Contiene todos los valores permitidos, no solo los que se usan.
La imagen (o rango) de f es el conjunto de todos los valores que f realmente alcanza: las segundas componentes de sus pares.
La imagen siempre está contenida en el codominio: Im(f) ⊆ Cod(f). Pueden coincidir o no.
Sea f : {1, 2, 3, 4} → {a, b, c, d, e} definida por:
| Concepto | Valor | Observación |
|---|---|---|
| Dominio | {1, 2, 3, 4} | Todo elemento tiene imagen |
| Codominio | {a, b, c, d, e} | Declarado en la definición de f |
| Imagen | {b, d, a} | Solo los valores realmente alcanzados |
| Elementos sin preimagen | {c, e} | Están en el codominio pero no en la imagen |
Dada la función como lista de pares, podemos extraer dominio, codominio e imagen fácilmente.
const f = [[1, 'b'], [2, 'd'], [3, 'b'], [4, 'a']];
const codominioDeclarado = ['a', 'b', 'c', 'd', 'e'];
// Dominio: primeras componentes de los pares
function dominio(relacion) {
return [...new Set(relacion.map(([a]) => a))];
}
// Imagen: segundas componentes únicas de los pares
function imagen(relacion) {
return [...new Set(relacion.map(([, b]) => b))];
}
// Elementos del codominio sin preimagen
function sinPreimagen(codominio, relacion) {
const img = imagen(relacion);
return codominio.filter(b => !img.includes(b));
}
console.log('Dominio:', dominio(f)); // [1, 2, 3, 4]
console.log('Imagen:', imagen(f)); // ['b', 'd', 'a']
console.log('Sin preimagen:', sinPreimagen(codominioDeclarado, f)); // ['c', 'e']Es importante distinguir dos usos del término "imagen":
| Término | Notación | Qué es | Tipo |
|---|---|---|---|
| Imagen de un elemento a | f(a) | El único b con (a, b) ∈ f | Un elemento de B |
| Imagen de un subconjunto A' | f(A') | {f(a) | a ∈ A'} | Un subconjunto de B |
| Imagen de la función | Im(f) o f(A) | Todos los valores alcanzados | Un subconjunto de B |
const f = [[1, 'b'], [2, 'd'], [3, 'b'], [4, 'a']];
// Imagen de un elemento
function evaluar(funcion, a) {
const par = funcion.find(([x]) => x === a);
return par ? par[1] : undefined;
}
// Imagen de un subconjunto
function imagenSubconjunto(funcion, subA) {
return [...new Set(subA.map(a => evaluar(funcion, a)).filter(v => v !== undefined))];
}
console.log(evaluar(f, 3)); // 'b'
console.log(imagenSubconjunto(f, [1, 2])); // ['b', 'd']
console.log(imagenSubconjunto(f, [1, 2, 3, 4])); // ['b', 'd', 'a']La preimagen (o imagen inversa) de un elemento b ∈ B bajo f es el conjunto de todos los elementos de A que tienen imagen b:
La preimagen de un elemento es un conjunto, no un elemento. Puede ser vacío, tener un elemento o tener varios.
const f = [[1, 'b'], [2, 'd'], [3, 'b'], [4, 'a']];
function preimagen(funcion, b) {
return funcion
.filter(([, y]) => y === b)
.map(([x]) => x);
}
console.log(preimagen(f, 'b')); // [1, 3] ← dos preimágenes
console.log(preimagen(f, 'd')); // [2] ← una preimagen
console.log(preimagen(f, 'c')); // [] ← sin preimagenLa relación entre la imagen y el codominio determina el tipo de función:
function imagen(relacion) {
return [...new Set(relacion.map(([, b]) => b))];
}
function esSobreyectiva(codominio, relacion) {
const img = imagen(relacion);
return codominio.every(b => img.includes(b));
}
const f1 = [[1, 'a'], [2, 'b'], [3, 'c']];
const f2 = [[1, 'a'], [2, 'a'], [3, 'b']];
const codominio = ['a', 'b', 'c'];
console.log(esSobreyectiva(codominio, f1)); // true (Im = Cod)
console.log(esSobreyectiva(codominio, f2)); // false (Im ⊊ Cod, falta 'c')En matemáticas se distingue entre el dominio natural (el mayor conjunto en el que la expresión tiene sentido) y el dominio declarado (el que se especifica explícitamente en la definición). En funciones discretas, siempre trabajamos con el dominio declarado.
// Dominio declarado: solo enteros del 1 al 5
const dominio = [1, 2, 3, 4, 5];
// f(x) = Math.floor(10 / x)
const f = dominio.map(x => [x, Math.floor(10 / x)]);
console.log(f);
// [[1,10],[2,5],[3,3],[4,2],[5,2]]
const img = [...new Set(f.map(([, b]) => b))];
console.log('Imagen:', img); // [10, 5, 3, 2]| Contexto | Dominio | Codominio | Imagen |
|---|---|---|---|
| Función hash MD5 | Cadenas de cualquier longitud | Cadenas de 32 hex | Subconjunto de cadenas de 32 hex |
| parseInt() | Cadenas de texto | Números enteros o NaN | Solo los enteros representados + NaN |
| Array.map(f) | Elementos del array de entrada | Tipo de retorno de f | Valores que f produce para cada elemento |
| Clave primaria → Registro | Claves existentes en la tabla | Todos los registros posibles | Registros almacenados |
Distinguir dominio, codominio e imagen evita confusiones frecuentes y permite caracterizar funciones con precisión. El codominio forma parte de la definición de la función; la imagen es una propiedad que se calcula a partir de ella.
En el próximo tema estudiaremos cómo evaluar funciones discretas: cómo calcular f(a) para un elemento concreto y cómo recorrer todo el dominio para construir la tabla de valores.