Bcnf Decomposition Calculator

BCNF Decomposition Calculator

An expert tool for database normalization and design.

Calculator

Relation Attributes

Enter all attributes of the relation, separated by commas.

Attributes cannot be empty.

Functional Dependencies (FDs)

Enter one functional dependency per line. Use “->” to show dependency.</div>
<div id="fds-error" class="error-message">Functional Dependencies cannot be empty.</div>
</p></div>
<div class="btn-container">
                    <button type="button" id="calculateBtn" class="btn btn-primary" onclick="runDecomposition()">Decompose to BCNF</button><br />
                    <button type="button" id="resetBtn" class="btn btn-secondary" onclick="resetCalculator()">Reset</button>
                </div>
</section>
<section id="results-section" style="display: none;">
<h2>Decomposition Results</h2>
<div id="primary-result-container">
<p><strong>Primary Result:</strong></p>
<div id="primary-result"></div>
</p></div>
<div class="intermediate-values">
<h3>Intermediate Steps</h3>
<div id="steps-output"></div>
</p></div>
<div class="btn-container">
                    <button type="button" id="copyBtn" class="btn btn-copy" onclick="copyResults()">Copy Results</button>
                </div>
<div class="table-wrapper">
<h3>Final Decomposed Relations</h3>
<table id="results-table">
<thead>
<tr>
<th>Relation Name</th>
<th>Attributes</th>
<th>Status</th>
</tr>
</thead>
<tbody id="results-table-body">
                        </tbody>
