Everyone’s Watching Quantum. No One’s Watching MVL!

Is quantum computing truly the groundbreaking advancement it’s hyped up to be, or is there a simpler, more practical revolution quietly emerging? Most people imagine quantum computing as the futuristic solution to all computing limitations, but the reality is more nuanced. Quantum’s strengths are powerful but specialized, and practical, everyday computing might find its real breakthrough elsewhere. Enter Multi-Valued Logic (MVL), an underappreciated yet promising approach that could drastically improve computing efficiency by moving beyond binary’s limited 0s and 1s. Imagine processors that naturally count in threes or fours, or beyond solving problems faster, using less power, and offering a practical path forward as Moore’s law hits a wall. Read on as we uncover why MVL, - not quantum computing, might actually be the technological leap executives and innovators have been waiting for!

Is Quantum Computing Such a Big Deal? Or is there a bigger deal in town?

Quantum computing is often touted as the next technological leap, - the rocket ship that will blast us into a new era of computing. Not quite. Although, we’ve all heard the breathless headlines: unbreakable encryption cracked in seconds, AI super-intelligences running on qubits, world hunger solved by quantum optimization. It’s as if quantum computers are magical spacecraft that can warp through computational problems at impossible speeds. But for all the hype and stardust, how much of this is reality and how much is science fiction?

The truth is more grounded and a bit ironic. Yes, quantum computing is a big deal in the way building a rocket to Mars is a big deal. It explores exotic physics and can do things classical computers can’t. However, like a rocket, a quantum computer is incredibly specialized, expensive, and finicky. It’s not going to replace the family sedan (your everyday laptop or server) any time soon. Today’s quantum processors operate at near absolute zero temperatures and require an army of engineers just to maintain stable conditions. Even then, they can only tackle specific types of problems. For most of our day-to-day computing needs (business software, web services, spreadsheets), quantum computers are massive overkill and often outright unusable.

Here’s a reality check that surprises many: quantum programs can’t even do something basic like an IF-THEN branch in the middle of a calculation. In a normal program, your code can say “if X is true, do step A, otherwise do step B.” Quantum computing doesn’t like making mid-course decisions, - at least not without losing its quantum “magic.” In fact, there’s no such thing as a classic branching statement inside a quantum algorithm; you can’t just check a qubit’s value halfway through without collapsing its state. To make it seem more difficult to understand, everything in a quantum algorithm has to be choreographed as reversible transformations on probabilities. Think of it like trying to navigate a rocket in space: you plot one continuous thrust, because stopping to ask directions (branching) would drop you out of warp.

Technical Deep Dive #1 – Why Quantum Computers Don’t Branch: A quantum computer must evolve its qubits in a smooth, reversible way (via unitary operations). If you try to peek at a qubit to decide a fork in the road, you break the superposition (like popping a soap bubble). As one expert put it, “There is no ‘while’ statement or ‘branching’ statement in quantum computing. Instead, we develop unitary operators…with the principle of interference”. In other words, quantum algorithms are more like ballet choreographies than choose-your-own-adventure books. This limitation means quantum computers can’t use many of the handy tricks that make classical software flexible.

None of this is to say quantum computing isn’t impressive. It is! It’s a profound scientific achievement analogous to that Moon shot or Mars rocket. For certain problems like quantum physics simulations, cryptography, or optimization, these rocket-computers could outperform any classical machine. But it’s worth remembering that most people’s perception of quantum computing (“a super-fast computer that does everything faster”) is not what quantum computing actually delivers today and with no expectation it will in the future.

So, if the real quantum computers are more niche and high-maintenance than the popular imagination suggests, where does that leave us? Are we stuck on the ground with only incremental improvements to our trusty classical computers? Perhaps not. What if I told you there’s another computing paradigm, - one that’s been quietly simmering in research labs, which might one day give us a more practical leap forward? Let’s leave our rocket on the launchpad for a moment and meet the underappreciated contender.

Beyond Ones and Zeros: Meet MVL (Multi-Valued Logic)

While everyone’s been gazing at the quantum stars, a different approach to turbocharging computing has been waiting in the wings. It doesn’t require quantum physics, dilution refrigerators, or sci-fi contraptions. Instead, it asks a simple yet profound question: Why limit ourselves to only two values (0 and 1) in computing? Enter Multi-Valued Logic (MVL) – computing with more than two states. In the simplest form, think ternary (three-valued) logic, using 0, 1, and 2 as possible values (or perhaps -1, 0, +1 in a balanced scheme).

