Homomorphisms: Structure-Preserving Maps

Learn to spot homomorphisms quickly, compute kernels and images, and use quotient groups to simplify problems. The isomorphism theorems then become a single reusable pattern: every map collapses exactly its kernel and nothing more.

A homomorphism is a function that keeps the algebraic rules intact while possibly identifying different elements. That combination feels like compression. You do not keep every detail of the input, but whatever gets lost is lost in a controlled way. Two elements become the same output exactly when they differ by something that the map treats as invisible.

That is why homomorphisms show up everywhere. They let you replace a complicated object by a simpler one without breaking the operation you care about, so you can compute in the simpler world and translate back.

Why homomorphisms feel like compression

Think of a homomorphism $f:G\to H$ as grouping elements of $G$ into buckets that all land on the same value in $H$ . Inside a bucket, information is intentionally ignored. Across buckets, the group operation still behaves consistently. The key is that the bucket structure is not arbitrary. It is forced by the operation on $G$ .

A surprising payoff is that the part you lose has a name and a shape. It is the kernel, and it fully controls how much collapsing happened.

See the standard factorization pattern that makes this precise.

Once you start looking for it, you notice a repeatable story. First you identify what becomes invisible, then you form a quotient that treats invisible differences as equal, and what remains matches the actual outputs of your map.

Predictable loss
A homomorphism can forget data, but it cannot forget it inconsistently. Whatever gets identified must form the kernel, and the quotient by that kernel is the clean record of what survives.

What it means to preserve operations

A homomorphism is a function that respects the operation that defines your structure.

Groups

For groups, a map $f:G\to H$ is a homomorphism if for all $a,b\in G$ , $f(ab)=f(a)f(b)$ . From this single rule you get two automatic consequences that are worth using as shortcuts. $f(e_G)=e_H$ and $f(a^{-1})=f(a)^{-1}$ .

Rings

For rings, you usually require preservation of addition and multiplication. $f(a+b)=f(a)+f(b)$ and $f(ab)=f(a)f(b)$ . Depending on the course, you may also require $f(1)=1$ . When that matters, it will be stated. If it is not stated, do not assume it.

Vector spaces and modules

For vector spaces (and more generally modules), a linear map is exactly the homomorphism notion for the additive structure plus scalar compatibility. $f(u+v)=f(u)+f(v)$ and $f(cu)=cf(u)$ .

Explore a quick checklist of what must be verified in each setting.

The habit to build is this. Always ask what the operation is, then write the single preservation equation for that operation. Everything else should be derived from it, not memorized as separate requirements.

Three concrete homomorphisms you can compute

You learn homomorphisms by doing three things repeatedly. Write the rule, find the kernel, find the image.

$\mathbb Z\to\mathbb Z_n$ via $f(k)=k\ \text{mod}\ n$ . The operation is addition, so the check is $f(a+b)=f(a)+f(b)$ mod $n$ .
$S_n\to\{\pm1\}$ via the sign map $\operatorname{sgn}(\sigma)$ . Composition in $S_n$ becomes multiplication of signs.
$GL_n(F)\to F^\times$ via $\det(A)$ . Matrix multiplication becomes multiplication of determinants.

These look different, but they share the same anatomy. Each one collapses a large structure onto a smaller one by treating some internal change as irrelevant.

Compare their kernels and images side by side.

Reading that comparison the right way matters. The kernel is not just a set you compute once. It is a statement about what your map cannot detect. For $\mathbb Z\to\mathbb Z_n$ , the map cannot detect adding $n$ . For $\det$ , the map cannot detect multiplying by a determinant $1$ matrix.

Kernel and image are the map’s fingerprints

Given a homomorphism $f:G\to H$ :

The kernel $\ker(f)$ is $\{g\in G\mid f(g)=e_H\}$ .
The image $\operatorname{im}(f)$ is $\{f(g)\mid g\in G\}\subseteq H$ .

These two objects tell you almost everything practical you want to know.

What kernel means structurally

In group theory, $\ker(f)$ is always a normal subgroup, so quotienting by it makes sense. In ring theory, the kernel is an ideal. For linear maps, the kernel is a subspace.

So computing a kernel is not just solving an equation like $f(g)=e$ . It is producing the exact kind of subobject that quotients are built from.

What image means structurally

