{"id":2133,"date":"2026-04-03T16:59:21","date_gmt":"2026-04-03T16:59:21","guid":{"rendered":"https:\/\/primetoolhub.com\/?page_id=2133"},"modified":"2026-07-13T12:31:57","modified_gmt":"2026-07-13T12:31:57","slug":"boolean-expression-simplifier","status":"publish","type":"page","link":"https:\/\/schoolict.net\/tools\/boolean-expression-simplifier\/","title":{"rendered":"Boolean Expression Simplifier &amp; Logic Gate Calculator"},"content":{"rendered":"<div class=\"pth-hero-section\">\n<div class=\"pth-hero-content\">\n<h2>Boolean Expression Simplifier &#038; Logic Gate Calculator<\/h2>\n<p>Use our free, 100% offline Boolean Expression Simplifier to instantly solve complex logic equations with a step-by-step breakdown and Boolean laws reference.<\/p>\n<div id=\"pth-toc-placeholder\"><\/div>\n<\/p>\n<\/div>\n<div class=\"pth-hero-image\">\n\t<img data-no-lazy=\"1\"\n         src=\"https:\/\/schoolict.net\/tools\/wp-content\/uploads\/2026\/05\/Boolean-Expression-Simplifier-800x447.jpeg\"\n         width=\"800\"\n         height=\"447\"\n         alt=\"Boolean Expression Simplifier\"\n         fetchpriority=\"high\"\n         loading=\"eager\"\n         decoding=\"async\"\n         style=\"width:100%; height:auto; display:block;\">\n  <\/div>\n<\/div>\n\n\n<div class=\"wp-block-rank-math-toc-block\" id=\"rank-math-toc\"><h2>Table of Contents<\/h2><nav><ul><li><a href=\"#\ud83d\udd34-writing-the-expression-the-tool-understands\">\ud83d\udd34\u00a0Writing the expression the tool understands<\/a><\/li><li><a href=\"#\ud83d\udfe1-a-worked-example-tab-by-tab\">\ud83d\udfe1\u00a0A worked example, tab by tab<\/a><\/li><li><a href=\"#\ud83d\udfe2-when-to-use-this-and-when-to-use-something-else\">\ud83d\udfe2\u00a0When to use this, and when to use something else<\/a><\/li><\/ul><\/nav><\/div>\n\n\n<!-- LSCACHE_DISABLE -->\r\n<div id=\"pth-bl-studio-wrapper\">\r\n<style>\r\n#pth-bl-studio-wrapper{font-family:'Inter',system-ui,-apple-system,sans-serif;max-width:1100px;margin:0 auto;box-sizing:border-box;background:#f8fafc;padding:20px;border-radius:18px;color:#0f172a}\r\n#pth-bl-studio-wrapper.pth-bl-full{max-width:1650px}\r\n#pth-bl-studio-wrapper *{box-sizing:border-box}\r\n#pth-bl-studio-wrapper .pth-bl-top{background:#fff;border:1px solid #e2e8f0;border-radius:14px;padding:18px 22px;margin-bottom:16px;box-shadow:0 4px 10px rgba(0,0,0,.04)}\r\n#pth-bl-studio-wrapper .pth-bl-title{font-size:1.5rem;font-weight:800;color:#0f172a;margin:0;display:flex;align-items:center;gap:10px}\r\n#pth-bl-studio-wrapper .pth-bl-sub{font-size:.9rem;color:#475569;font-weight:500;margin-top:4px}\r\n#pth-bl-studio-wrapper .pth-bl-inrow{display:flex;gap:10px;flex-wrap:wrap;align-items:flex-end;margin-top:14px}\r\n#pth-bl-studio-wrapper .pth-bl-inrow>div.pth-bl-inbox{flex:1;min-width:240px}\r\n#pth-bl-studio-wrapper label{font-size:.82rem;font-weight:700;color:#334155;display:block;margin-bottom:6px}\r\n#pth-bl-studio-wrapper input[type=text]{width:100%;padding:11px 13px;border:1px solid #cbd5e1;border-radius:8px;font-size:1rem;font-family:ui-monospace,Menlo,Consolas,monospace;color:#0f172a;background:#fff;outline:none;transition:.2s}\r\n#pth-bl-studio-wrapper input[type=text]:focus{border-color:#2563eb;box-shadow:0 0 0 3px rgba(37,99,235,.12)}\r\n#pth-bl-studio-wrapper .pth-bl-btn{background:#2563eb;color:#fff;border:none;border-radius:8px;padding:11px 18px;font-weight:700;font-size:.9rem;cursor:pointer;transition:.2s;font-family:inherit}\r\n#pth-bl-studio-wrapper .pth-bl-btn:hover{background:#1d4ed8}\r\n#pth-bl-studio-wrapper .pth-bl-btn.pth-bl-ghost{background:#f1f5f9;color:#334155;border:1px solid #cbd5e1}\r\n#pth-bl-studio-wrapper .pth-bl-btn.pth-bl-ghost:hover{background:#e2e8f0}\r\n#pth-bl-studio-wrapper .pth-bl-hint{font-size:.8rem;color:#475569;margin-top:8px;line-height:1.5}\r\n#pth-bl-studio-wrapper .pth-bl-hint code{background:#eef2ff;color:#4338ca;padding:1px 6px;border-radius:4px;font-size:.85em}\r\n#pth-bl-studio-wrapper .pth-bl-tabs{display:flex;flex-wrap:wrap;gap:8px;margin-bottom:16px}\r\n#pth-bl-studio-wrapper .pth-bl-tab{background:#fff;border:1px solid #cbd5e1;color:#334155;font-weight:700;font-size:.88rem;padding:10px 15px;border-radius:10px;cursor:pointer;transition:.2s;font-family:inherit}\r\n#pth-bl-studio-wrapper .pth-bl-tab:hover{border-color:#2563eb;color:#2563eb}\r\n#pth-bl-studio-wrapper .pth-bl-tab.pth-bl-on{background:#2563eb;border-color:#2563eb;color:#fff}\r\n#pth-bl-studio-wrapper .pth-bl-panel{display:none}\r\n#pth-bl-studio-wrapper .pth-bl-panel.pth-bl-show{display:block}\r\n#pth-bl-studio-wrapper .pth-bl-card{background:#fff;border:1px solid #e2e8f0;border-radius:12px;padding:20px;margin-bottom:16px;box-shadow:0 4px 6px -1px rgba(0,0,0,.02)}\r\n#pth-bl-studio-wrapper .pth-bl-h{font-size:1.02rem;font-weight:800;color:#1e293b;margin:0 0 14px;padding-bottom:11px;border-bottom:2px solid #e2e8f0;display:flex;align-items:center;gap:8px}\r\n#pth-bl-studio-wrapper .pth-bl-result{font-family:ui-monospace,Menlo,Consolas,monospace;font-size:1.25rem;font-weight:800;color:#047857;background:#f0fdf4;border:1px solid #bbf7d0;border-radius:10px;padding:16px 18px;word-break:break-word;line-height:1.5}\r\n#pth-bl-studio-wrapper .pth-bl-err{background:#fef2f2;border:1px solid #fecaca;color:#b91c1c;font-weight:600;font-size:.9rem;padding:12px 14px;border-radius:8px}\r\n#pth-bl-studio-wrapper .pth-bl-mono{font-family:ui-monospace,Menlo,Consolas,monospace}\r\n#pth-bl-studio-wrapper .pth-bl-steps{counter-reset:pthstep;margin:0;padding:0;list-style:none}\r\n#pth-bl-studio-wrapper .pth-bl-steps li{position:relative;padding:12px 14px 12px 46px;border:1px solid #e2e8f0;border-radius:10px;margin-bottom:10px;background:#f8fafc;font-size:.9rem;color:#334155;line-height:1.6}\r\n#pth-bl-studio-wrapper .pth-bl-steps li:before{counter-increment:pthstep;content:counter(pthstep);position:absolute;left:12px;top:12px;width:24px;height:24px;background:#2563eb;color:#fff;border-radius:50%;font-weight:800;font-size:.8rem;display:flex;align-items:center;justify-content:center}\r\n#pth-bl-studio-wrapper .pth-bl-steps b{color:#0f172a}\r\n#pth-bl-studio-wrapper .pth-bl-tag{display:inline-block;font-family:ui-monospace,Menlo,Consolas,monospace;background:#eef2ff;color:#4338ca;padding:2px 8px;border-radius:6px;font-size:.85rem;font-weight:700;margin:2px 3px}\r\n#pth-bl-studio-wrapper table.pth-bl-tbl{width:100%;border-collapse:collapse;font-size:.84rem}\r\n#pth-bl-studio-wrapper table.pth-bl-tbl th{background:#f1f5f9;color:#1e293b;font-weight:800;text-align:center;padding:8px 10px;border:1px solid #e2e8f0}\r\n#pth-bl-studio-wrapper table.pth-bl-tbl td{padding:7px 10px;border:1px solid #e2e8f0;color:#334155;text-align:center;font-family:ui-monospace,Menlo,Consolas,monospace}\r\n#pth-bl-studio-wrapper table.pth-bl-tbl td.pth-bl-x{color:#047857;font-weight:800}\r\n#pth-bl-studio-wrapper table.pth-bl-tbl tr.pth-bl-ess td{background:#f0fdf4}\r\n#pth-bl-studio-wrapper .pth-bl-tblwrap{overflow:auto;border:1px solid #e2e8f0;border-radius:10px;max-height:460px}\r\n#pth-bl-studio-wrapper .pth-bl-badge{display:inline-block;font-size:.72rem;font-weight:800;padding:2px 8px;border-radius:20px;background:#dcfce7;color:#15803d;margin-left:6px}\r\n#pth-bl-studio-wrapper .pth-bl-grid2{display:grid;grid-template-columns:1fr 1fr;gap:14px}\r\n@media(max-width:768px){#pth-bl-studio-wrapper .pth-bl-grid2{grid-template-columns:1fr}}\r\n#pth-bl-studio-wrapper .pth-bl-box{border:1px solid #e2e8f0;border-radius:10px;padding:14px;background:#f8fafc}\r\n#pth-bl-studio-wrapper .pth-bl-box h4{margin:0 0 8px;font-size:.85rem;color:#334155;font-weight:800;text-transform:uppercase;letter-spacing:.4px}\r\n#pth-bl-studio-wrapper .pth-bl-eq{font-family:ui-monospace,Menlo,Consolas,monospace;font-size:1rem;color:#0f172a;font-weight:700;word-break:break-word;line-height:1.5}\r\n#pth-bl-studio-wrapper .pth-bl-cost{display:flex;flex-wrap:wrap;gap:12px;margin-top:12px}\r\n#pth-bl-studio-wrapper .pth-bl-metric{flex:1;min-width:130px;background:#f8fafc;border:1px solid #e2e8f0;border-radius:10px;padding:14px;text-align:center}\r\n#pth-bl-studio-wrapper .pth-bl-metric b{display:block;font-size:1.6rem;color:#2563eb;font-weight:800}\r\n#pth-bl-studio-wrapper .pth-bl-metric span{font-size:.76rem;color:#475569;font-weight:700;text-transform:uppercase;letter-spacing:.4px}\r\n#pth-bl-studio-wrapper .pth-bl-law{border:1px solid #e2e8f0;border-radius:10px;padding:12px 14px;margin-bottom:10px;background:#f8fafc}\r\n#pth-bl-studio-wrapper .pth-bl-law b{color:#0f172a;font-size:.92rem}\r\n#pth-bl-studio-wrapper .pth-bl-law span{display:block;font-family:ui-monospace,Menlo,Consolas,monospace;color:#334155;font-size:.85rem;margin-top:4px}\r\n#pth-bl-studio-wrapper .pth-bl-xlink{color:#1d4ed8;font-weight:700;text-decoration:none}\r\n#pth-bl-studio-wrapper .pth-bl-xlink:hover{text-decoration:underline}\r\n#pth-bl-studio-wrapper .pth-bl-note{background:#eff6ff;border:1px solid #bfdbfe;color:#1e3a8a;font-size:.82rem;font-weight:600;padding:11px 14px;border-radius:8px;margin-top:12px;line-height:1.55}\r\n#pth-bl-studio-wrapper .pth-bl-toast{position:fixed;bottom:22px;right:22px;background:#0f172a;color:#fff;font-weight:700;font-size:.86rem;padding:12px 20px;border-radius:9px;box-shadow:0 10px 30px rgba(0,0,0,.3);z-index:99999;opacity:0;transform:translateY(10px);transition:.3s;pointer-events:none}\r\n#pth-bl-studio-wrapper .pth-bl-toast.pth-bl-tshow{opacity:1;transform:translateY(0)}\r\n@media(max-width:768px){#pth-bl-studio-wrapper{padding:14px}}\r\n<\/style>\r\n\r\n<div class=\"pth-bl-top\">\r\n  <h2 class=\"pth-bl-title\">\ud83e\uddee Boolean Algebra Studio Pro<\/h2>\r\n  <div class=\"pth-bl-sub\">A deep-dive Boolean minimizer: step-by-step simplification, the Quine\u2013McCluskey method, SOP\/POS forms, and NAND\/NOR gate realization with a cost comparison \u2014 100% offline.<\/div>\r\n  <div class=\"pth-bl-inrow\">\r\n    <div class=\"pth-bl-inbox\">\r\n      <label for=\"pth-bl-expr\">Boolean expression<\/label>\r\n      <input type=\"text\" id=\"pth-bl-expr\" spellcheck=\"false\" value=\"\">\r\n    <\/div>\r\n    <div style=\"flex:0 0 auto\"><button class=\"pth-bl-btn\" id=\"pth-bl-run\">\u26a1 Simplify<\/button><\/div>\r\n    <div style=\"flex:0 0 auto\"><button class=\"pth-bl-btn pth-bl-ghost\" id=\"pth-bl-sample\">\ud83d\udca1 Load Sample<\/button><\/div>\r\n    <div style=\"flex:0 0 auto\"><button class=\"pth-bl-btn pth-bl-ghost\" id=\"pth-bl-full\">\u26f6 Full Width<\/button><\/div>\r\n    <div style=\"flex:0 0 auto\"><button class=\"pth-bl-btn pth-bl-ghost\" id=\"pth-bl-clear\">\ud83d\uddd1\ufe0f Clear<\/button><\/div>\r\n  <\/div>\r\n  <div class=\"pth-bl-hint\">Operators: NOT = <code>A'<\/code> or <code>!A<\/code> &nbsp;\u00b7&nbsp; AND = <code>AB<\/code>, <code>A.B<\/code> or <code>A*B<\/code> &nbsp;\u00b7&nbsp; OR = <code>A+B<\/code> &nbsp;\u00b7&nbsp; XOR = <code>A^B<\/code> &nbsp;\u00b7&nbsp; use <code>( )<\/code> and constants <code>0<\/code> \/ <code>1<\/code>. Single-letter variables (A\u2013Z).<\/div>\r\n<\/div>\r\n\r\n<div class=\"pth-bl-tabs\" role=\"tablist\">\r\n  <button class=\"pth-bl-tab pth-bl-on\" data-tab=\"simplify\">\u26a1 Simplify + Steps<\/button>\r\n  <button class=\"pth-bl-tab\" data-tab=\"qm\">\ud83e\uddee Quine\u2013McCluskey<\/button>\r\n  <button class=\"pth-bl-tab\" data-tab=\"forms\">\ud83d\udd00 SOP &amp; POS<\/button>\r\n  <button class=\"pth-bl-tab\" data-tab=\"gates\">\ud83d\udd27 Gate Realization &amp; Cost<\/button>\r\n  <button class=\"pth-bl-tab\" data-tab=\"laws\">\ud83d\udcd8 Boolean Laws<\/button>\r\n<\/div>\r\n\r\n<div class=\"pth-bl-panel pth-bl-show\" id=\"pth-bl-panel-simplify\">\r\n  <div class=\"pth-bl-card\">\r\n    <div class=\"pth-bl-h\">\u26a1 Minimal Result<\/div>\r\n    <div id=\"pth-bl-simres\"><div class=\"pth-bl-hint\">Enter an expression above and press Simplify.<\/div><\/div>\r\n  <\/div>\r\n  <div class=\"pth-bl-card\">\r\n    <div class=\"pth-bl-h\">\ud83e\ude9c How it was derived<\/div>\r\n    <div id=\"pth-bl-simsteps\"><\/div>\r\n  <\/div>\r\n  <div class=\"pth-bl-note\">This tool minimizes algebraically via the truth table and the Quine\u2013McCluskey method, so the result is always the true minimal Sum-of-Products. For a visual grid view use the <a class=\"pth-bl-xlink\" href=\"\/advanced-k-map-solver\/\" target=\"_blank\" rel=\"noopener\">K-Map Solver<\/a>, and for a full input\/output table use the <a class=\"pth-bl-xlink\" href=\"\/truth-table-generator\/\" target=\"_blank\" rel=\"noopener\">Truth Table Generator<\/a>.<\/div>\r\n<\/div>\r\n\r\n<div class=\"pth-bl-panel\" id=\"pth-bl-panel-qm\">\r\n  <div class=\"pth-bl-card\">\r\n    <div class=\"pth-bl-h\">\ud83e\uddee Prime Implicants<\/div>\r\n    <div id=\"pth-bl-qmpi\"><div class=\"pth-bl-hint\">Run Simplify to see the Quine\u2013McCluskey working.<\/div><\/div>\r\n  <\/div>\r\n  <div class=\"pth-bl-card\">\r\n    <div class=\"pth-bl-h\">\u2705 Prime Implicant Chart<\/div>\r\n    <div id=\"pth-bl-qmchart\"><\/div>\r\n  <\/div>\r\n<\/div>\r\n\r\n<div class=\"pth-bl-panel\" id=\"pth-bl-panel-forms\">\r\n  <div class=\"pth-bl-card\">\r\n    <div class=\"pth-bl-h\">\ud83d\udd00 Canonical vs Minimal<\/div>\r\n    <div id=\"pth-bl-forms\"><div class=\"pth-bl-hint\">Run Simplify to see SOP and POS forms.<\/div><\/div>\r\n  <\/div>\r\n<\/div>\r\n\r\n<div class=\"pth-bl-panel\" id=\"pth-bl-panel-gates\">\r\n  <div class=\"pth-bl-card\">\r\n    <div class=\"pth-bl-h\">\ud83d\udd27 Gate Realizations<\/div>\r\n    <div id=\"pth-bl-gates\"><div class=\"pth-bl-hint\">Run Simplify to see AND-OR, NAND and NOR forms.<\/div><\/div>\r\n  <\/div>\r\n  <div class=\"pth-bl-card\">\r\n    <div class=\"pth-bl-h\">\ud83d\udcc9 Cost Comparison<\/div>\r\n    <div id=\"pth-bl-cost\"><\/div>\r\n  <\/div>\r\n  <div class=\"pth-bl-note\">Need to convert whole circuits or see waveforms? The all-in-one <a class=\"pth-bl-xlink\" href=\"\/universal-logic-gate-converter-pro\/\" target=\"_blank\" rel=\"noopener\">Digital Logic Studio<\/a> handles gate conversion, timing and circuit building.<\/div>\r\n<\/div>\r\n\r\n<div class=\"pth-bl-panel\" id=\"pth-bl-panel-laws\">\r\n  <div class=\"pth-bl-card\">\r\n    <div class=\"pth-bl-h\">\ud83d\udcd8 Boolean Algebra Laws<\/div>\r\n    <div class=\"pth-bl-grid2\">\r\n      <div><div class=\"pth-bl-law\"><b>Identity<\/b><span>A + 0 = A &nbsp;\u00b7&nbsp; A \u00b7 1 = A<\/span><\/div>\r\n      <div class=\"pth-bl-law\"><b>Null \/ Annulment<\/b><span>A + 1 = 1 &nbsp;\u00b7&nbsp; A \u00b7 0 = 0<\/span><\/div>\r\n      <div class=\"pth-bl-law\"><b>Idempotent<\/b><span>A + A = A &nbsp;\u00b7&nbsp; A \u00b7 A = A<\/span><\/div>\r\n      <div class=\"pth-bl-law\"><b>Complement<\/b><span>A + A' = 1 &nbsp;\u00b7&nbsp; A \u00b7 A' = 0<\/span><\/div>\r\n      <div class=\"pth-bl-law\"><b>Double Negation<\/b><span>(A')' = A<\/span><\/div>\r\n      <div class=\"pth-bl-law\"><b>Commutative<\/b><span>A + B = B + A &nbsp;\u00b7&nbsp; AB = BA<\/span><\/div><\/div>\r\n      <div><div class=\"pth-bl-law\"><b>Associative<\/b><span>A + (B + C) = (A + B) + C<\/span><\/div>\r\n      <div class=\"pth-bl-law\"><b>Distributive<\/b><span>A(B + C) = AB + AC<\/span><\/div>\r\n      <div class=\"pth-bl-law\"><b>Absorption<\/b><span>A + AB = A &nbsp;\u00b7&nbsp; A(A + B) = A<\/span><\/div>\r\n      <div class=\"pth-bl-law\"><b>De Morgan<\/b><span>(A + B)' = A'B' &nbsp;\u00b7&nbsp; (AB)' = A' + B'<\/span><\/div>\r\n      <div class=\"pth-bl-law\"><b>Consensus<\/b><span>AB + A'C + BC = AB + A'C<\/span><\/div>\r\n      <div class=\"pth-bl-law\"><b>Redundancy<\/b><span>A + A'B = A + B<\/span><\/div><\/div>\r\n    <\/div>\r\n  <\/div>\r\n<\/div>\r\n\r\n<div class=\"pth-bl-toast\" id=\"pth-bl-toast\"><\/div>\r\n<\/div>\r\n\r\n<script data-no-optimize=\"1\" data-no-minify=\"1\" data-cfasync=\"false\">\r\nwindow.pthBoolStudioApp = (function () {\r\n    'use strict';\r\n    var root = null;\r\n    var SAMPLE = \"A'C + A'B + AB'C + BC\";\r\n    var state = { result: null };\r\n\r\n    function byId(id) { return document.getElementById(id); }\r\n    function toast(m) {\r\n        var t = byId('pth-bl-toast'); if (!t) { return; }\r\n        t.textContent = m; t.className = 'pth-bl-toast pth-bl-tshow';\r\n        window.setTimeout(function () { t.className = 'pth-bl-toast'; }, 2000);\r\n    }\r\n    function el(tag, cls, txt) { var e = document.createElement(tag); if (cls) { e.className = cls; } if (txt !== undefined) { e.textContent = txt; } return e; }\r\n\r\n    \/* ---------- ENGINE ---------- *\/\r\n    function tokenize(s) {\r\n        var toks = [], i, c;\r\n        for (i = 0; i < s.length; i++) {\r\n            c = s.charAt(i);\r\n            if (c === ' ' || c === '\\t' || c === '\\n') { continue; }\r\n            if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) { toks.push({ t: 'VAR', v: c.toUpperCase() }); }\r\n            else if (c === '0' || c === '1') { toks.push({ t: 'CONST', v: parseInt(c, 10) }); }\r\n            else if (c === '+' || c === '|') { toks.push({ t: 'OR' }); }\r\n            else if (c === '.' || c === '*' || c === '&') { toks.push({ t: 'AND' }); }\r\n            else if (c === '^') { toks.push({ t: 'XOR' }); }\r\n            else if (c === '(') { toks.push({ t: 'LP' }); }\r\n            else if (c === ')') { toks.push({ t: 'RP' }); }\r\n            else if (c === \"'\") { toks.push({ t: 'NOTP' }); }\r\n            else if (c === '!' || c === '~') { toks.push({ t: 'NOTPRE' }); }\r\n            else { throw new Error('Unexpected character \"' + c + '\"'); }\r\n        }\r\n        return toks;\r\n    }\r\n    function parse(s) {\r\n        var toks = tokenize(s), pos = 0;\r\n        function peek() { return toks[pos]; }\r\n        function isFactor(tk) { return tk && (tk.t === 'VAR' || tk.t === 'CONST' || tk.t === 'LP' || tk.t === 'NOTPRE'); }\r\n        function pOr() { var l = pXor(); while (peek() && peek().t === 'OR') { pos++; l = { op: 'or', l: l, r: pXor() }; } return l; }\r\n        function pXor() { var l = pAnd(); while (peek() && peek().t === 'XOR') { pos++; l = { op: 'xor', l: l, r: pAnd() }; } return l; }\r\n        function pAnd() {\r\n            var l = pUn();\r\n            while (true) {\r\n                var tk = peek();\r\n                if (tk && tk.t === 'AND') { pos++; l = { op: 'and', l: l, r: pUn() }; }\r\n                else if (isFactor(tk)) { l = { op: 'and', l: l, r: pUn() }; }\r\n                else { break; }\r\n            }\r\n            return l;\r\n        }\r\n        function pUn() { if (peek() && peek().t === 'NOTPRE') { pos++; return { op: 'not', c: pUn() }; } return pPost(); }\r\n        function pPost() { var n = pPrim(); while (peek() && peek().t === 'NOTP') { pos++; n = { op: 'not', c: n }; } return n; }\r\n        function pPrim() {\r\n            var tk = peek();\r\n            if (!tk) { throw new Error('Unexpected end of expression'); }\r\n            if (tk.t === 'VAR') { pos++; return { op: 'var', v: tk.v }; }\r\n            if (tk.t === 'CONST') { pos++; return { op: 'const', v: tk.v }; }\r\n            if (tk.t === 'LP') { pos++; var e = pOr(); if (!peek() || peek().t !== 'RP') { throw new Error('Missing closing parenthesis'); } pos++; return e; }\r\n            throw new Error('Unexpected symbol');\r\n        }\r\n        var ast = pOr();\r\n        if (pos < toks.length) { throw new Error('Unexpected trailing input'); }\r\n        return ast;\r\n    }\r\n    function collectVars(ast) {\r\n        var set = {};\r\n        (function w(n) { if (!n) { return; } if (n.op === 'var') { set[n.v] = true; return; } if (n.c) { w(n.c); } if (n.l) { w(n.l); } if (n.r) { w(n.r); } })(ast);\r\n        var a = [], k; for (k in set) { if (set.hasOwnProperty(k)) { a.push(k); } } a.sort(); return a;\r\n    }\r\n    function ev(n, asg) {\r\n        switch (n.op) {\r\n            case 'var': return asg[n.v] ? 1 : 0;\r\n            case 'const': return n.v ? 1 : 0;\r\n            case 'not': return ev(n.c, asg) ? 0 : 1;\r\n            case 'and': return (ev(n.l, asg) && ev(n.r, asg)) ? 1 : 0;\r\n            case 'or': return (ev(n.l, asg) || ev(n.r, asg)) ? 1 : 0;\r\n            case 'xor': return (ev(n.l, asg) ^ ev(n.r, asg)) ? 1 : 0;\r\n        }\r\n        return 0;\r\n    }\r\n    function truth(ast, vars) {\r\n        var n = vars.length, rows = [], i, j, asg, total = Math.pow(2, n);\r\n        for (i = 0; i < total; i++) { asg = {}; for (j = 0; j < n; j++) { asg[vars[j]] = (i >> (n - 1 - j)) & 1; } rows.push({ idx: i, out: ev(ast, asg) }); }\r\n        return rows;\r\n    }\r\n    function toBin(m, n) { var s = '', i; for (i = n - 1; i >= 0; i--) { s += ((m >> i) & 1); } return s; }\r\n    function combine(a, b) {\r\n        var diff = 0, p = -1, i, r = '';\r\n        for (i = 0; i < a.length; i++) { if (a.charAt(i) !== b.charAt(i)) { if (a.charAt(i) === '-' || b.charAt(i) === '-') { return null; } diff++; p = i; } }\r\n        if (diff !== 1) { return null; }\r\n        for (i = 0; i < a.length; i++) { r += (i === p ? '-' : a.charAt(i)); }\r\n        return r;\r\n    }\r\n    function uCov(a, b) { var m = {}, i, o = []; for (i = 0; i < a.length; i++) { m[a[i]] = true; } for (i = 0; i < b.length; i++) { m[b[i]] = true; } for (var k in m) { if (m.hasOwnProperty(k)) { o.push(parseInt(k, 10)); } } return o; }\r\n    function primes(minterms, n) {\r\n        var cur = [], i;\r\n        for (i = 0; i < minterms.length; i++) { cur.push({ bits: toBin(minterms[i], n), covers: [minterms[i]] }); }\r\n        var pr = [], pk = {};\r\n        while (cur.length) {\r\n            var flag = {}, next = [], nk = {}, a, b;\r\n            for (a = 0; a < cur.length; a++) {\r\n                for (b = a + 1; b < cur.length; b++) {\r\n                    var cb = combine(cur[a].bits, cur[b].bits);\r\n                    if (cb) { flag[a] = true; flag[b] = true; if (!nk[cb]) { nk[cb] = true; next.push({ bits: cb, covers: uCov(cur[a].covers, cur[b].covers) }); } }\r\n                }\r\n            }\r\n            for (a = 0; a < cur.length; a++) { if (!flag[a] && !pk[cur[a].bits]) { pk[cur[a].bits] = true; pr.push(cur[a]); } }\r\n            cur = next;\r\n        }\r\n        return pr;\r\n    }\r\n    function choose(pr, minterms) {\r\n        var i, j, coverOf = {}, chosen = [], ck = {}, uncov = {};\r\n        for (i = 0; i < minterms.length; i++) { coverOf[minterms[i]] = []; uncov[minterms[i]] = true; }\r\n        for (i = 0; i < pr.length; i++) { for (j = 0; j < pr[i].covers.length; j++) { var mt = pr[i].covers[j]; if (coverOf.hasOwnProperty(mt)) { coverOf[mt].push(i); } } }\r\n        var ess = {};\r\n        for (i = 0; i < minterms.length; i++) { if (coverOf[minterms[i]].length === 1) { ess[coverOf[minterms[i]][0]] = true; } }\r\n        var e; for (e in ess) { if (ess.hasOwnProperty(e)) { var ei = parseInt(e, 10); chosen.push(ei); ck[ei] = true; var cv = pr[ei].covers; for (j = 0; j < cv.length; j++) { delete uncov[cv[j]]; } } }\r\n        function rem(pi) { var c = 0, k; for (k = 0; k < pi.covers.length; k++) { if (uncov[pi.covers[k]]) { c++; } } return c; }\r\n        while (true) {\r\n            var any = false, mk; for (mk in uncov) { if (uncov.hasOwnProperty(mk)) { any = true; break; } }\r\n            if (!any) { break; }\r\n            var best = -1, bc = -1;\r\n            for (i = 0; i < pr.length; i++) { if (ck[i]) { continue; } var rc = rem(pr[i]); if (rc > bc) { bc = rc; best = i; } }\r\n            if (best < 0 || bc <= 0) { break; }\r\n            chosen.push(best); ck[best] = true; var cv2 = pr[best].covers; for (j = 0; j < cv2.length; j++) { delete uncov[cv2[j]]; }\r\n        }\r\n        return { chosen: chosen, essential: ess, coverOf: coverOf };\r\n    }\r\n    function bitsTerm(bits, vars) { var s = '', i; for (i = 0; i < bits.length; i++) { var c = bits.charAt(i); if (c === '1') { s += vars[i]; } else if (c === '0') { s += vars[i] + \"'\"; } } return s === '' ? '1' : s; }\r\n    function litCount(bits) { var c = 0, i; for (i = 0; i < bits.length; i++) { if (bits.charAt(i) !== '-') { c++; } } return c; }\r\n\r\n    function minimizeSOP(minterms, n, vars) {\r\n        var total = Math.pow(2, n);\r\n        if (minterms.length === 0) { return { expr: '0', terms: [], literals: 0, primes: [], sel: { chosen: [], essential: {}, coverOf: {} } }; }\r\n        if (minterms.length === total) { return { expr: '1', terms: [], literals: 0, primes: [], sel: { chosen: [], essential: {}, coverOf: {} } }; }\r\n        var pr = primes(minterms, n), sel = choose(pr, minterms), terms = [], i;\r\n        for (i = 0; i < sel.chosen.length; i++) { var pi = pr[sel.chosen[i]]; terms.push({ bits: pi.bits, str: bitsTerm(pi.bits, vars), lit: litCount(pi.bits) }); }\r\n        terms.sort(function (a, b) { return a.str.length - b.str.length; });\r\n        var strs = [], lits = 0; for (i = 0; i < terms.length; i++) { strs.push(terms[i].str); lits += terms[i].lit; }\r\n        return { expr: strs.join(' + '), terms: terms, literals: lits, primes: pr, sel: sel };\r\n    }\r\n    function minimizePOS(zeros, n, vars) {\r\n        var total = Math.pow(2, n);\r\n        if (zeros.length === 0) { return { expr: '1', clauses: [], literals: 0 }; }\r\n        if (zeros.length === total) { return { expr: '0', clauses: [], literals: 0 }; }\r\n        var comp = minimizeSOP(zeros, n, vars), clauses = [], lits = 0, i;\r\n        for (i = 0; i < comp.terms.length; i++) {\r\n            var bits = comp.terms[i].bits, cl = '', j;\r\n            for (j = 0; j < bits.length; j++) { var c = bits.charAt(j); if (c === '1') { cl += (cl ? ' + ' : '') + vars[j] + \"'\"; lits++; } else if (c === '0') { cl += (cl ? ' + ' : '') + vars[j]; lits++; } }\r\n            clauses.push(cl === '' ? '1' : cl);\r\n        }\r\n        var expr = '';\r\n        for (i = 0; i < clauses.length; i++) { expr += '(' + clauses[i] + ')'; }\r\n        return { expr: expr, clauses: clauses, literals: lits };\r\n    }\r\n\r\n    \/* ---------- ANALYZE ---------- *\/\r\n    function analyze() {\r\n        var raw = byId('pth-bl-expr').value;\r\n        if (!raw || !raw.replace(\/^\\s+|\\s+$\/g, '')) { showError('Enter a Boolean expression first.'); return; }\r\n        var ast, vars, rows;\r\n        try { ast = parse(raw); vars = collectVars(ast); }\r\n        catch (e) { showError(e.message || 'Could not parse that expression.'); return; }\r\n        if (vars.length === 0) {\r\n            try { var v0 = ev(ast, {}); state.result = { constant: v0 }; renderConst(v0); return; }\r\n            catch (e2) { showError('Invalid expression.'); return; }\r\n        }\r\n        if (vars.length > 8) { showError('Please use up to 8 variables (' + vars.length + ' found).'); return; }\r\n        rows = truth(ast, vars);\r\n        var minterms = [], maxterms = [], i;\r\n        for (i = 0; i < rows.length; i++) { if (rows[i].out === 1) { minterms.push(rows[i].idx); } else { maxterms.push(rows[i].idx); } }\r\n        var sop = minimizeSOP(minterms, vars.length, vars);\r\n        var pos = minimizePOS(maxterms, vars.length, vars);\r\n        state.result = { expr: raw, vars: vars, rows: rows, minterms: minterms, maxterms: maxterms, sop: sop, pos: pos, n: vars.length };\r\n        renderAll();\r\n        toast('Simplified');\r\n    }\r\n    function showError(msg) {\r\n        state.result = null;\r\n        var box = byId('pth-bl-simres'); box.innerHTML = ''; box.appendChild(el('div', 'pth-bl-err', msg));\r\n        byId('pth-bl-simsteps').innerHTML = '';\r\n    }\r\n    function renderConst(v) {\r\n        var box = byId('pth-bl-simres'); box.innerHTML = '';\r\n        box.appendChild(el('div', 'pth-bl-result', 'F = ' + v));\r\n        byId('pth-bl-simsteps').innerHTML = '';\r\n        toast('Constant expression');\r\n    }\r\n\r\n    function renderAll() {\r\n        renderSimplify(); renderQM(); renderForms(); renderGates();\r\n    }\r\n\r\n    function renderSimplify() {\r\n        var r = state.result; if (!r) { return; }\r\n        var box = byId('pth-bl-simres'); box.innerHTML = '';\r\n        box.appendChild(el('div', 'pth-bl-result', 'F = ' + r.sop.expr));\r\n\r\n        var steps = byId('pth-bl-simsteps'); steps.innerHTML = '';\r\n        var ul = el('ol', 'pth-bl-steps');\r\n        var li1 = el('li'); li1.innerHTML = ''; li1.appendChild(document.createTextNode('Variables detected: ')); var b1 = el('b', null, r.vars.join(', ')); li1.appendChild(b1); ul.appendChild(li1);\r\n        var li2 = el('li'); li2.appendChild(document.createTextNode('Build the truth table and read the minterms (rows where F = 1): '));\r\n        var mm = el('span', null, '\u03a3m(' + r.minterms.join(', ') + ')'); mm.className = 'pth-bl-mono'; li2.appendChild(mm); ul.appendChild(li2);\r\n        var li3 = el('li'); li3.appendChild(document.createTextNode('Quine\u2013McCluskey combines adjacent minterms to find the prime implicants: '));\r\n        var pcount = r.sop.primes.length; li3.appendChild(el('b', null, pcount + ' prime implicant' + (pcount === 1 ? '' : 's'))); ul.appendChild(li3);\r\n        var essCount = 0, k; for (k in r.sop.sel.essential) { if (r.sop.sel.essential.hasOwnProperty(k)) { essCount++; } }\r\n        var li4 = el('li'); li4.appendChild(document.createTextNode('Select the essential prime implicants, then cover any remaining minterms: '));\r\n        li4.appendChild(el('b', null, essCount + ' essential')); ul.appendChild(li4);\r\n        var li5 = el('li'); li5.appendChild(document.createTextNode('The chosen implicants give the minimal Sum-of-Products: '));\r\n        var res = el('b', null, 'F = ' + r.sop.expr); li5.appendChild(res); ul.appendChild(li5);\r\n        steps.appendChild(ul);\r\n    }\r\n\r\n    function renderQM() {\r\n        var r = state.result; if (!r) { return; }\r\n        var pi = byId('pth-bl-qmpi'); pi.innerHTML = '';\r\n        var wrap = el('div', 'pth-bl-tblwrap');\r\n        var t = el('table', 'pth-bl-tbl');\r\n        var thead = el('thead'); var htr = el('tr');\r\n        ['Prime implicant', 'Term', 'Covers minterms', 'Literals'].forEach(function (h) { htr.appendChild(el('th', null, h)); });\r\n        thead.appendChild(htr); t.appendChild(thead);\r\n        var tb = el('tbody'), i;\r\n        for (i = 0; i < r.sop.primes.length; i++) {\r\n            var p = r.sop.primes[i], tr = el('tr');\r\n            tr.appendChild(el('td', null, p.bits));\r\n            tr.appendChild(el('td', null, bitsTerm(p.bits, r.vars)));\r\n            var cov = p.covers.slice(0); cov.sort(function (a, b) { return a - b; });\r\n            tr.appendChild(el('td', null, cov.join(', ')));\r\n            tr.appendChild(el('td', null, String(litCount(p.bits))));\r\n            tb.appendChild(tr);\r\n        }\r\n        t.appendChild(tb); wrap.appendChild(t); pi.appendChild(wrap);\r\n\r\n        var chart = byId('pth-bl-qmchart'); chart.innerHTML = '';\r\n        if (!r.minterms.length) { chart.appendChild(el('div', 'pth-bl-hint', 'No minterms (F = 0).')); return; }\r\n        var cw = el('div', 'pth-bl-tblwrap'); var ct = el('table', 'pth-bl-tbl');\r\n        var ch = el('thead'); var chtr = el('tr'); chtr.appendChild(el('th', null, 'PI \\\\ m'));\r\n        var j; for (j = 0; j < r.minterms.length; j++) { chtr.appendChild(el('th', null, String(r.minterms[j]))); }\r\n        ch.appendChild(chtr); ct.appendChild(ch);\r\n        var ctb = el('tbody');\r\n        for (i = 0; i < r.sop.primes.length; i++) {\r\n            var pp = r.sop.primes[i]; var isChosen = false, c2;\r\n            for (c2 = 0; c2 < r.sop.sel.chosen.length; c2++) { if (r.sop.sel.chosen[c2] === i) { isChosen = true; break; } }\r\n            var rtr = el('tr'); if (r.sop.sel.essential[i]) { rtr.className = 'pth-bl-ess'; }\r\n            var lbl = el('td', null, bitsTerm(pp.bits, r.vars) + (r.sop.sel.essential[i] ? '  *' : '')); rtr.appendChild(lbl);\r\n            var covmap = {}; for (c2 = 0; c2 < pp.covers.length; c2++) { covmap[pp.covers[c2]] = true; }\r\n            for (j = 0; j < r.minterms.length; j++) {\r\n                var cell = el('td', null, covmap[r.minterms[j]] ? 'X' : ''); if (covmap[r.minterms[j]]) { cell.className = 'pth-bl-x'; } rtr.appendChild(cell);\r\n            }\r\n            ctb.appendChild(rtr);\r\n        }\r\n        ct.appendChild(ctb); cw.appendChild(ct); chart.appendChild(cw);\r\n        chart.appendChild(el('div', 'pth-bl-hint', 'Rows marked * are essential prime implicants (they solely cover at least one minterm).'));\r\n    }\r\n\r\n    function canonicalSOP(minterms, n, vars) {\r\n        if (!minterms.length) { return '0'; }\r\n        var parts = [], i, cap = 20;\r\n        for (i = 0; i < minterms.length && i < cap; i++) { parts.push(bitsTerm(toBin(minterms[i], n), vars)); }\r\n        var s = parts.join(' + '); if (minterms.length > cap) { s += ' + ... (' + minterms.length + ' terms)'; } return s;\r\n    }\r\n    function canonicalPOS(maxterms, n, vars) {\r\n        if (!maxterms.length) { return '1'; }\r\n        var parts = [], i, cap = 20;\r\n        for (i = 0; i < maxterms.length && i < cap; i++) {\r\n            var bits = toBin(maxterms[i], n), cl = '', j;\r\n            for (j = 0; j < bits.length; j++) { cl += (cl ? ' + ' : '') + (bits.charAt(j) === '1' ? vars[j] + \"'\" : vars[j]); }\r\n            parts.push('(' + cl + ')');\r\n        }\r\n        var s = parts.join(''); if (maxterms.length > cap) { s += ' ... (' + maxterms.length + ' terms)'; } return s;\r\n    }\r\n\r\n    function renderForms() {\r\n        var r = state.result; if (!r) { return; }\r\n        var box = byId('pth-bl-forms'); box.innerHTML = '';\r\n        var grid = el('div', 'pth-bl-grid2');\r\n        function b(title, canon, mini, mlabel) {\r\n            var d = el('div', 'pth-bl-box');\r\n            d.appendChild(el('h4', null, title));\r\n            var c = el('div', 'pth-bl-eq'); c.style.color = '#475569'; c.style.fontSize = '.9rem'; c.textContent = 'Canonical: ' + canon; d.appendChild(c);\r\n            var m = el('div', 'pth-bl-eq'); m.style.marginTop = '8px'; m.textContent = mlabel + ' ' + mini; d.appendChild(m);\r\n            return d;\r\n        }\r\n        grid.appendChild(b('Sum of Products (SOP)', canonicalSOP(r.minterms, r.n, r.vars), r.sop.expr, 'Minimal: F ='));\r\n        grid.appendChild(b('Product of Sums (POS)', canonicalPOS(r.maxterms, r.n, r.vars), r.pos.expr, 'Minimal: F ='));\r\n        box.appendChild(grid);\r\n        box.appendChild(el('div', 'pth-bl-hint', '\u03a3m lists the minterms (F = 1); \u03a0M lists the maxterms (F = 0). Minimal forms come from Quine\u2013McCluskey on each set.'));\r\n    }\r\n\r\n    function renderGates() {\r\n        var r = state.result; if (!r) { return; }\r\n        var box = byId('pth-bl-gates'); box.innerHTML = '';\r\n        var sop = r.sop, pos = r.pos;\r\n        var nand = '';\r\n        if (sop.terms.length) { var i, parts = []; for (i = 0; i < sop.terms.length; i++) { parts.push('(' + sop.terms[i].str + \")'\"); } nand = '( ' + parts.join(' ') + \" )'\"; }\r\n        else { nand = sop.expr; }\r\n        var nor = '';\r\n        if (pos.clauses.length) { var j, cp = []; for (j = 0; j < pos.clauses.length; j++) { cp.push('(' + pos.clauses[j] + \")'\"); } nor = '( ' + cp.join(' + ') + \" )'\"; }\r\n        else { nor = pos.expr; }\r\n\r\n        function box4(title, eq, note) {\r\n            var d = el('div', 'pth-bl-box');\r\n            d.appendChild(el('h4', null, title));\r\n            var e = el('div', 'pth-bl-eq'); e.textContent = 'F = ' + eq; d.appendChild(e);\r\n            if (note) { d.appendChild(el('div', 'pth-bl-hint', note)); }\r\n            return d;\r\n        }\r\n        var g = el('div', 'pth-bl-grid2');\r\n        g.appendChild(box4('AND\u2013OR (2-level SOP)', sop.expr, 'Products feed one OR gate.'));\r\n        g.appendChild(box4('NAND\u2013NAND', nand, 'Same as SOP, realized with NAND gates only.'));\r\n        g.appendChild(box4('OR\u2013AND (2-level POS)', pos.expr, 'Sum terms feed one AND gate.'));\r\n        g.appendChild(box4('NOR\u2013NOR', nor, 'Same as POS, realized with NOR gates only.'));\r\n        box.appendChild(g);\r\n\r\n        var cost = byId('pth-bl-cost'); cost.innerHTML = '';\r\n        var canonLit = r.minterms.length * r.n;\r\n        var minLit = sop.literals;\r\n        var canonTerms = r.minterms.length;\r\n        var minTerms = sop.terms.length;\r\n        var red = canonLit > 0 ? Math.round((1 - minLit \/ canonLit) * 100) : 0;\r\n        var row = el('div', 'pth-bl-cost');\r\n        function metric(val, lbl) { var m = el('div', 'pth-bl-metric'); m.appendChild(el('b', null, String(val))); m.appendChild(el('span', null, lbl)); return m; }\r\n        row.appendChild(metric(canonTerms + ' \\u2192 ' + minTerms, 'Product terms'));\r\n        row.appendChild(metric(canonLit + ' \\u2192 ' + minLit, 'Literals'));\r\n        row.appendChild(metric(red + '%', 'Literal reduction'));\r\n        cost.appendChild(row);\r\n        cost.appendChild(el('div', 'pth-bl-hint', 'Canonical is the raw sum-of-minterms; minimal is after Quine\u2013McCluskey. Fewer literals means fewer gate inputs and a cheaper circuit.'));\r\n    }\r\n\r\n    \/* ---------- UI ---------- *\/\r\n    function initTabs() {\r\n        var tabs = root.querySelectorAll('.pth-bl-tab'), i;\r\n        for (i = 0; i < tabs.length; i++) {\r\n            tabs[i].addEventListener('click', function () {\r\n                var name = this.getAttribute('data-tab'), all = root.querySelectorAll('.pth-bl-tab'), j;\r\n                for (j = 0; j < all.length; j++) { all[j].className = 'pth-bl-tab'; }\r\n                this.className = 'pth-bl-tab pth-bl-on';\r\n                var pans = root.querySelectorAll('.pth-bl-panel');\r\n                for (j = 0; j < pans.length; j++) { pans[j].className = 'pth-bl-panel'; }\r\n                var p = byId('pth-bl-panel-' + name); if (p) { p.className = 'pth-bl-panel pth-bl-show'; }\r\n            });\r\n        }\r\n    }\r\n    function init() {\r\n        root = document.getElementById('pth-bl-studio-wrapper');\r\n        if (!root || root.getAttribute('data-pth-init') === '1') { return; }\r\n        root.setAttribute('data-pth-init', '1');\r\n        initTabs();\r\n        byId('pth-bl-run').addEventListener('click', analyze);\r\n        byId('pth-bl-expr').addEventListener('keydown', function (e) { if (e.keyCode === 13) { analyze(); } });\r\n        byId('pth-bl-sample').addEventListener('click', function () { byId('pth-bl-expr').value = SAMPLE; analyze(); });\r\n        byId('pth-bl-clear').addEventListener('click', function () {\r\n            byId('pth-bl-expr').value = '';\r\n            byId('pth-bl-simres').innerHTML = '<div class=\"pth-bl-hint\">Enter an expression above and press Simplify.<\/div>';\r\n            byId('pth-bl-simsteps').innerHTML = '';\r\n            byId('pth-bl-qmpi').innerHTML = ''; byId('pth-bl-qmchart').innerHTML = '';\r\n            byId('pth-bl-forms').innerHTML = ''; byId('pth-bl-gates').innerHTML = ''; byId('pth-bl-cost').innerHTML = '';\r\n            state.result = null; toast('Cleared');\r\n        });\r\n        byId('pth-bl-full').addEventListener('click', function () {\r\n            if (root.className.indexOf('pth-bl-full') !== -1) { root.className = root.className.replace(' pth-bl-full', '').replace('pth-bl-full', ''); }\r\n            else { root.className = root.className + ' pth-bl-full'; }\r\n        });\r\n    }\r\n    return { init: init };\r\n})();\r\n\r\n\/* 4-layer bootstrap (LiteSpeed-safe) *\/\r\n(function () {\r\n    function boot() { if (window.pthBoolStudioApp && document.getElementById('pth-bl-studio-wrapper')) { window.pthBoolStudioApp.init(); } }\r\n    if (document.readyState === 'complete' || document.readyState === 'interactive') { window.setTimeout(boot, 1); }\r\n    document.addEventListener('DOMContentLoaded', boot);\r\n    window.addEventListener('load', boot);\r\n    window.setTimeout(boot, 900);\r\n})();\r\n<\/script>\n\n\n\n<style>\n.pth-feature-wrap { display: grid; grid-template-columns: repeat(auto-fit, minmax(280px, 1fr)); gap: 20px; margin-bottom: 30px; }\n.pth-feat-box { border: 1px solid #e2e8f0; background: #ffffff; padding: 24px; border-radius: 12px; box-shadow: 0 4px 6px -1px rgba(0,0,0,0.02); transition: all 0.3s ease; }\n.pth-feat-box:hover { border-color: #bfdbfe; transform: translateY(-3px); box-shadow: 0 10px 15px -3px rgba(0,0,0,0.05); }\n.pth-feat-title { font-size: 1.1rem; font-weight: 800; color: #0f172a; margin-bottom: 10px; display: flex; align-items: center; gap: 10px; }\n.pth-feat-text { font-size: 0.9rem; color: #475569; line-height: 1.6; margin: 0; }\n.pth-steps-wrap { border: 1px solid #e2e8f0; background: #ffffff; padding: 40px 30px; border-radius: 16px; text-align: center; box-shadow: 0 4px 6px -1px rgba(0,0,0,0.02); margin-bottom: 40px; }\n.pth-steps-title { font-size: 1.2rem; font-weight: 800; color: #1e293b; text-transform: uppercase; margin-bottom: 35px; letter-spacing: 1px; }\n.pth-steps-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(220px, 1fr)); gap: 30px; }\n.pth-step-item { display: flex; flex-direction: column; align-items: center; }\n.pth-step-num { width: 45px; height: 45px; background: #3b82f6; color: #ffffff; border-radius: 50%; display: flex; align-items: center; justify-content: center; font-weight: 800; font-size: 1.2rem; margin-bottom: 15px; box-shadow: 0 4px 10px rgba(59,130,246,0.3); }\n.pth-step-name { font-weight: 800; color: #0f172a; margin-bottom: 8px; font-size: 1.05rem; }\n.pth-step-desc { font-size: 0.9rem; color: #64748b; line-height: 1.5; margin: 0; }\n<\/style>\n<div class=\"pth-feature-wrap\">\n    <div class=\"pth-feat-box\">\n        <div class=\"pth-feat-title\">\ud83d\udfe2 Algorithmic Reduction<\/div>\n        <p class=\"pth-feat-text\">This Boolean Expression Simplifier executes discrete mathematical theorems iteratively to minimize complex variable sets into their most highly optimized forms natively.<\/p>\n    <\/div>\n    <div class=\"pth-feat-box\">\n        <div class=\"pth-feat-title\">\ud83d\udd35 Step-by-Step Resolution<\/div>\n        <p class=\"pth-feat-text\">The compiler outputs a strict chronological audit trail, displaying exactly which specific algebraic rule modified the parent string during processing.<\/p>\n    <\/div>\n    <div class=\"pth-feat-box\">\n        <div class=\"pth-feat-title\">\ud83d\udfe3 Hardware-Isolated Processing<\/div>\n        <p class=\"pth-feat-text\">By isolating the evaluation loop within the local browser DOM, developers can process unreleased circuitry blueprints completely offline without remote server intervention.<\/p>\n    <\/div>\n<\/div>\n<div class=\"pth-steps-wrap\">\n    <div class=\"pth-steps-title\">How to Use the Boolean Expression Simplifier<\/div>\n    <div class=\"pth-steps-grid\">\n        <div class=\"pth-step-item\">\n            <div class=\"pth-step-num\">1<\/div>\n            <div class=\"pth-step-name\">Inject Syntax Equation<\/div>\n            <p class=\"pth-step-desc\">Enter your raw logical operators manually or insert variables using the integrated virtual symbol keyboard.<\/p>\n        <\/div>\n        <div class=\"pth-step-item\">\n            <div class=\"pth-step-num\">2<\/div>\n            <div class=\"pth-step-name\">Select Display Notation<\/div>\n            <p class=\"pth-step-desc\">Configure the interface to render text-based operators or strict mathematical symbols based on your academic requirements.<\/p>\n        <\/div>\n        <div class=\"pth-step-item\">\n            <div class=\"pth-step-num\">3<\/div>\n            <div class=\"pth-step-name\">Execute Simplification<\/div>\n            <p class=\"pth-step-desc\">Trigger the compiler to apply theorems iteratively until the logical string reaches its absolute minimal viable form.<\/p>\n        <\/div>\n        <div class=\"pth-step-item\">\n            <div class=\"pth-step-num\">4<\/div>\n            <div class=\"pth-step-name\">Extract Documentation<\/div>\n            <p class=\"pth-step-desc\">Copy the finalized output or download a detailed TXT file containing the complete mathematical step breakdown.<\/p>\n        <\/div>\n    <\/div>\n<\/div>\n\n\n\n<p class=\"wp-block-paragraph\">Last updated: July 2026<\/p>\n\n\n\n<h2 id=\"\ud83d\udd34-writing-the-expression-the-tool-understands\" class=\"wp-block-heading\">\ud83d\udd34&nbsp;<strong>Writing the expression the tool understands<\/strong><\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">The input accepts the notation you already write by hand. NOT is an apostrophe after the variable, as in A&#8217;, or an exclamation mark before it. AND is implied by writing letters together, so AB means A AND B, and a dot or asterisk works too. OR is a plus sign, XOR is a caret, and parentheses group as you would expect. Constants 0 and 1 are allowed. Variables are single letters, and the tool handles up to eight of them, which covers essentially every textbook problem and most real design work.<\/p>\n\n\n\n<h2 id=\"\ud83d\udfe1-a-worked-example-tab-by-tab\" class=\"wp-block-heading\">\ud83d\udfe1&nbsp;<strong>A worked example, tab by tab<\/strong><\/h2>\n\n\n<figure class=\"pth-article-figure pth-img-left\" style=\"float:left; width:700px; max-width:100%; margin:4px 28px 16px 0; clear:left;\"><img decoding=\"async\" src=\"https:\/\/schoolict.net\/tools\/wp-content\/uploads\/2026\/07\/quine-mccluskey-chart-800x447.jpeg\" alt=\"Prime implicant chart showing essential implicants for a Boolean function\" width=\"700\" height=\"394\" loading=\"lazy\" data-no-lazy=\"1\" class=\"pth-article-img\" style=\"width:100%;height:auto;display:block;border-radius:10px;border:1px solid #e2e8f0;\"><\/figure>\n\n\n\n<p class=\"wp-block-paragraph\">Take the expression A&#8217;C + A&#8217;B + AB&#8217;C + BC and press Simplify. Input: four product terms, three variables. Output: F = C + A&#8217;B. That is the minimal Sum-of-Products, and the Simplify tab lists the steps that produced it \u2014 the variables detected, the minterms where the function is true, the prime implicants found, how many were essential, and the final cover. Read those five lines and you can reproduce the derivation on paper.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">The Quine\u2013McCluskey tab is where the real working lives. It lists every prime implicant with the minterms it covers, then draws the prime implicant chart: implicants down the side, minterms across the top, an X where one covers the other. Rows marked with a star are essential, meaning they are the only implicant covering some minterm, so they must be in the answer. This is exactly the table an exam asks you to construct, and seeing it filled in correctly is the fastest way to learn the method.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">The SOP and POS tab shows the canonical form beside the minimal one, so you can see how much was thrown away. The Gate Realization tab then takes the result to hardware: the two-level AND\u2013OR circuit, the NAND-only and NOR-only equivalents, and a cost comparison. For our example the canonical form needs 15 literals; the minimal needs 3. That is the number a hardware engineer actually cares about, because fewer literals means fewer gate inputs, less silicon, and lower propagation delay.<\/p>\n\n\n\n<h2 id=\"\ud83d\udfe2-when-to-use-this-and-when-to-use-something-else\" class=\"wp-block-heading\">\ud83d\udfe2&nbsp;<strong>When to use this, and when to use something else<\/strong><\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">This tool is the algebraic specialist. It exists to minimize an expression correctly and show the tabular method behind it. That makes it the right choice when you need the minimal form, the prime implicant chart, or a gate-cost comparison \u2014 and especially when you have more than four variables, where a Karnaugh map becomes awkward and Quine\u2013McCluskey is the only sane approach.<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>\ud83d\udd35 <strong>Want the visual grid instead?<\/strong> A Karnaugh map is easier to eyeball for two to four variables. The <a href=\"https:\/\/schoolict.net\/tools\/advanced-k-map-solver\/\" target=\"_blank\" rel=\"noreferrer noopener\">K-Map Solver<\/a> does the grouping for you visually.<\/li>\n\n\n\n<li>\ud83d\udfe0 <strong>Need the full input\/output table?<\/strong> The <a href=\"https:\/\/schoolict.net\/tools\/truth-table-generator\/\" target=\"_blank\" rel=\"noreferrer noopener\">Truth Table Generator<\/a> prints every row for up to eight variables.<\/li>\n\n\n\n<li>\ud83d\udfe3 <strong>Building the circuit?<\/strong> The <a href=\"https:\/\/schoolict.net\/tools\/universal-logic-gate-converter-pro\/\" target=\"_blank\" rel=\"noreferrer noopener\">Digital Logic Studio<\/a> handles gate conversion, circuit diagrams, timing waveforms and Verilog output.<\/li>\n<\/ul>\n\n\n\n<p class=\"wp-block-paragraph\">Two honest limits worth stating. The tool minimizes to a two-level Sum-of-Products or Product-of-Sums, which is the standard textbook target \u2014 it does not perform multi-level factoring, so an expression that a human might factor cleverly into three levels will still be reported in two-level form. And it does not currently accept don&#8217;t-care conditions, so functions with unspecified outputs need to be handled by treating those rows as 0 or 1 before you enter them. If you want the theory behind the method itself, the companion guide on <a href=\"https:\/\/schoolict.net\/tools\/boolean-minimization-explained\/\" target=\"_blank\" rel=\"noreferrer noopener\">Boolean minimization and Quine\u2013McCluskey<\/a> explains why each step works.<\/p>\n\n\n\n<style>\n.pth-faq-section{margin:50px auto 40px;font-family:inherit;max-width:1480px;padding:0 20px;box-sizing:border-box}\n.pth-faq-header{font-size:1.8rem;font-weight:800;color:#0f172a;margin-bottom:25px;border-bottom:2px solid #e2e8f0;padding-bottom:10px;display:flex;align-items:center;gap:10px}\n.pth-faq-grid{display:grid;grid-template-columns:1fr;gap:20px}\n@media(min-width:768px){.pth-faq-grid{grid-template-columns:repeat(2,1fr)}}\n@media(min-width:1024px){.pth-faq-grid{grid-template-columns:repeat(3,1fr)}}\n.pth-faq-card{background:#f8fafc;padding:24px;border-radius:12px;border:1px solid #e2e8f0;transition:transform .2s ease;break-inside:avoid}\n.pth-faq-card:hover{transform:translateY(-3px);box-shadow:0 4px 12px rgba(0,0,0,.05)}\n.pth-faq-q{color:#0f172a;font-size:1rem;font-weight:700;margin:0 0 12px;line-height:1.4}\n.pth-faq-a{margin:0;font-size:.95rem;color:#1e293b;line-height:1.6;font-weight:500}\n<\/style>\n<div class=\"pth-faq-section\">\n  <div class=\"pth-faq-header\">\u2753 Frequently Asked Questions<\/div>\n  <div class=\"pth-faq-grid\">\n    <div class=\"pth-faq-card\"><p class=\"pth-faq-q\">How do I type NOT, AND and OR?<\/p><p class=\"pth-faq-a\">NOT is A&#8217; or !A. AND is AB, A.B or A*B. OR is A+B. XOR is A^B. Parentheses group as normal and constants 0 and 1 are allowed.<\/p><\/div>\n    <div class=\"pth-faq-card\"><p class=\"pth-faq-q\">Is the answer always the true minimum?<\/p><p class=\"pth-faq-a\">For two-level Sum-of-Products, yes. It builds the truth table and runs Quine\u2013McCluskey, which is exhaustive, so the result is the minimal SOP rather than a lucky guess.<\/p><\/div>\n    <div class=\"pth-faq-card\"><p class=\"pth-faq-q\">What is a prime implicant?<\/p><p class=\"pth-faq-a\">A product term that cannot be combined any further with a neighbouring term. Essential ones are the only implicant covering some minterm, so they must appear in the final answer.<\/p><\/div>\n    <div class=\"pth-faq-card\"><p class=\"pth-faq-q\">Why use Quine\u2013McCluskey instead of a K-map?<\/p><p class=\"pth-faq-a\">K-maps are quicker to eyeball up to four variables. Beyond that the grid gets unwieldy, while Quine\u2013McCluskey is a systematic algorithm that scales and can be checked step by step.<\/p><\/div>\n    <div class=\"pth-faq-card\"><p class=\"pth-faq-q\">How many variables can it handle?<\/p><p class=\"pth-faq-a\">Up to eight single-letter variables, which is 256 truth-table rows. That covers standard coursework and most practical combinational design.<\/p><\/div>\n    <div class=\"pth-faq-card\"><p class=\"pth-faq-q\">Does it support don&#8217;t-care conditions?<\/p><p class=\"pth-faq-a\">Not currently. Decide whether each unspecified row should be 0 or 1 and enter the expression accordingly. This is a known limit rather than a bug.<\/p><\/div>\n    <div class=\"pth-faq-card\"><p class=\"pth-faq-q\">What does the literal count tell me?<\/p><p class=\"pth-faq-a\">It is the total number of variable appearances in the expression, which maps roughly to gate inputs. Fewer literals means a smaller, cheaper, faster circuit.<\/p><\/div>\n    <div class=\"pth-faq-card\"><p class=\"pth-faq-q\">Does my expression get uploaded anywhere?<\/p><p class=\"pth-faq-a\">No. The parser, truth table and minimizer all run in your browser tab. Nothing is sent to a server, so it works offline once the page has loaded.<\/p><\/div>\n  <\/div>\n<\/div>\n\n\n\n<p class=\"wp-block-paragraph\"><\/p>\n","protected":false},"excerpt":{"rendered":"<p>Boolean Expression Simplifier &#038; Logic Gate Calculator Use our free, 100% offline Boolean Expression Simplifier to instantly solve complex logic equations with a step-by-step breakdown and Boolean laws reference. \ud83d\udfe2 Algorithmic Reduction This Boolean Expression Simplifier executes discrete mathematical theorems iteratively to minimize complex variable sets into their most highly optimized forms natively. \ud83d\udd35 Step-by-Step &#8230; <a title=\"Boolean Expression Simplifier &amp; Logic Gate Calculator\" class=\"read-more\" href=\"https:\/\/schoolict.net\/tools\/boolean-expression-simplifier\/\" aria-label=\"Read more about Boolean Expression Simplifier &amp; Logic Gate Calculator\">Read more<\/a><\/p>\n","protected":false},"author":1,"featured_media":3466,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-2133","page","type-page","status-publish","has-post-thumbnail"],"_links":{"self":[{"href":"https:\/\/schoolict.net\/tools\/wp-json\/wp\/v2\/pages\/2133","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/schoolict.net\/tools\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/schoolict.net\/tools\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/schoolict.net\/tools\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/schoolict.net\/tools\/wp-json\/wp\/v2\/comments?post=2133"}],"version-history":[{"count":1,"href":"https:\/\/schoolict.net\/tools\/wp-json\/wp\/v2\/pages\/2133\/revisions"}],"predecessor-version":[{"id":6839,"href":"https:\/\/schoolict.net\/tools\/wp-json\/wp\/v2\/pages\/2133\/revisions\/6839"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/schoolict.net\/tools\/wp-json\/wp\/v2\/media\/3466"}],"wp:attachment":[{"href":"https:\/\/schoolict.net\/tools\/wp-json\/wp\/v2\/media?parent=2133"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}