</table>
<p><small>This table summarizes the final set of relations after the BCNF decomposition is complete.</small></p>
</p></div>
<div class="chart-container">
<h3>Decomposition Visualization</h3>
<p>                    <svg id="decomposition-chart" width="800" height="400"></svg></p>
<p><small>This chart visually represents how the original relation was decomposed step-by-step.</small></p>
</p></div>
</section>
<article class="article-section">
<section id="what-is">
<h2>What is a BCNF Decomposition Calculator?</h2>
<p>A <strong>BCNF decomposition calculator</strong> is a specialized tool used in database design to break down a larger, single table (relation) into multiple smaller tables that are in Boyce-Codd Normal Form (BCNF). BCNF is a strict version of the Third Normal Form (3NF). The primary goal of using a <strong>BCNF decomposition calculator</strong> is to eliminate data redundancy and reduce the risk of data anomalies (insertion, update, and deletion anomalies) that can occur in poorly designed databases. For a table to be in BCNF, for every non-trivial functional dependency <code>X -> Y</code>, X must be a superkey of the table.</p>
<p>This calculator is essential for database administrators, students learning about database theory, and developers who want to ensure their database schema is highly normalized and efficient. By automating the complex process of checking functional dependencies and decomposing relations, it saves time and prevents errors. Using a <strong>BCNF decomposition calculator</strong> helps in achieving a logically sound and robust database structure.</p>
<h4>Common Misconceptions</h4>
<p>A common misconception is that all decompositions must be dependency-preserving. While the BCNF decomposition algorithm guarantees a lossless join (meaning you can reconstruct the original data without losing information), it does not always preserve all original functional dependencies. Sometimes, a dependency might only be enforceable by joining the decomposed tables, which can be a trade-off for achieving the stricter normalization of BCNF.</p>
</section>
<section id="formula">
<h2>BCNF Decomposition Formula and Mathematical Explanation</h2>
<p>The process of a <strong>BCNF decomposition calculator</strong> is based on a well-defined algorithm. It iteratively finds and resolves violations of BCNF rules. A relation R is in BCNF if, for every one of its non-trivial functional dependencies (FDs) <code>X → Y</code>, the determinant X is a superkey for R.</p>
<p>The decomposition algorithm is as follows:</p>
<ol>
<li>Start with a set of relations, initially containing only the original relation R.</li>
<li>Find all functional dependencies (FDs) that apply to the current relations.</li>
<li>Check each relation: for every FD <code>X → Y</code> in that relation, is <code>X</code> a superkey of that relation? A superkey is a set of attributes whose closure includes all attributes of the relation.</li>
<li>If a relation R’ is not in BCNF because of a violating FD <code>X → Y</code> (where X is not a superkey of R’), decompose it.</li>
<li>The decomposition creates two new relations: R1 containing attributes (X U Y) and R2 containing attributes (R’ – Y).</li>
<li>Replace the original relation R’ with the new R1 and R2.</li>
<li>Repeat the process for the new relations until all relations in the set are in BCNF.</li>
</ol>
<h4>Variables Table</h4>
<div class="table-wrapper">
<table>
<thead>
<tr>
<th>Variable</th>
<th>Meaning</th>
<th>Unit</th>
<th>Typical Range</th>
</tr>
</thead>
<tbody>
<tr>
<td>R</td>
<td>A relation (table) with a set of attributes.</td>
<td>Set of Attributes</td>
<td>e.g., {A, B, C, D}</td>
</tr>
<tr>
<td>F</td>
<td>A set of Functional Dependencies.</td>
<td>Set of FDs</td>
<td>e.g., {A->B, BC->D}</td>
</tr>
<tr>
<td>X → Y</td>
<td>A functional dependency, where X determines Y.</td>
<td>Statement</td>
<td>X and Y are sets of attributes.</td>
</tr>
<tr>
<td>X+</td>
<td>The closure of attribute set X, which is the set of all attributes functionally determined by X.</td>
<td>Set of Attributes</td>
<td>Subset of R’s attributes.</td>
</tr>
<tr>
<td>Superkey</td>
<td>An attribute set X is a superkey if its closure X+ contains all attributes of the relation.</td>
<td>Attribute Set</td>
<td>e.g., {A, C, E}</td>
</tr>
</tbody>
</table></div>
</section>
<section id="examples">
<h2>Practical Examples (Real-World Use Cases)</h2>
<p>Understanding how a <strong>BCNF decomposition calculator</strong> works is best done with practical examples.</p>
<h3>Example 1: Simple BCNF Violation</h3>
<p>Consider a relation <code>R(StudentID, Course, Instructor)</code> with the functional dependencies:</p>
<ul>
<li><code>{StudentID, Course} → Instructor</code> (A student in a course has one instructor)</li>
<li><code>Instructor → Course</code> (An instructor teaches only one course – a simplifying assumption for this example)</li>
</ul>
<p>The candidate key is <code>{StudentID, Instructor}</code>. The FD <code>Instructor → Course</code> violates BCNF because <code>Instructor</code> is not a superkey. Our <strong>BCNF decomposition calculator</strong> would perform the following steps:</p>
<ol>
<li><strong>Identify Violation:</strong> <code>Instructor → Course</code> violates BCNF.</li>
<li><strong>Decompose:</strong>
<ul>
<li>R1(<u>Instructor</u>, Course)</li>
<li>R2(<u>StudentID</u>, <u>Instructor</u>)</li>
</ul>
</li>
</ol>
<p>Both R1 and R2 are now in BCNF. This decomposition is lossless.</p>
<h3>Example 2: More Complex Decomposition</h3>
<p>Consider a relation <code>R(A, B, C, D, E)</code> with FDs:</p>
<ul>
<li><code>A → B</code></li>
<li><code>C → D</code></li>
</ul>
<p>The only candidate key for this relation is <code>{A, C, E}</code>. Both FDs violate BCNF because neither <code>A</code> nor <code>C</code> are superkeys. The <strong>BCNF decomposition calculator</strong> proceeds as follows:</p>
<ol>
<li><strong>Process <code>A → B</code>:</strong>
<ul>
<li>Decompose R into R1(<u>A</u>, B) and R2(A, C, D, E).</li>
</ul>
</li>
<li><strong>Process R2(A, C, D, E):</strong> The FD <code>C → D</code> is still a violation in R2.
<ul>
<li>Decompose R2 into R3(<u>C</u>, D) and R4(A, C, E).</li>
</ul>
</li>
</ol>
<p>The final set of BCNF relations is: <code>R1(<u>A</u>, B)</code>, <code>R3(<u>C</u>, D)</code>, and <code>R4(<u>A</u>, <u>C</u>, <u>E</u>)</code>.</p>
</section>
<section id="how-to-use">
<h2>How to Use This BCNF Decomposition Calculator</h2>
<p>This <strong>BCNF decomposition calculator</strong> is designed for ease of use. Follow these simple steps to normalize your relations.</p>
<ol>
<li><strong>Enter Attributes:</strong> In the “Relation Attributes” field, type all the attributes of your table, separated by commas. For example: <code>A,B,C,D</code>.</li>
<li><strong>Enter Functional Dependencies:</strong> In the “Functional Dependencies (FDs)” text area, list all FDs, with one FD per line. Use the format <code>LHS -> RHS</code>. For example, for <code>A and B determine C</code>, you would write <code>A,B -> C</code>.</li>
<li><strong>Calculate:</strong> Click the “Decompose to BCNF” button. The calculator will process the inputs and check for violations.</li>
<li><strong>Review Results:</strong> The tool will display the final decomposed relations in a table, showing which tables are now in BCNF. It will also provide a step-by-step log of how it performed the decomposition, including which violating FDs were found and how the relations were split. A visual chart will also show the decomposition tree.</li>
</ol>
<p>Reading the results involves checking the final table to see your new database schema. The intermediate steps help you understand the logic behind the decomposition, which is crucial for learning and verifying the process. For more information on database design, you might find our guide on <a href="/tools/candidate-key-calculator">candidate key calculation</a> useful.</p>
</section>
<section id="key-factors">
<h2>Key Factors That Affect BCNF Decomposition Results</h2>
<p>The final output of a <strong>BCNF decomposition calculator</strong> depends on several key factors related to the initial relation and its dependencies.</p>
<ul>
<li><strong>Initial Set of Attributes:</strong> The number and combination of attributes define the scope of the relation and potential keys.</li>
<li><strong>Functional Dependencies:</strong> This is the most critical factor. The complexity, quantity, and nature of FDs determine the candidate keys and BCNF violations. Exploring <a href="/guides/database-normalization">database normalization</a> in depth can provide more context.</li>
<li><strong>Candidate Keys:</strong> The structure of candidate keys is central to BCNF. Relations with multiple, overlapping candidate keys often lead to more complex decompositions and may present challenges in preserving dependencies.</li>
<li><strong>Order of Decomposition:</strong> For relations with multiple BCNF violations, the order in which violating FDs are processed can sometimes lead to different (but equally valid) final sets of decomposed relations.</li>
<li><strong>Lossless Join vs. Dependency Preservation:</strong> The algorithm prioritizes a lossless join. As a result, not all original FDs may be preserved within a single resulting table. Understanding the trade-offs between BCNF and 3NF is important, as 3NF always guarantees dependency preservation. You can learn more by comparing <a href="/guides/3nf-vs-bcnf">3NF vs BCNF</a>.</li>
<li><strong>Transitive Dependencies:</strong> The presence of transitive dependencies (where a non-prime attribute determines another non-prime attribute) is a direct cause of BCNF violations and a primary trigger for decomposition.</li>
</ul>
</section>
<section id="faq">
<h2>Frequently Asked Questions (FAQ)</h2>
<dl>
<dt>1. What is the main difference between 3NF and BCNF?</dt>
<dd>BCNF is stricter than 3NF. In 3NF, a functional dependency X -> Y is allowed if X is a superkey OR Y is a prime attribute (part of a candidate key). BCNF removes the second condition, requiring that for any non-trivial FD, the determinant X MUST be a superkey. This handles certain anomalies that 3NF does not.</dd>
<dt>2. Is the decomposition from this BCNF decomposition calculator always lossless?</dt>
<dd>Yes, the standard BCNF decomposition algorithm guarantees a lossless-join decomposition. This means that joining the resulting tables back together on their common attributes will recreate the original table without generating spurious tuples or losing data.</dd>
<dt>3. Is the decomposition always dependency-preserving?</dt>
<dd>No. Unlike the synthesis algorithm for 3NF, the BCNF decomposition algorithm does not guarantee dependency preservation. Some dependencies might be “lost,” meaning they can only be checked by performing a join across multiple tables, which adds overhead.</dd>
<dt>4. What is a “superkey”?</dt>
<dd>A superkey is a set of one or more attributes that can uniquely identify a row in a table. A candidate key is a minimal superkey (i.e., no attribute can be removed from the set without losing its unique identification property).</dd>
<dt>5. Why should I use a BCNF decomposition calculator?</dt>
<dd>Manually calculating BCNF decomposition is tedious and error-prone, especially for complex relations. A <strong>BCNF decomposition calculator</strong> automates the process of finding attribute closures, identifying superkeys, finding violations, and applying the decomposition algorithm correctly.</dd>
<dt>6. What happens if my relation is already in BCNF?</dt>
<dd>The calculator will check all functional dependencies and determine that no violations exist. It will report that the original relation is already in BCNF and no decomposition is needed.</dd>
<dt>7. Can the order of processing FDs change the result?</dt>
<dd>Yes, if there are multiple BCNF violations, the order in which you choose to decompose can lead to a different final set of relations. However, all valid final sets will be in BCNF and the decomposition will be lossless.</dd>
<dt>8. What is a “trivial” functional dependency?</dt>
<dd>A functional dependency X -> Y is trivial if Y is a subset of X. For example, <code>{A, B} -> A</code> is trivial. BCNF rules only apply to non-trivial dependencies.</dd>
</dl>
</section>
<section id="related-tools">
<h2>Related Tools and Internal Resources</h2>
<p>Enhance your understanding of database design with these related resources:</p>
<ul>
<li><a href="/tools/candidate-key-calculator">Candidate Key Calculator</a>: A tool to find all candidate keys for a given relation and set of functional dependencies.</li>
<li><a href="/tools/3nf-synthesis-calculator">3NF Synthesis Calculator</a>: Use this calculator to perform a dependency-preserving, lossless decomposition into Third Normal Form.</li>
<li><a href="/guides/database-normalization">Guide to Database Normalization</a>: A comprehensive article covering 1NF, 2NF, 3NF, BCNF, and more.</li>
<li><a href="/guides/lossless-decomposition">What is Lossless Decomposition?</a>: An explanation of what it means for a decomposition to be lossless and how to test for it.</li>
<li><a href="/guides/functional-dependency">Understanding Functional Dependencies</a>: A deep dive into the core concept of functional dependencies in databases.</li>
<li><a href="/guides/3nf-vs-bcnf">3NF vs BCNF: A Detailed Comparison</a>: An article that breaks down the key differences, pros, and cons of 3NF and BCNF.</li>
</ul>
</section>
</article>
<p>        </main></p>
<footer>
<p>© 2026 Date-Related Web Tools. All Rights Reserved.</p>
</footer></div>
<p>    <script>
    // --- UTILITY FUNCTIONS ---
    function isSubset(subset, superset) {
        for (var i = 0; i < subset.length; i++) {
            if (superset.indexOf(subset[i]) === -1) {
                return false;
            }
        }
        return true;
    }