If binary computing is like a language with just two letters, MVL gives us a richer alphabet. Suddenly our “words” (numbers, data) can carry more information in the same length. A single ternary digit – often called a trit – can represent about 1.58 bits worth of information. In plain English, that’s ~50% more data per “digit” than binary. This means, for example, that two trits can encode 3×3 = 9 values (where two bits can only encode 4 values). As you add more digits, the capacity explodes: 10 binary bits can represent 1024 values, but 10 ternary trits can represent 3^10 = 59,049 values! In computing terms, MVL is like widening a highway – more lanes for data to drive through side by side.

To use a light-hearted metaphor: Traditional binary computing is like painting a picture using only black and white. It’s amazing what we’ve accomplished with just those two “colors” (virtually all of modern computing!). But MVL says, “Hey, here’s a whole palette of colors – reds, blues, greens – go paint with those too.” With more hues (states) to work with, you might capture a scene with far greater efficiency and nuance than sticking to monochrome. Once you experience computing in full color, going back to black-and-white seems limiting.

And MVL computing isn’t just a theoretical dream. It’s been demonstrated in the real world, albeit in limited ways. In fact, you probably use a form of multi-valued logic every day without realizing it: the memory in your smartphone or laptop SSD. Modern flash memory cells can store 2, 3, even 4 bits in a single cell by using multiple charge levels (essentially an analog form of multi-valued storage). For instance, a “triple-level cell” (TLC) flash stores 3 bits by distinguishing 8 charge levels – effectively a device with 8 states! The reason is simple: more states per cell = more data in the same chip area. The industry did this to get cheaper, higher-capacity storage.

The concept of MVL has been around a long time. Back in 1958, Soviet engineers built a computer called Setun that ran on ternary logic. It was literally a base-3 computer using balanced ternary digits. And guess what? It worked quite well. They built 50 of these machines and found that a comparable binary machine cost 2.5 times more to achieve the same performance. In many ways, Setun was a computer beyond its time – a Concorde of computing. Like the Concorde jet, which proved supersonic travel was possible (and elegant), Setun proved ternary computing was feasible. But also like the Concorde, it wasn’t adopted widely due to practical economics and infrastructure. The world had already standardized on binary (just as aviation standardized on cheaper subsonic flights), so ternary became a historical footnote.

Today, however, the landscape is changing. The binary paradigm is showing its age as we pack billions of transistors on a chip, hitting physical limits. Researchers worldwide are revisiting MVL with fresh eyes and new technology. What if our future computer chips used transistors that natively handle 3 or 4 levels instead of just 2? Imagine arithmetic circuits that don’t need as many chained steps because each element carries more information. MVL could potentially reduce the number of components and wires needed in a circuit – since one multi-valued signal can carry what would otherwise require multiple binary signals. Fewer wires and components mean faster communication on-chip and potentially lower power consumption.

 Multi-Valued Logic in Action – How It Works (A Quick Tour)

Let’s get a bit technical for a moment (don’t worry, we’ll keep it high-level and fun). How do you actually compute with multiple values? What does a “ternary transistor” even look like?

In a binary digital circuit, a transistor is essentially a switch that is either off (0) or on (1). In MVL, we need devices that can reliably hold and distinguish 3 (or more) distinct levels. One simple way is using different voltage levels: e.g. 0 volts for “0”, 1.2 volts for “1”, 2.4 volts for “2”. A ternary logic gate would then be designed to handle these as inputs and output the appropriate ternary result. For example, a ternary inverter might map 0→2, 1→1, 2→0 (that’s one way to define a NOT function in base-3).

Technical Deep Dive #2 – How Trits Encode More Data: Think of a trit as a traffic light instead of a binary on/off switch. With a normal bit (on/off), you can only signal “go” or “stop.” With a three-state signal (say, red, yellow, green), you have an extra option – like “yield” or “caution”. That’s about 58% more than a single bit. So, two trits (~3.17 bits) pack more information than even 3 binary bits (3 bits = 3 bits). As a result, any data – numbers, text, etc. – can be represented with fewer trits than bits. For example, the number 100 (decimal) is 1100100 in binary (7 bits) but only 10201 in ternary (5 trits). Fewer digits can mean fewer operations to process that number. In theory, a ternary ALU (arithmetic unit) could add or multiply large numbers with fewer steps because each step handles more magnitude.