The image is the part of $H$ your map can actually reach. In group settings it is a subgroup, in vector spaces it is a subspace. Surjective means the image is all of $H$ . Injective means the kernel is trivial.

Watch how changing a parameter changes what gets collapsed and what remains visible.

A good workflow for examples is to compute kernel first, then image, then check injective or surjective. The kernel often drops out from solving one equation, while the image can require a bit of thought about what outputs are possible.

Quotients and the canonical projection

Quotients often feel abstract until you connect them to a map you already have. Start with a subgroup $N\triangleleft G$ . The canonical projection $\pi:G\to G/N$ sends $g$ to its coset $gN$ . This map is always a homomorphism, and its kernel is exactly $N$ .

Now flip that viewpoint. Given any homomorphism $f:G\to H$ , the fibers of $f$ are the sets of elements that map to the same output. The crucial fact is that these fibers are precisely the cosets of $\ker(f)$ . In other words, $f$ groups elements the same way the quotient $G/\ker(f)$ groups them.

A technical word you will meet here is well-definedness. If you want to define a map out of a quotient, you must check it does not depend on which representative of a coset you chose. The kernel is the usual reason this works.

See how the fibers line up with cosets in a picture.

Once this clicks, quotient notation stops being decorative. It becomes a promise. It says we are going to treat elements as the same exactly when they differ by something in the kernel.

Coset test
To prove $g\ker(f)=h\ker(f)$ , it is often fastest to show $f(g)=f(h)$ . For homomorphisms, equal outputs and equal kernel cosets are the same statement.

First Isomorphism Theorem as a workflow

If $f:G\to H$ is a homomorphism, then

G/\ker(f)\cong \operatorname{im}(f).

This is the First Isomorphism Theorem, and it is less a theorem to memorize than a recipe you can run.

Use it as a factorization you can always write down. There is a surjection $G\to G/\ker(f)$ , then an isomorphism $G/\ker(f)\to \operatorname{im}(f)$ , then an inclusion $\operatorname{im}(f)\hookrightarrow H$ .

Explore the factorization scaffold step by step.

A worked roadmap you can reuse

When you are given a map and asked to identify a quotient or compute a structure, do this.

Compute $\ker(f)$ .
Recognize that elements differing by $\ker(f)$ must be identified.
Replace $G$ by the simpler quotient $G/\ker(f)$ .
Work inside $\operatorname{im}(f)$ , which is the part of $H$ you actually see.

This is why homomorphisms feel like compression. The theorem tells you exactly what the compressed representation is. It is $G/\ker(f)$ , and it is isomorphic to the image.

Second, third, and correspondence theorems as navigation tools

Once you are comfortable with one quotient, the next step is moving between subgroups of $G$ and subgroups of $G/N$ without recomputing everything from scratch.

Second Isomorphism Theorem

With $H\le G$ and $N\triangleleft G$ , the subgroup $HN$ fits between them, and $HN/N\cong H/(H\cap N)$ . This tells you how intersecting with $N$ in the numerator corresponds to modding out by $N$ in the denominator.

Third Isomorphism Theorem

With $K\triangleleft G$ and $K\le H\triangleleft G$ , $(G/K)/(H/K)\cong G/H$ . It lets you quotient in stages, and assures you the result is the same as quotienting once.

Correspondence Theorem

Under the projection $\pi:G\to G/N$ , subgroups of $G$ that contain $N$ correspond exactly to subgroups of $G/N$ , and normal subgroups correspond to normal subgroups. This is how you classify subgroups of a quotient using subgroups upstairs.

See these relationships in a single diagram you can point to while solving problems.

The practical gain is speed. Instead of guessing what subgroups of a quotient look like, you pull them back to $G$ , where you often have more concrete control, then push the result down again.

How to think with homomorphisms

When you meet a new algebraic object, look for the natural maps it comes with.

Projections from products, like $G\times H\to G$ .
Inclusion maps of substructures, like $H\hookrightarrow G$ .
Reduction maps, like $\mathbb Z\to\mathbb Z_n$ .
Determinants, traces, norms, signs, and other invariants that turn complicated operations into simpler ones.

A good next step is to take any map you already know and ask two questions. What is its kernel, and what does the quotient by that kernel look like? If you can answer those, the isomorphism theorems stop feeling like separate facts and start behaving like one coherent lens.