function arraysEqual(a, b) {
        if (a === b) return true;
        if (a == null || b == null) return false;
        if (a.length !== b.length) return false;
        var sortedA = a.slice().sort();
        var sortedB = b.slice().sort();
        for (var i = 0; i < sortedA.length; ++i) {
            if (sortedA[i] !== sortedB[i]) return false;
        }
        return true;
    }

// --- PARSING FUNCTIONS ---
    function parseAttributes(input) {
        return input.replace(/\s/g, '').split(',').filter(function(attr) { return attr.length > 0; });
    }</p>
<p>    function parseFds(input) {
        var fds = [];
        var lines = input.split('\n');
        for (var i = 0; i < lines.length; i++) {
            var line = lines[i].trim();
            if (line.indexOf('->') === -1) continue;
            var parts = line.split('->');
            var lhs = parts.replace(/\s/g, '').split(',').filter(function(attr) { return attr.length > 0; });
            var rhs = parts.replace(/\s/g, '').split(',').filter(function(attr) { return attr.length > 0; });
            if (lhs.length > 0 && rhs.length > 0) {
                 // Decomposition: if X -> YZ, then X -> Y and X -> Z
                 for(var j=0; j<rhs.length; j++){
                    fds.push({ left: lhs, right: [rhs[j]] });
                 }
            }
        }
        return fds;
    }

