Lossless vs Lossy Decomposition for Given Functional Dependencies (D1 and D2)

Lossless vs Lossy Decomposition for Given Functional Dependencies (D1 and D2)

Verified Sources
Sep 11, 2026

We are given a relation schema
R(P,Q,S,T,X,Y,Z,W)R(P,Q,S,T,X,Y,Z,W) with functional dependencies :

  • PQXPQ \to X
  • PYXP \to YX
  • QYQ \to Y
  • YZWY \to ZW

Two decomposition schemes are proposed:

  • D1: R=[(P,Q,S,T); (P,T,X); (Q,Y); (Y,Z,W)]R = [(P,Q,S,T);\ (P,T,X);\ (Q,Y);\ (Y,Z,W)]
  • D2: R=[(P,Q,S); (T,X); (Q,Y); (Y,Z,W)]R = [(P,Q,S);\ (T,X);\ (Q,Y);\ (Y,Z,W)]

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

  1. 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).

  2. 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).

  3. 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 F={PQX, PYX, QY, YZW}F=\{PQ\to X,\ P\to YX,\ Q\to Y,\ Y\to ZW\}.

From PYXP \to YX we immediately get:

  • PYP \to Y
  • PXP \to X

From QYQ \to Y and YZWY \to ZW we get:

  • QZWQ \to ZW (via transitivity)

Also, from PYP \to Y and YZWY \to ZW:

  • PZWP \to ZW

Finally, since PQXPQ \to X is already given, and PQYPQ \to Y follows from PYP \to Y:

  • PQYPQ \to Y
  • then PQZWPQ \to ZW (because PQYPQ \to Y and YZWY \to ZW)

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

  1. 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).

  2. 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)

  1. 1
    Step 1

    D1 fragments: R1(P,Q,S,T)R_1(P,Q,S,T), R2(P,T,X)R_2(P,T,X), R3(Q,Y)R_3(Q,Y), R4(Y,Z,W)R_4(Y,Z,W). Common attributes among them are: R1R2={P,T}R_1\cap R_2=\{P,T\}, R1R3={Q}R_1\cap R_3=\{Q\}, R3R4={Y}R_3\cap R_4=\{Y\}, and R2R4=R_2\cap R_4=\emptyset.

  2. 2
    Step 2

    Create one row per fragment. Use a distinguished symbol aPa_P wherever an attribute appears in the first row fragment (the “seed”), otherwise use unique bb-symbols for each attribute occurrence not in the seed row. (This is the standard chase-tableau construction for lossless join tests 2.)

    Footnotes

    1. 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).

    2. 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.

  3. 3
    Step 3

    Take the seed row as R1(P,Q,S,T)R_1(P,Q,S,T) (so P,Q,S,TP,Q,S,T are marked with aa-symbols in that row; X,Y,Z,WX,Y,Z,W use fresh bb-symbols in that row).

  4. 4
    Step 4

    Use the chase rule: for each FD UVU\to V, if in some column(s) of UU two rows have the same “kind” of symbol (an aa matching an aa, or a forced equality already established), then the corresponding VV-columns must be equated as well.

  5. 5
    Step 5

    Since QQ is present in R1R_1 and R3R_3, the QQ-columns in the seed row and the R3R_3 row share the same determinant (seed has aQa_Q, and R3R_3 has aQa_Q for QQ). Applying QYQ\to Y forces equality of the YY-columns between the seed row and the R3R_3 row (so the YY symbols align).

  6. 6
    Step 6

    Once YY is aligned between the seed and the R3R_3 row, FD YZWY\to ZW forces the ZZ and WW columns to align in the R4R_4 row with the same symbol types as required by the tableau.

  7. 7
    Step 7

    Because PP is in both R1R_1 and R2R_2, the tableau has aligned PP columns between the seed and R2R_2. Applying PYXP\to YX forces both YY and XX columns in R2R_2 to align with the already-consistent YY (from the QYQ\to Y chain) and to produce consistent XX.

  8. 8
    Step 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 RR 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, QQ connects (P,Q,S,T)(P,Q,S,T) to (Q,Y)(Q,Y), and YY connects to (Y,Z,W)(Y,Z,W); simultaneously, PP connects (P,Q,S,T)(P,Q,S,T) to (P,T,X)(P,T,X) via PYXP\to YX. That gives multiple propagation paths that prevent spurious tuples.

2) Lossless Join Test for D2

D2 fragments:

  • R1(P,Q,S)R_1'(P,Q,S)
  • R2(T,X)R_2'(T,X)
  • R3(Q,Y)R_3'(Q,Y)
  • R4(Y,Z,W)R_4'(Y,Z,W)

Notice the crucial structural change from D1: in D2, the fragment (P,T,X)(P,T,X) is split into separate fragments (P,Q,S)(P,Q,S) and (T,X)(T,X), so attributes PP and XX are no longer together. This breaks the immediate chase propagation that existed in D1 (through PtoYXP\\to YX).

Lossless Join Test for D2 using the Chase Tableau logic

  1. 1
    Step 1

    Overlaps: R1R3={Q}R_1'\cap R_3' = \{Q\}, R3R4={Y}R_3'\cap R_4' = \{Y\}, and there is no overlap between R2(T,X)R_2'(T,X) and R1(P,Q,S)R_1'(P,Q,S) (they share none).

  2. 2
    Step 2

    Use a standard chase tableau with one row per fragment per the lossless join test method 2. Choose seed row as R1(P,Q,S)R_1'(P,Q,S).

    Footnotes

    1. 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).

    2. 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.

  3. 3
    Step 3

    Because QQ appears in both R1R_1' and R3R_3', chase applies QYQ\to Y so YY becomes consistent across those rows; then YZWY\to ZW propagates consistency into R4R_4'.

  4. 4
    Step 4

    To constrain XX in R2(T,X)R_2'(T,X), the tableau would need some FD whose LHS is present in the already-consistent components and whose RHS includes XX. Candidate FDs with XX on RHS are: PQXPQ\to X and PYXP\to YX.

  5. 5
    Step 5

    In D2, (T,X)(T,X) shares no attributes with the seed component (P,Q,S)(P,Q,S) or with (Q,Y)(Q,Y) / (Y,Z,W)(Y,Z,W). Therefore in the chase tableau, there is no way to align the determinant of PQXPQ\to X (requires both PP and QQ in the same intersecting structure) with rows that also contain XX. Similarly, PYXP\to YX requires alignment of PP, but PP never appears in the R2(T,X)R_2'(T,X) row, so the RHS symbol XX in that row never gets forced to match the XX symbols derived elsewhere.

  6. 6
    Step 6

    Because the determinant information cannot reach the XX-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 (T,X)(T,X) has zero overlap with the rest, so the FD-driven chase cannot force XX 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

1 / 4
Question · Term

Lossless join (definition)

Click to reveal
Answer · Definition

A decomposition is lossless iff the natural join of the component relations equals the original relation (no spurious tuples).

Knowledge Check

Question 1 of 4
Q1Single choice

Which property is tested by the chase/tableau method in this problem?

Explore Related Topics

1

Existential Query Answering in the Blocks World

2

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.
3

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 FaultErrorFailure\text{Fault} \rightarrow \text{Error} \rightarrow \text{Failure} guides prevention, detection, and reliability, and fault‑tolerance blocks errors from causing failures.