Lossless vs Lossy Decomposition for Given Functional Dependencies (D1 and D2)
We are given a relation schema
with functional dependencies :
Two decomposition schemes are proposed:
- D1:
- D2:
To decide whether each decomposition is lossless, we use the chase / tableau criterion for lossless join decompositions under functional dependencies 2. The decomposition is lossless iff the chase table forces a row to become “consistent with the original tuple symbols” (equivalently, no spurious tuples are created); otherwise it is lossy.
Key terms:
- lossless join
- lossy decomposition
- chase test
- attribute closure
Footnotes
-
Knowledge Gate AI, "Lossless Join and Dependency Preservation, Step by Step - Knowledge Gate AI" https://www.knowledgegate.ai/blog/lossless-join-dependency-preservation-gate - Background on lossless/dependency preservation and FD reasoning context (includes common FD propagation discussion). ↩
-
GeeksforGeeks, "Lossless Join and Dependency Preserving Decomposition - GeeksforGeeks" https://www.geeksforgeeks.org/dbms/lossless-join-and-dependency-preserving-decomposition - Definitions and conditions for lossless join decomposition (with FD-based reasoning). ↩
-
UMBC/CMSC661, "Lossless Join Example discussed in class" https://www.csee.umbc.edu/~pmundur/courses/CMSC661-05/LosslessJoinExample.pdf - Provides a tableau/chase-style lossless join test worked example. ↩
DBMS - Algorithm To check Whether a Decomposition is Lossless
1) Compute closure facts from the given FDs
Let .
From we immediately get:
From and we get:
- (via transitivity)
Also, from and :
Finally, since is already given, and follows from :
- then (because and )
These closure properties will drive the lossless-join reasoning because common attributes between fragments must “act like” a key/superkey for some fragment under the chase criterion 2.
Footnotes
-
GeeksforGeeks, "Lossless Join and Dependency Preserving Decomposition - GeeksforGeeks" https://www.geeksforgeeks.org/dbms/lossless-join-and-dependency-preserving-decomposition - Definitions and conditions for lossless join decomposition (with FD-based reasoning). ↩
-
UMBC/CMSC661, "Lossless Join Example discussed in class" https://www.csee.umbc.edu/~pmundur/courses/CMSC661-05/LosslessJoinExample.pdf - Provides a tableau/chase-style lossless join test worked example. ↩
Lossless Join Test for D1 using the Chase Tableau (with functional dependencies)
- 1Step 1
D1 fragments: , , , . Common attributes among them are: , , , and .
- 2Step 2
Create one row per fragment. Use a distinguished symbol wherever an attribute appears in the first row fragment (the “seed”), otherwise use unique -symbols for each attribute occurrence not in the seed row. (This is the standard chase-tableau construction for lossless join tests 2.)
Footnotes
-
GeeksforGeeks, "Lossless Join and Dependency Preserving Decomposition - GeeksforGeeks" https://www.geeksforgeeks.org/dbms/lossless-join-and-dependency-preserving-decomposition - Definitions and conditions for lossless join decomposition (with FD-based reasoning). ↩
-
UMBC/CMSC661, "Lossless Join Example discussed in class" https://www.csee.umbc.edu/~pmundur/courses/CMSC661-05/LosslessJoinExample.pdf - Provides a tableau/chase-style lossless join test worked example. ↩
-
- 3Step 3
Take the seed row as (so are marked with -symbols in that row; use fresh -symbols in that row).
- 4Step 4
Use the chase rule: for each FD , if in some column(s) of two rows have the same “kind” of symbol (an matching an , or a forced equality already established), then the corresponding -columns must be equated as well.
- 5Step 5
Since is present in and , the -columns in the seed row and the row share the same determinant (seed has , and has for ). Applying forces equality of the -columns between the seed row and the row (so the symbols align).
- 6Step 6
Once is aligned between the seed and the row, FD forces the and columns to align in the row with the same symbol types as required by the tableau.
- 7Step 7
Because is in both and , the tableau has aligned columns between the seed and . Applying forces both and columns in to align with the already-consistent (from the chain) and to produce consistent .
- 8Step 8
After these propagation steps, the chase tableau yields at least one row where all attributes of the seed component match consistently (no contradictions/spurious symbol merging). Therefore the join of the fragments reproduces exactly, so D1 is lossless.
How to sanity-check losslessness intuition
In a lossless decomposition, the overlap structure must allow the chase to propagate determinant information across fragments. In D1, connects to , and connects to ; simultaneously, connects to via . That gives multiple propagation paths that prevent spurious tuples.
2) Lossless Join Test for D2
D2 fragments:
Notice the crucial structural change from D1: in D2, the fragment is split into separate fragments and , so attributes and are no longer together. This breaks the immediate chase propagation that existed in D1 (through ).
Lossless Join Test for D2 using the Chase Tableau logic
- 1Step 1
Overlaps: , , and there is no overlap between and (they share none).
- 2Step 2
Use a standard chase tableau with one row per fragment per the lossless join test method 2. Choose seed row as .
Footnotes
-
GeeksforGeeks, "Lossless Join and Dependency Preserving Decomposition - GeeksforGeeks" https://www.geeksforgeeks.org/dbms/lossless-join-and-dependency-preserving-decomposition - Definitions and conditions for lossless join decomposition (with FD-based reasoning). ↩
-
UMBC/CMSC661, "Lossless Join Example discussed in class" https://www.csee.umbc.edu/~pmundur/courses/CMSC661-05/LosslessJoinExample.pdf - Provides a tableau/chase-style lossless join test worked example. ↩
-
- 3Step 3
Because appears in both and , chase applies so becomes consistent across those rows; then propagates consistency into .
- 4Step 4
To constrain in , the tableau would need some FD whose LHS is present in the already-consistent components and whose RHS includes . Candidate FDs with on RHS are: and .
- 5Step 5
In D2, shares no attributes with the seed component or with / . Therefore in the chase tableau, there is no way to align the determinant of (requires both and in the same intersecting structure) with rows that also contain . Similarly, requires alignment of , but never appears in the row, so the RHS symbol in that row never gets forced to match the symbols derived elsewhere.
- 6Step 6
Because the determinant information cannot reach the -containing fragment through overlaps, the chase tableau does not collapse to a fully consistent consistent row. Hence the decomposition introduces spurious combinations upon joining, so D2 is lossy.
Common overlap is essential for chase propagation
Losslessness is not just about having the same overall attributes. It is about whether determinants can propagate through the join graph. In D2, fragment has zero overlap with the rest, so the FD-driven chase cannot force consistently, leading to a lossy join.
Lossless vs Lossy under the given FD set
Qualitative outcome using chase/propagation logic
FAQ / Quick Justifications
Key Concepts Check
Knowledge Check
Which property is tested by the chase/tableau method in this problem?
Explore Related Topics
Existential Query Answering in the Blocks World
Hierarchy and Power of Bottom-Up Parsers: SLR, LALR, and CLR
Bottom‑up LR parsers form a strict hierarchy of power: LR(0) < SLR < LALR < CLR, with each level able to handle all grammars of the lower levels.
- SLR uses LR(0) items and resolves conflicts with FOLLOW sets; it is the weakest but simplest LR parser.
- LALR builds full LR(1) items then merges states that share the same core, keeping the same number of states as SLR while adding look‑ahead precision.
- CLR (canonical LR) retains all LR(1) states and look‑aheads, giving it the highest grammar coverage at the cost of many more states.
- Merging CLR states to form LALR can introduce reduce‑reduce conflicts (never shift‑reduce), making LALR strictly less powerful than CLR.
- In practice, tools like Yacc/Bison prefer LALR because it balances power with manageable memory usage.
Explain Fault vs Failure in Dependable Systems
In dependable systems a fault is the hidden cause, an error is the incorrect internal state it may create, and a failure is the externally visible deviation from required service.
- Faults are hidden causes (design, hardware, configuration, environment) that may remain dormant.
- An error is the internal incorrect state produced when a fault activates; it can be detected or masked.
- Failure is the observable service deviation; the chain guides prevention, detection, and reliability, and fault‑tolerance blocks errors from causing failures.