Over the last few posts, we've talked about Fully Homomorphic Encryption (FHE), why encrypted data normally has to be decrypted before it's useful, and how the industry eventually settled on the familiar phrase:

"Encrypted at rest and in transit."

Along the way, we've managed to avoid talking about one very important thing.

The math.

That wasn't an accident.

Mostly because every time someone starts explaining the mathematics behind modern cryptography, there's a non-zero chance the conversation eventually involves “lattices”, “polynomial rings”, and someone enthusiastically filling an entire whiteboard with symbols.

That's usually the point where I quietly excuse myself to brew coffee using a pour-over of a good dark roast.

Fortunately, this isn't a graduate mathematics course.

It's FHE 101.

So instead of trying to explain every equation, let's talk about why the mathematics matter in the first place.

Demystifying the Math

When most people think about encryption, they imagine locks.

• Keys
• Secrets
• Hidden processes for concealing data

Something mysterious happening behind the scenes.

Modern cryptography is actually much less mysterious.

The algorithms are public.
The research is public.
The mathematics is public.

In fact, one of the guiding principles of modern cryptography is that the system should remain secure even if everyone knows exactly how it works.

That sounds backwards.

Until you realize something important:

The security isn't hiding in the algorithm.
It's baked into the mathematics.

Or put another way:

Modern cryptography isn't secure because nobody knows how it works.
It's secure because everybody knows how it works.

The challenge isn't understanding the algorithm.
The challenge is solving the mathematics behind it.

Easy One Way. Painfully Hard the Other

One of the recurring ideas in cryptography is surprisingly simple.

Some mathematical problems are easy to create.
They're much harder to reverse.

Think about a thousand-piece jigsaw puzzle.

Building the puzzle is easy.
Someone already did that.

Putting it back together after all the pieces have been dumped onto the table?
That's a very different problem.

The information is still there.
Recovering it takes work.

Modern cryptography is built on mathematical problems that have a similar flavor.

Easy in one direction and not impossible in the reverse direction.
Just extremely computationally expensive.

And in cryptography, “extremely expensive” is often good enough.

Solvable Isn't the Same as Practical

This turns out to be one of the biggest misconceptions in cryptography.

People often think encryption works because computers simply can't solve the problem.

Sometimes that's actually the goal. Cryptographers have a term for systems whose security doesn't depend on how much computing power an attacker has: information-theoretic security.

But much of modern cryptography relies on something different: computational security.

Here, the problem isn't necessarily impossible to solve.
It's just extraordinarily expensive to solve.

The real question becomes:
How long would it take?

Imagine I hand you a puzzle.

You can absolutely solve it.
It'll only take:

• 100 years
• 1,000 years
• 10 billion years

At that point, "solvable" becomes a technicality.

Much of modern cryptography lives in that space.

The goal isn't necessarily to make something impossible.

It's to make breaking it so computationally expensive that, with any realistic amount of computing power and time, the answer is effectively out of reach.

Turns out, "technically possible, practically ridiculous" can be a pretty useful security feature.

This Is Where Cryptographers Live

Software engineers spend a lot of time asking:
"Can we make this faster?"

Cryptographers spend a surprising amount of time asking:
"Can we make this computationally expensive for the wrong person and efficient for the right one?"

That's a wonderfully different way of looking at the world.

They're constantly searching for mathematical problems that are:

• easy to construct
• practical to use
• extraordinarily difficult to reverse

Not because they enjoy making life complicated.
(Although I occasionally wonder.)

But because those hard mathematical problems become the foundation of modern security.

A Quick Word About Lattices

If you've spent any time reading about modern cryptography or FHE specifically, you've probably encountered the word lattice.

At a very high level, a lattice is simply a repeating arrangement of points in space.

Imagine an infinite sheet of graph paper.

Every intersection forms part of a lattice.

That's the simple version.

Cryptographers, naturally, looked at that idea and asked:
"What happens if we do this in hundreds, or even thousands, of dimensions?"

As it turns out...
Some very interesting things.

In those incredibly high-dimensional spaces, certain mathematical problems become remarkably difficult for computers to solve efficiently.

That's one of the reasons lattices have become such an important building block in modern cryptography.

Especially in post-quantum cryptography.

Which includes Fully Homomorphic Encryption.

If you've spent any time on the Niobium website, you've probably seen our logo dozens of times.

You may have even noticed the lattice in it.

Or maybe you didn't.

That's okay, I worked here for a while before I fully appreciated why it was there.

Turns out our designers and cryptographers were a few steps ahead of me.

It wasn't included because it looked cool.
(Although I still think it does.)

So yes...
We've been hiding lattices in plain sight this whole time.

The good news is that by the end of the next post, you'll know exactly why it's there.

Besides...
I'll probably need another pour-over before we get into polynomial rings.

The Part Where We Turn It Up to 11

There's another concept that surprises almost everyone.

Noise.

Most engineers spend their careers trying to remove it.

• Signal processing
• Networking
• Photography
• Audio

Noise is usually the thing standing between you and the correct answer.

Cryptographers looked at that idea and said:
"Let's add some."

Which feels wonderfully backwards.

If you're familiar with the 1984 film This Is Spinal Tap, you'll remember Nigel Tufnel proudly explaining that his amplifier goes to 11 instead of 10.

