The boolean algebra absorption law is a simplification rule stating that a variable combined with a logical AND of itself and another variable reduces simply to the original variable ($A + AB = A$). When you are designing hardwired relay panels, writing PLC ladder logic, or synthesizing Verilog for an FPGA, redundant logic isn't just an eyesore—it costs scan time, logic elements, and troubleshooting headaches. More dangerously, as we will see in the numeric example below, failing to recognize this law can lead to accidental safety interlock bypasses in industrial control systems.
The Core Mechanics and a Real-World Numeric Example
The absorption law manifests in two primary forms, depending on whether you are working with sum-of-products (OR-based) or product-of-sums (AND-based) logic:
- OR Form: $A + AB = A$
- AND Form: $A(A + B) = A$
The algebraic proof is straightforward. By factoring out $A$ in the OR form, you get $A(1 + B)$. In boolean logic, $1 + ext{anything} = 1$. Therefore, $A(1) = A$. The secondary variable $B$ is entirely absorbed by the primary variable $A$.
Worked Numeric Example: The Conveyor Belt Safety Bypass
Let’s map this to a real industrial scenario. Imagine a junior programmer is writing a start sequence for a conveyor motor. They define two inputs:
- A = Master_Start_Switch (1 when pressed)
- B = Safety_Guard_Closed (1 when the physical polycarbonate guard is shut)
The programmer intends for the motor to run if the Master Switch is pressed, but they get confused and write the following boolean equation for the motor output:
Motor_Out = A + (A * B)
Let’s evaluate this numerically across all four possible binary states:
| Master Switch (A) | Guard Closed (B) | A * B (AND) | A + AB (Output) | Physical Result |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | Motor Off |
| 0 | 1 | 0 | 0 | Motor Off |
| 1 | 0 | 0 | 1 | Motor Runs (Guard Open!) |
| 1 | 1 | 1 | 1 | Motor Runs |
Where You Meet This in Practice
Theory is useless if it doesn't translate to the bench or the jobsite. Here is exactly where the absorption law dictates hardware and software decisions in modern electrical engineering.
1. PLC Ladder Logic Optimization
In platforms like Rockwell Studio 5000 or Siemens TIA Portal, every instruction (XIC, XIO, OTE) takes a measurable amount of time to execute. While a single redundant branch might only add microseconds to a PLC scan cycle, high-speed packaging machines running 20ms scan times cannot afford bloated logic. If you have a sealing subroutine that checks Machine_Auto_Mode + (Machine_Auto_Mode AND Part_In_Position), applying the absorption law reduces the rung to a single XIC instruction. Over a 500-rung program, this optimization reduces CPU overhead and makes troubleshooting vastly easier for the maintenance technicians who inherit your code.
2. FPGA Synthesis and LUT Mapping
When you write Verilog or VHDL for an FPGA, the synthesis tool (like AMD/Xilinx Vivado) maps your code into physical silicon Look-Up Tables (LUTs). A standard UltraScale+ FPGA uses 6-input LUTs. If your code contains unabsorbed terms, the synthesis engine has to route additional multiplexers and interconnects. While modern synthesis tools are smart enough to apply the absorption law automatically during the optimization pass, writing clean, pre-absorbed RTL code reduces compilation time and prevents edge-case bugs where the tool misinterprets complex nested conditionals.
3. Hardwired Relay Control Panels
If you are building a legacy control panel using 11-pin octal relays (like the ubiquitous Omron MY4N or Schneider Electric RXM), you are strictly limited by physical contact count. A standard relay provides four sets of NO/NC contacts. If your logic design requires you to wire a redundant $A + AB$ branch, you might burn through your available contacts and be forced to add a second, $15 intermediary relay just to repeat the signal. Applying the absorption law on the schematic saves you physical panel space, wiring time, and component costs.
Common Confusions and Pitfalls
Even experienced controls engineers occasionally mix up the fundamental laws of boolean algebra. Here is what the absorption law is frequently confused with:
- The Idempotent Law ($A + A = A$): People confuse absorption with idempotency. Idempotency simply states that ORing a variable with itself yields the variable. Absorption requires a secondary variable ($B$) trapped in an AND gate with the primary variable.
- The Distributive Law ($A + BC = (A+B)(A+C)$): The distributive law expands logic; the absorption law collapses it. If you try to apply distribution to $A + AB$, you get $(A+A)(A+B)$, which simplifies via idempotency to $A(A+B)$, which then requires the AND-form absorption law to finally reach $A$. It’s a circular trap that wastes time.
- Intentional Redundancy for Diagnostics: Sometimes, a senior programmer will intentionally write $A + AB$ in a PLC. Why? Because they map the $AB$ branch to a diagnostic HMI indicator light. They *want* to know when both conditions are true, even if the primary output $A$ is already satisfied. In these cases, the logic isn't mathematically redundant; it's functionally split for user feedback.
Frequently Asked Questions
How do you prove the boolean algebra absorption law using a truth table?
You prove it by evaluating all possible binary combinations of A and B (00, 01, 10, 11). As demonstrated in the conveyor belt example above, the output column for $A + AB$ will perfectly match the output column for $A$ in every single row. Because the outputs are identical across all possible input states, the two expressions are mathematically proven to be equivalent, meaning $B$ has zero impact on the final result.
Why does the absorption law matter in PLC ladder logic programming?
It matters for three reasons: scan time, memory, and maintainability. Every extra branch in a ladder logic rung requires the PLC processor to fetch the state of that tag from memory, evaluate the logic, and move to the next instruction. In high-speed motion control or packaging applications, eliminating absorbed variables reduces the scan cycle. Furthermore, it prevents the "spaghetti code" effect, ensuring that maintenance electricians can trace a fault without deciphering unnecessary parallel branches.
What is the difference between the absorption law and the consensus theorem?
The absorption law eliminates a variable that is paired with itself ($A + AB = A$). The consensus theorem eliminates a redundant third term that is generated by the intersection of two other terms. The consensus theorem states that $AB + A'C + BC = AB + A'C$. In the consensus theorem, the $BC$ term is absorbed by the opposing states of $A$ and $A'$ in the first two terms. Absorption is a two-variable rule; consensus is a three-variable rule.
Can the absorption law be applied to three or more variables?
Yes, the law scales infinitely. If you have an equation like $Y = A + ABC + ABDE$, the absorption law dictates that the primary variable $A$ absorbs any AND-chain that begins with $A$. Therefore, $Y = A + ABC + ABDE$ simplifies instantly to $Y = A$. As long as the primary variable is present in every term of the OR-chain, the secondary variables are irrelevant to the final boolean outcome.