// --- CORE BCNF LOGIC ---
    function getAttributeClosure(attributes, fds) {
        var closure = attributes.slice();
        var changed = true;
        while (changed) {
            changed = false;
            for (var i = 0; i < fds.length; i++) {
                var fd = fds[i];
                if (isSubset(fd.left, closure)) {
                    var beforeSize = closure.length;
                    closure = union(closure, fd.right);
                    if (closure.length > beforeSize) {
                        changed = true;
                    }
                }
            }
        }
        return closure.sort();
    }</p>
<p>    function isSuperkey(attributes, relationAttributes, fds) {
        var closure = getAttributeClosure(attributes, fds);
        return arraysEqual(closure, relationAttributes.slice().sort());
    }</p>
<p>    // --- MAIN DECOMPOSITION FUNCTION ---
    function runDecomposition() {
        // Clear previous results
        document.getElementById('steps-output').innerHTML = '';
        document.getElementById('results-table-body').innerHTML = '';
        var svg = document.getElementById('decomposition-chart');
        svg.innerHTML = '';</p>
<p>        // Input validation
        var attributesInput = document.getElementById('attributes').value.trim();
        var fdsInput = document.getElementById('fds').value.trim();
        var attrError = document.getElementById('attributes-error');
        var fdsError = document.getElementById('fds-error');
        var isValid = true;</p>
<p>        if (attributesInput === '') {
            attrError.style.display = 'block';
            isValid = false;
        } else {
            attrError.style.display = 'none';
        }</p>
<p>        if (fdsInput === '') {
            fdsError.style.display = 'block';
            isValid = false;
        } else {
            fdsError.style.display = 'none';
        }</p>
<p>        if (!isValid) {
            document.getElementById('results-section').style.display = 'none';
            return;
        }</p>
<p>        document.getElementById('results-section').style.display = 'block';</p>
<p>        var allAttributes = parseAttributes(attributesInput);
        var allFds = parseFds(fdsInput);</p>
<p>        var relationsToProcess = [{ attributes: allAttributes, name: 'R' }];
        var finalBcnfRelations = [];
        var stepLog = [];
        var processedRelations = []; // To avoid infinite loops
        var relationCounter = 1;
        var decompositionStepsForChart = [];</p>
<p>        var loopGuard = 0;
        while (relationsToProcess.length > 0 && loopGuard < 50) {
            loopGuard++;
            var currentRelation = relationsToProcess.shift();
            var relationName = currentRelation.name;
            var currentAttributes = currentRelation.attributes.slice().sort();

// Avoid reprocessing the same relation structure
            var processedSignature = currentAttributes.join(',');
            if (processedRelations.indexOf(processedSignature) !== -1) {
                continue;
            }
            processedRelations.push(processedSignature);

stepLog.push("<strong>Processing Relation " + relationName + "(" + currentAttributes.join(', ') + ")</strong>");</p>
<p>            var violatingFd = null;</p>
<p>            for (var i = 0; i < allFds.length; i++) {
                var fd = allFds[i];
                var fdAttributes = union(fd.left, fd.right);
    
                if (isSubset(fdAttributes, currentAttributes)) {
                    // Check for non-triviality
                    if (isSubset(fd.right, fd.left)) continue;
    
                    if (!isSuperkey(fd.left, currentAttributes, allFds)) {
                        violatingFd = fd;
                        break;
                    }
                }
            }
    
            if (violatingFd) {
                stepLog.push("Found BCNF violation in " + relationName + ": <code>" + violatingFd.left.join(', ') + " -> " + violatingFd.right.join(', ') + "</code>. The determinant is not a superkey.");</p>
<p>                var r1_attrs = union(violatingFd.left, violatingFd.right);
                // R2 = (R - (Y - X))
                var r2_attrs = union(difference(currentAttributes, violatingFd.right), violatingFd.left);</p>
<p>                var r1_name = "R" + (++relationCounter);
                var r2_name = "R" + (++relationCounter);</p>
<p>                relationsToProcess.push({ attributes: r1_attrs, name: r1_name });
                relationsToProcess.push({ attributes: r2_attrs, name: r2_name });</p>
<p>                stepLog.push("Decomposing " + relationName + " into:</p>
<ul>
<li>" + r1_name + "(" + r1_attrs.join(', ') + ")</li>
<li>" + r2_name + "(" + r2_attrs.join(', ') + ")</li>
</ul>
<p>");
                decompositionStepsForChart.push({ parent: relationName, children: [r1_name, r2_name] });</p>
<p>            } else {
                stepLog.push("Relation " + relationName + "(" + currentAttributes.join(', ') + ") is in BCNF. No violations found.");
                finalBcnfRelations.push(currentRelation);
            }
        }</p>
<p>        // Display final results
        var tableBody = document.getElementById('results-table-body');
        var primaryResult = [];
        finalBcnfRelations.forEach(function(rel) {
            var row = tableBody.insertRow();
            row.insertCell(0).textContent = rel.name;
            row.insertCell(1).textContent = rel.attributes.join(', ');
            row.insertCell(2).innerHTML = '<span style="color: #28a745;">In BCNF</span>';
            primaryResult.push(rel.name + "(" + rel.attributes.join(', ') + ")");
        });</p>
<p>        document.getElementById('primary-result').innerHTML = "Final Decomposition: " + primaryResult.join('; ');
        document.getElementById('steps-output').innerHTML = stepLog.join('');
        drawDecompositionChart(allAttributes, decompositionStepsForChart);
    }</p>
<p>    // --- UI FUNCTIONS ---
    function resetCalculator() {
        document.getElementById('attributes').value = 'A,B,C,D,E';
        document.getElementById('fds').value = 'A,B -> C\nC -> D,E';
        document.getElementById('results-section').style.display = 'none';
        document.getElementById('attributes-error').style.display = 'none';
        document.getElementById('fds-error').style.display = 'none';
        document.getElementById('steps-output').innerHTML = '';
        document.getElementById('results-table-body').innerHTML = '';
        var svg = document.getElementById('decomposition-chart');
        svg.innerHTML = '';
    }</p>
<p>    function copyResults() {
        var textToCopy = "BCNF Decomposition Results:\n\n";
        textToCopy += "Primary Result:\n" + document.getElementById('primary-result').textContent + "\n\n";</p>
<p>        textToCopy += "Final Decomposed Relations:\n";
        var table = document.getElementById('results-table');
        for (var i = 0; i < table.rows.length; i++) {
            var row = table.rows[i];
            for (var j = 0; j < row.cells.length; j++) {
                textToCopy += row.cells[j].textContent + (j === row.cells.length - 1 ? "" : "\t| ");
            }
            textToCopy += "\n";
        }
        
        textToCopy += "\nIntermediate Steps:\n";
        var steps = document.getElementById('steps-output').children;
         for(var k=0; k < steps.length; k++){
            textToCopy += steps[k].textContent + "\n";
         }
    
        navigator.clipboard.writeText(textToCopy).then(function() {
            alert('Results copied to clipboard!');
        }, function(err) {
            alert('Failed to copy results.');
        });
    }

function drawDecompositionChart(initialAttributes, steps) {
        var svg = document.getElementById('decomposition-chart');
        svg.innerHTML = ''; // Clear previous chart
        var width = svg.clientWidth;
        var height = 400;
        svg.setAttribute('viewBox', '0 0 ' + width + ' ' + height);

var nodes = {};
        var edges = [];

// Create nodes
        nodes['R'] = { x: width / 2, y: 50, name: 'R(' + initialAttributes.join(',') + ')'};
        
        var levelMap = {};
        levelMap['R'] = 0;

steps.forEach(function(step) {
            edges.push({ source: step.parent, target: step.children });
            edges.push({ source: step.parent, target: step.children });
            levelMap[step.children] = (levelMap[step.parent] || 0) + 1;
            levelMap[step.children] = (levelMap[step.parent] || 0) + 1;
        });

// Position nodes
        var levels = {};
        Object.keys(levelMap).forEach(function(nodeName) {
            var level = levelMap[nodeName];
            if (!levels[level]) levels[level] = [];
            levels[level].push(nodeName);
        });

var levelY = 50;
        Object.keys(levels).sort().forEach(function(level) {
            var nodesOnLevel = levels[level];
            var nodeXStep = width / (nodesOnLevel.length + 1);
            nodesOnLevel.forEach(function(nodeName, index) {
                 var nodeLabel = nodeName;
                 var table = document.getElementById('results-table-body');
                 for(var i=0; i<table.rows.length; i++){
                    if(table.rows[i].cells.textContent === nodeName){
                        nodeLabel = nodeName + '(' + table.rows[i].cells.textContent + ')';
                        break;
                    }
                 }
                 if(nodeName === 'R') nodeLabel = 'R(' + initialAttributes.join(',') + ')';

nodes[nodeName] = {
                    x: nodeXStep * (index + 1),
                    y: levelY,
                    name: nodeLabel
                };
            });
            levelY += 100;
        });
        
        svg.style.height = levelY + 'px';

// Draw edges
        edges.forEach(function(edge) {
            var sourceNode = nodes[edge.source];
            var targetNode = nodes[edge.target];
            if (sourceNode && targetNode) {
                var line = document.createElementNS('http://www.w3.org/2000/svg', 'line');
                line.setAttribute('x1', sourceNode.x);
                line.setAttribute('y1', sourceNode.y);
                line.setAttribute('x2', targetNode.x);
                line.setAttribute('y2', targetNode.y);
                line.setAttribute('stroke', '#6c757d');
                line.setAttribute('stroke-width', 2);
                svg.appendChild(line);
            }
        });

// Draw nodes
        Object.keys(nodes).forEach(function(nodeName) {
            var node = nodes[nodeName];
            var g = document.createElementNS('http://www.w3.org/2000/svg', 'g');
            
            var rect = document.createElementNS('http://www.w3.org/2000/svg', 'rect');
             var text = document.createElementNS('http://www.w3.org/2000/svg', 'text');
            text.setAttribute('x', node.x);
            text.setAttribute('y', node.y);
            text.setAttribute('text-anchor', 'middle');
            text.setAttribute('dominant-baseline', 'middle');
            text.setAttribute('fill', '#fff');
            text.setAttribute('font-size', '14');
            text.textContent = node.name;
            
            // dynamically size rect
            var textWidth = node.name.length * 8; 
            rect.setAttribute('x', node.x - textWidth / 2 - 10);
            rect.setAttribute('y', node.y - 20);
            rect.setAttribute('width', textWidth + 20);
            rect.setAttribute('height', 40);
            rect.setAttribute('rx', 5);
            rect.setAttribute('ry', 5);
            rect.setAttribute('fill', '#004a99');
            
            g.appendChild(rect);
            g.appendChild(text);
            svg.appendChild(g);
        });
    }

// Initialize with default values
    window.onload = function() {
        resetCalculator();
    };

</script><br />
</body><br />
</html></p>
		</div>

</article>

</div>

<div class="ct-comments" id="comments">
	
	
	
	
		<div id="respond" class="comment-respond">
		<h2 id="reply-title" class="comment-reply-title">Leave a Reply<span class="ct-cancel-reply"><a rel="nofollow" id="cancel-comment-reply-link" href="/bcnf-decomposition-calculator/#respond" style="display:none;">Cancel Reply</a></span></h2><form action="https://cal7.calculator.city/wp-comments-post.php" method="post" id="commentform" class="comment-form has-website-field has-labels-inside"><p class="comment-notes"><span id="email-notes">Your email address will not be published.</span> <span class="required-field-message">Required fields are marked <span class="required">*</span></span></p><p class="comment-form-field-input-author">
			<label for="author">Name <b class="required"> *</b></label>
			<input id="author" name="author" type="text" value="" size="30" required='required'>
			</p>
<p class="comment-form-field-input-email">
				<label for="email">Email <b class="required"> *</b></label>
				<input id="email" name="email" type="text" value="" size="30" required='required'>
			</p>
<p class="comment-form-field-input-url">
				<label for="url">Website</label>
				<input id="url" name="url" type="text" value="" size="30">
				</p>

<p class="comment-form-field-textarea">
			<label for="comment">Add Comment<b class="required"> *</b></label>
			<textarea id="comment" name="comment" cols="45" rows="8" required="required">