Duality — Flipping the Arrows Changes Everything

When we studied initial objects and terminal objects, something subtle appeared.

The definitions looked almost identical.

Initial object:

Terminal object:

The only difference is the direction of arrows.

That symmetry is not accidental.

It comes from one of the most powerful ideas in category theory: Duality.

The Opposite Category

Given any category C, we can construct a new category called:

pronounced:

“C op” or “C opposite.”

This new category keeps the same objects but reverses every morphism.

If we had a morphism:

then in the opposite category we get:

Nothing else changes. Objects stay the same. Only arrows flip direction.

Composition in the Opposite Category

In the original category:

composition gives:

Graphically:

A → B → C

Now reverse all arrows.

C → B → A

So the morphisms become:

Composition now becomes:

Notice the order flips.

Mathematical Rule

Original:

Opposite category:

Identity Morphisms

Every object has an identity morphism.

When we reverse arrows:

The arrow still points to itself. So reversing identity morphisms changes nothing. It’s literally a no-op.

Initial and Terminal Objects Through Duality

Now something beautiful appears.

Initial object definition:

Terminal object definition:

If we reverse arrows:

I → X

becomes

X → I

So in the opposite category:

I

becomes a terminal object.

This means:

A terminal object in C is an initial object in C^{op}. And vice versa.

Dual Concepts Everywhere

Because of this arrow reversal rule, many concepts appear in pairs.

Mathematicians love this property because:

Every theorem automatically generates another theorem.

If you prove something for products, the dual statement holds for coproducts.

Programming Interpretation

Duality appears in programming too.

We often move between two perspectives:

Data Construction

Building structures.

Example:

Pair<A, B>

Data Choice

Choosing between structures.

Either<A, B>

These two ideas are dual.

Kotlin Example — Product vs Coproduct

Product:

data class Pair<A, B>(
    val first: A,
    val second: B
)

Coproduct:

sealed class Either<A, B> {

    data class Left<A, B>(val value: A) : Either<A, B>()

    data class Right<A, B>(val value: B) : Either<A, B>()
}

One contains both values. The other contains one of the values. They are dual structures.

Duality in Kotlin Types

Initial object:

Nothing

Terminal object:

Unit

Relationships:

Nothing → A

is always valid.

Example:

fun fail(): Nothing {
    throw RuntimeException()
}

Terminal object:

A → Unit

Example:

fun log(message: String): Unit {
    println(message)
}

These two types represent the two extremes of information flow.

Visual Intuition

Original category:

Initial object

      I
     /|\
    / | \
   v  v  v
   A  B  C

Opposite category:

Terminal object

   A  B  C
    \ | /
     \|/
      v
      T

Final Insight

Duality reveals a deep symmetry:

Initial Object
        ↓
Arrow reversal
        ↓
Terminal Object

In category theory, flipping arrows transforms entire mathematical structures. And that simple idea explains why many programming abstractions appear in pairs.