Because...
it's one louder.

Noise in modern cryptography feels a little like that.

At first glance, you might think:
"If a little noise is good... why not just turn it up to 11?"

Unfortunately, cryptography is slightly less forgiving than a guitar amplifier.

A carefully controlled amount of mathematical noise makes it dramatically more difficult for an attacker to recover the original information.

In other words:

The noise isn't a bug.
The noise is part of the security.

But unlike Nigel's amplifier, more isn't always better.

Too little noise...
and the system becomes weaker.

Too much...
and eventually even the legitimate user can't decrypt the answer.

Managing that balance turns out to be one of the defining engineering challenges in Fully Homomorphic Encryption.

Every homomorphic operation adds a little more noise.

Eventually, if you're not careful, you've metaphorically turned the volume all the way up.

The encryption is still secure.
It's just no longer useful.

We'll save "noise budgets" for another post.

Trust me.

They're far more interesting and far more important than they first sound.

Why FHE Gets Weird

Traditional cryptography asks a fairly straightforward question:
How do we protect information?

FHE asks something much stranger:
How do we protect information while still doing useful work with it?

Now the mathematics has to do two jobs at once.

1. Protect the data.
2. Enable computation.

That's why Fully Homomorphic Encryption feels different from almost every other form of encryption you've encountered.

Most encryption works like a lock box. Once the data is inside, nothing can happen to it until someone with the key opens the box back up.

Fully Homomorphic Encryption goes back to the lattices. Your data becomes a point in one of those infinite pieces of graph paper. That point can be moved, through simple operations like addition and multiplication (with an appropriate amount of noise), where the person doing the moving doesn’t know what the point stands for.

In FHE, the encryption is malleable without being breakable.

The math isn't simply protecting information anymore.

It's enabling entirely new ways of computing.

When Great Mathematics Meets Reality

If you've read this far, you might be wondering:
If the mathematics behind FHE is so elegant... why isn't everyone using it?

The short answer is:
Because elegant mathematics can still be incredibly demanding to compute.

For years, that was one of the biggest challenges facing Fully Homomorphic Encryption.

The mathematics worked.
Researchers continued improving it.
Libraries became better.
The theory became stronger.

But running real workloads remained computationally expensive.
Very computationally expensive.

That's one of the reasons we're building purpose-built hardware at Niobium.

Our custom ASIC isn't built to change the mathematics.

It’s built to make the mathematics usable.

Our goal is to make FHE practical and approachable for developers. That means accelerating the underlying computation with purpose-built hardware, but it also means abstracting away much of the specialized FHE knowledge traditionally required to build an application.

We're doing that with tools including our FHE AI Skill and FHE DSL, which help developers take a familiar application and translate it into something FHE-compatible. Developers can compare their original application against a cleartext FHE-friendly version—where operations that don't translate well to FHE can be replaced or approximated with polynomial functions—and ultimately the encrypted implementation. That makes it easier to understand tradeoffs in accuracy, debug problems, and iterate without becoming an FHE expert first.

The math can stay complicated.

Building an application doesn't have to be.

Of course, hardware is only part of the story.

Great hardware sitting in a rack doesn't help many people.

That's why we're also building the Niobium Fog.

Think of it as a cloud built specifically for Fully Homomorphic Encryption.

A place where developers, researchers, and organizations can experiment, prototype, and eventually deploy encrypted applications without first becoming experts in specialized infrastructure or cryptographic engineering.

Earlier in this series, we talked about how encryption in transit eventually enabled entirely new kinds of applications like e-commerce.

Our hope is that purpose-built hardware and cloud platforms do something similar for FHE.

Not because the mathematics changes.

But because the practical barriers begin to disappear.

• The mathematics made FHE possible
• Purpose-built hardware helps make it practical
• The Fog helps make it accessible

And that's where things start getting really interesting.

Curiosity Before Equations

One of the things I've enjoyed most about learning more about cryptography is realizing that it's far less about secret algorithms than it is about beautiful mathematics.

The more I've learned, the less I think about locks and keys.

I think about clever mathematical ideas that somehow convince computers to behave in ways that initially seem impossible.

That's a remarkable thing.

And we've really only scratched the surface.

What's Next

So far in our FHE 101 series, we've covered the basics of Fully Homomorphic Encryption, compared it with the encryption you already know, TLS, AES, and friends and looked at how "encrypted at rest and in transit" became the industry standard while quietly leaving computation out of the conversation.

And now we've wandered into the math.

• Lattices.
• Noise.
• Polynomial approximations.
• And, apparently, the need for a good dark roast.

But eventually, someone has to build something with all of this.

That's where the Niobium Fog comes in.

In the next post, we'll step away from the math and take a closer look at why we built the Fog, what it's like to actually use it, and how we're thinking about shortening the path from "I have an idea" to "I have an encrypted application running."

We'll talk about ease of use, developer experience, and perhaps most importantly, time to productivity because developers shouldn't have to become cryptographers before they can start building with FHE.

Next time, we'll head into the Fog.

Visibility should actually be pretty good.

To learn more about FHE, hardware acceleration, and Niobium’s encrypted cloud platform, The Fog™, contact us or sign up to join our Developer Partner Program.