In practice, engineers have explored various physical implementations for MVL. One promising approach is to use novel transistor designs with multiple stable thresholds. Recently, experiments with quantum dot transistors and specialized FETs have achieved exactly that: transistors with 4 distinct output levels (essentially 2-bit output) from a single device. The results are exciting – such 4-state devices showed the potential for higher speeds and lower power compared to using many binary transistors to achieve the same function. It’s like suddenly being able to carry 4 passengers on a bicycle built for one; you’d need four separate bikes in binary, but one quad-level bike can do it all, with less total effort. Other research has built prototype processors that operate in ternary, showcasing that standard computing tasks can be done in a 3-valued system. The pieces are falling into place, slowly but surely, to make MVL computing viable in the real world.

Before we get carried away, though, we should talk about the elephant in the room: if MVL is so great, why aren’t we using it everywhere already? Time to address the challenges on this journey.

Why We (Still) Compute in Binary – Challenges of MVL

If multi-valued logic is like the high-speed rail of computing (fast, efficient, more capacity), binary logic is like the old but reliable highway system. We continue to use binary because, frankly, it’s simple and robust. Pushing beyond it is a bit like adding more lanes to a freeway – it sounds great, but it complicates the engineering (and accidents get more frequent if lanes aren’t clearly separated!).

The number one challenge for MVL hardware is signal integrity and noise. With binary, distinguishing a “0” from a “1” is relatively easy – there’s a nice large voltage or current gap between the two states, and digital circuits use thresholds to clean up noise. If your signal is 0 volts for a “0” and 5 volts for a “1”, a little noise won’t confuse the two. But if you have to distinguish multiple levels (say 0, 2.5, 5 volts for 0/1/2), the gaps between levels are smaller. A bit of electrical noise or a slight manufacturing variation can nudge a “2” level signal down to what looks like a “1.” In the flash memory example, moving from 2 states per cell to 4 states per cell shrinks the margins and thus requires much more error correction. In logic circuits, this could mean more errors unless design tricks or error-correcting schemes are in place. In short, it’s harder to keep three (or more) values cleanly separated as signals zip around a chip at billions of operations per second.

Another challenge is the lack of industry infrastructure for MVL. Decades of progress in semiconductors have been laser-focused on binary. All our design tools, fabrication processes, and even programming languages assume bits. To switch to trits or more, a huge ecosystem would need retooling – from the ground up. It’s not just building one ternary transistor; you need ternary memory cells, ternary logic gate libraries, ternary arithmetic circuits, and so on, plus software compilers that know how to leverage them. That’s a tall order. It’s a bit like having an entire city’s transport built for cars and then proposing we switch to hovercrafts – even if hovercrafts could be superior, you’d have to rebuild the roads, garages, gas stations, traffic rules, everything.

There’s also a Goldilocks problem: what’s the ideal number of logic values? Binary (2) might be too few for future needs, but something like decimal (10) might be too many to reliably handle in hardware based on today’s technology of needing 10 distinct voltage levels, - that might be tough, - but certainly not impossible. Ternary (3) or quaternary (4) are often seen as a sweet spot – offering significant gains without overwhelming complexity. Still, engineers will have to prove that any MVL system can be as reliable and cost-effective as binary, - which we know it can be some day. The engineering challenges are far easier to overcome than those currenly facing quantum computing.

Technical Deep Dive #3 – Signal Integrity in MVL (Why It’s Hard): Consider trying to have a conversation in a room with background noise. If you only care about distinguishing “yes” vs “no” (two states), you can shout those words and likely be understood even with noise. Now imagine you have five different responses to convey – it gets harder for the listener to tell which of the five you said unless the room is very quiet or you speak very clearly. That’s what an MVL circuit faces: more “words” (logic levels) in a noisy environment. Electronics can mitigate this with techniques like larger signal swings, error-correcting codes, or shielding, but these add complexity. It’s one reason why our binary circuits, which essentially shout either a strong “on” or “off,” have been so reliable. MVL will need clever engineering (perhaps adaptive thresholds or new materials) to ensure a “level 3” never gets mistaken for a “level 2” under real-world conditions.

Despite these challenges, progress is being made. New materials like graphene and carbon nanotubes have shown the ability to maintain multiple stable states. Some experimental chips use analog properties and then convert them into multi-valued logic. We’re in the early days, but the train is moving.

 MVL vs Quantum: Two Different Journeys, Not Mutually Exclusive

It’s tempting to frame this as a head-to-head battle: Quantum Computing vs. MVL Computing – which will win? But in reality, these technologies are apples and oranges. They’re aimed at different problems and likely will coexist, each in their niche. Quantum computing shines in specialized arenas where quantum effects give it a massive advantage (for example, factoring large numbers, certain optimization or chemistry simulations). MVL computing shines in taking classical computing to the next level – making everyday processors faster and more efficient in a broad range of tasks by upgrading the very fabric of how we represent data.

In fact, MVL could complement quantum in some ways. Even a quantum computer needs classical control systems; maybe those could benefit from MVL to handle more complex state management. Or think of a future where high-performance servers use MVL-based CPUs for general tasks and quantum accelerators for specific heavy lifting – a bit like how we use GPUs today alongside CPUs.

Here’s the key takeaway: MVL computing is an evolution of classical computing that could yield huge practical benefits, whereas quantum computing is a more revolutionary approach but with a narrower initial impact. If quantum is our rocket for special missions, MVL is like improving the engines in our cars and planes that we use every day. We don’t need to choose one over the other in absolute terms; we should recognize what each is and isn’t. MVL won’t break the laws of physics or let us crack RSA-2048 encryption with ease – that might be quantum’s domain, - or so they say. Conversely, quantum won’t magically make your data center run at 1/10th the power consumption for typical workloads – but MVL just might.

Perhaps the biggest similarity between the two is that both are in early stages, and both face years of R&D before they reach their full potential. But MVL has the advantage of building on existing tech paradigms (we don’t need to invent new physics, just new engineering), which might make its path to practicality a bit more straightforward, even if less glamorous.

MVL Computing Will Blow Away Quantum Computing… But When?

MVL isn’t going to render quantum computing obsolete since they are too different in purpose. The provocation in this title is really reflecting that MVL could blow away quantum in the arena of practical, general-purpose computing, which is what most people think quantum computing will do. It’s a bit of a cheeky claim, but there’s a case for it. MVL doesn’t require us to rewrite the rules of computation from scratch; it turbocharges the classical rulebook. If MVL computing even achieves, say, a 10x improvement in computational efficiency for general workloads in the next couple of decades, that’s enormous. It would indeed steal a lot of thunder from quantum, which might still be struggling to get error-corrected qubits into the thousands by then.

The question is when (and if) MVL will start showing up in real processors. It’s the billion-dollar question (maybe literally, for whoever masters it). Based on current trends, we can speculate with cautious optimism. In the next 5-10 years, we might begin to see hybrid approaches: perhaps memory chips or specialized AI accelerators that use multi-level analog signals internally, blurring into MVL territory. By the 15–20 year mark, it’s conceivable that a full-fledged MVL-based CPU could be a reality, especially as CMOS (the current transistor tech) gives way to emerging technologies where multi-valued operation is more natural. For instance, future carbon nanotube transistors or spintronic devices might find it just as easy to output three stable states as two.

Of course, this timeline can slip or accelerate depending on breakthroughs. It’s worth remembering that a lot of pieces have to fall in place: not just the devices, but industry standards, manufacturing techniques, and even developer mindsets. Change in computing paradigms tends to be gradual. Even the move from 32-bit to 64-bit in mainstream CPUs took over a decade to fully catch on, and that was a minor evolutionary step compared to changing the number of logic states!

So, no, don’t throw out your binary computers yet, and don’t cancel that quantum research program either. Quantum computing will continue to make strides in its own domain, and binary classical computing isn’t hitting a wall tomorrow. But keep an eye on MVL computing – it’s the promising underdog of the story. In a sense, MVL is quietly what many people mistakenly think quantum is: a potentially transformative boost to how we compute everything, not by magic, but by a clever extension of the familiar.

Multi-valued logic computing may not have the wow factor of qubits and entanglement, but it has a certain pragmatic charm – and maybe, just maybe, the power to take us further than we ever thought binary could, into the full color future of computing.

---

This article represents my personal views on computer processing trends and does not necessarily reflect the official position of my employer.