Normal Form Practice Questions

To find the canonical cover F_c, we follow these steps:

1. Split right-hand sides (RHS):
   All FDs in F already have a single attribute on their RHS. So, F' = F.

2. Remove extraneous attributes from left-hand sides (LHS):
   Only FD 'ABC -> D' has multiple attributes on its LHS.

   • Check for A in ABC -> D: Is D derivable from (BC)+ using F'?
     (BC)+ from F' = {B, C}. Applying B -> C, we get {B, C}. Applying C -> D, we get {B, C, D}. Since D is in (BC)+, A is extraneous. Replace ABC -> D with BC -> D.
     Current set: F'' = {BC -> D, A -> B, B -> C, C -> D}.
   • Check for B in BC -> D: Is D derivable from (C)+ using F''?
     (C)+ from F'' = {C}. Applying C -> D, we get {C, D}. Since D is in (C)+, B is extraneous. Replace BC -> D with C -> D.
     Current set: F''' = {C -> D, A -> B, B -> C, C -> D}. We remove the duplicate C -> D.
     So, F''' = {A -> B, B -> C, C -> D}.
     All other FDs have single attribute LHS, so no more extraneous attributes.

3. Remove redundant functional dependencies:
   We check each FD in F''' for redundancy:

   • A -> B: (A)+ from F''' - {A -> B} = {A}. 'B' is not in (A)+. Not redundant.
   • B -> C: (B)+ from F''' - {B -> C} = {B}. 'C' is not in (B)+. Not redundant.
   • C -> D: (C)+ from F''' - {C -> D} = {C}. 'D' is not in (C)+. Not redundant.

   The canonical cover is F_c = {A -> B, B -> C, C -> D}.

To find the canonical cover, we follow these steps:

Step 1: Split FDs with multiple attributes on the RHS.

• A -> BCD splits into { A -> B, A -> C, A -> D }.
• F_c becomes { A -> B, A -> C, A -> D, B -> A, C -> D, D -> B }.

Step 2: Remove extraneous attributes from the LHS of each FD.
All FDs in F_c have a single attribute on the LHS, which are inherently minimal. No changes in this step.
F_c = { A -> B, A -> C, A -> D, B -> A, C -> D, D -> B }.

Step 3: Remove redundant FDs.
Initial F_c for redundancy check: { A -> B, A -> C, A -> D, B -> A, C -> D, D -> B }

Pass 1:

• Consider A -> B: Can B be derived from A using {A -> C, A -> D, B -> A, C -> D, D -> B}? (A)+ = {A, C, D} (from A->C, A->D). Then {A, C, D, B} (from D->B). Yes, B is in (A)+. So A -> B IS redundant. Remove it.
  • F_c now becomes { A -> C, A -> D, B -> A, C -> D, D -> B }.
  • Since an FD was removed, restart redundancy check.

Pass 2:

• Current F_c: { A -> C, A -> D, B -> A, C -> D, D -> B }
• Consider A -> C: Can C be derived from A using {A -> D, B -> A, C -> D, D -> B}? (A)+ = {A, D} (from A->D). Then {A, D, B} (from D->B). Then {A, D, B, A} (from B->A). C is not in (A)+. So A -> C is NOT redundant.
• Consider A -> D: Can D be derived from A using {A -> C, B -> A, C -> D, D -> B}? (A)+ = {A, C} (from A->C). Then {A, C, D} (from C->D). Yes, D is in (A)+. So A -> D IS redundant. Remove it.
  • F_c now becomes { A -> C, B -> A, C -> D, D -> B }.
  • Since an FD was removed, restart redundancy check.

Pass 3:

• Current F_c: { A -> C, B -> A, C -> D, D -> B }
• Consider A -> C: Can C be derived from A using {B -> A, C -> D, D -> B}? (A)+ = {A}. C is not in (A)+. So A -> C is NOT redundant.
• Consider B -> A: Can A be derived from B using {A -> C, C -> D, D -> B}? (B)+ = {B, D} (from D->B, no B->D directly). D->B means (D)+ contains B. (B)+ closure with {A->C, C->D, D->B} = {B, D} (from D->B). A is not in (B)+. So B -> A is NOT redundant.
• Consider C -> D: Can D be derived from C using {A -> C, B -> A, D -> B}? (C)+ = {C, A} (from A->C). D is not in (C)+. So C -> D is NOT redundant.
• Consider D -> B: Can B be derived from D using {A -> C, B -> A, C -> D}? (D)+ = {D}. B is not in (D)+. So D -> B is NOT redundant.

No FDs were removed in Pass 3. The process terminates.

The canonical cover F_c is { A -> C, B -> A, C -> D, D -> B }.

Let F1 and F2 be the FDs in R1 and R2 respectively. We need to check if F+ is equivalent to (F1 ∪ F2)+.

1. Original FDs F = { K → L, LM → N, N → O, K → M }
2. FDs in R1 = (K, L, M):
   • K → L and K → M are fully contained.
   • F1 = { K → L, K → M } (can be written as K → LM).
3. FDs in R2 = (L, N, O):
   • N → O is fully contained.
   • LM → N (M is not in R2) is not fully contained.
   • F2 = { N → O }.
4. Combined FDs F' = F1 ∪ F2 = { K → L, K → M, N → O }
5. Check if F' preserves F:
   • K → L: K+ (using F') = KL. Preserved (direct in F1).
   • K → M: K+ (using F') = KM. Preserved (direct in F1).
   • N → O: N+ (using F') = NO. Preserved (direct in F2).
   • LM → N: Let's find (LM)+ using F'.
     (LM)+ = L (given) M (given)
     From F', we cannot derive N from LM. For instance, L and M alone do not trigger any FDs in F' that would yield N.
     Therefore, the functional dependency LM → N is NOT preserved by the decomposition.

Thus, the decomposition is not dependency preserving. Option B correctly identifies the non-preserved FD. Option A is incorrect because K → N is derivable (K → M, LM → N implies K → N), but this doesn't guarantee overall dependency preservation if other FDs are not preserved. Option D is incorrect as both K → L and N → O are preserved.

To find the canonical cover, we follow these steps:

Step 1: Split FDs with multiple attributes on the RHS.

• A -> BC splits into { A -> B, A -> C }.
• F_c becomes { A -> B, A -> C, C -> E, E -> F, F -> B, A -> F }.

Step 2: Remove extraneous attributes from the LHS of each FD.
All FDs in F_c have a single attribute on the LHS, which are inherently minimal. No changes in this step.
F_c = { A -> B, A -> C, C -> E, E -> F, F -> B, A -> F }.

Step 3: Remove redundant FDs.
Initial F_c for redundancy check: { A -> B, A -> C, C -> E, E -> F, F -> B, A -> F }

Pass 1:

• Consider A -> B: Can B be derived from A using {A -> C, C -> E, E -> F, F -> B, A -> F}? (A)+ = {A, C} (from A->C). Then {A, C, E} (from C->E). Then {A, C, E, F} (from E->F). Then {A, C, E, F, B} (from F->B). Yes, B is in (A)+. So A -> B IS redundant. Remove it.
  • F_c now becomes { A -> C, C -> E, E -> F, F -> B, A -> F }.
  • Since an FD was removed, restart redundancy check.

Pass 2:

• Current F_c: { A -> C, C -> E, E -> F, F -> B, A -> F }
• Consider A -> C: Can C be derived from A using {C -> E, E -> F, F -> B, A -> F}? (A)+ = {A, F} (from A->F). Then {A, F, B} (from F->B). C is not in (A)+. So A -> C is NOT redundant.
• Consider C -> E: Can E be derived from C using {A -> C, E -> F, F -> B, A -> F}? (C)+ = {C, A} (from A->C). E is not in (C)+. So C -> E is NOT redundant.
• Consider E -> F: Can F be derived from E using {A -> C, C -> E, F -> B, A -> F}? (E)+ = {E}. F is not in (E)+. So E -> F is NOT redundant.
• Consider F -> B: Can B be derived from F using {A -> C, C -> E, E -> F, A -> F}? (F)+ = {F, E} (from E->F, as E is in {F, E}). B is not in (F)+. So F -> B is NOT redundant.
• Consider A -> F: Can F be derived from A using {A -> C, C -> E, E -> F, F -> B}? (A)+ = {A, C} (from A->C). Then {A, C, E} (from C->E). Then {A, C, E, F} (from E->F). Yes, F is in (A)+. So A -> F IS redundant. Remove it.
  • F_c now becomes { A -> C, C -> E, E -> F, F -> B }.
  • Since an FD was removed, restart redundancy check.

Pass 3:

• Current F_c: { A -> C, C -> E, E -> F, F -> B }
• Consider A -> C: Can C be derived from A using {C -> E, E -> F, F -> B}? (A)+ = {A}. C is not in (A)+. So A -> C is NOT redundant.
• Consider C -> E: Can E be derived from C using {A -> C, E -> F, F -> B}? (C)+ = {C, A} (from A->C). E is not in (C)+. So C -> E is NOT redundant.
• Consider E -> F: Can F be derived from E using {A -> C, C -> E, F -> B}? (E)+ = {E}. F is not in (E)+. So E -> F is NOT redundant.
• Consider F -> B: Can B be derived from F using {A -> C, C -> E, E -> F}? (F)+ = {F, E} (from E->F). B is not in (F)+. So F -> B is NOT redundant.

No FDs were removed in Pass 3. The process terminates.

The canonical cover F_c is { A -> C, C -> E, E -> F, F -> B }.

To find the canonical cover, we follow these steps:

Step 1: Split FDs with multiple attributes on the RHS.
All FDs in F already have a single attribute on the RHS. So, F_c = { A -> C, BC -> A, AB -> D, B -> C, C -> D }.

Step 2: Remove extraneous attributes from the LHS of each FD.

• A -> C: LHS is minimal.
• BC -> A:
  • Is C extraneous? Check if A is in (B)+ using F_c. (B)+ = {B, C, D} (from B->C, C->D). A is not in (B)+. So C is not extraneous.
  • Is B extraneous? Check if A is in (C)+ using F_c. (C)+ = {C, D} (from C->D). A is not in (C)+. So B is not extraneous.
  • BC -> A remains.
• AB -> D:
  • Is B extraneous? Check if D is in (A)+ using F_c. (A)+ = {A, C, D} (from A->C, C->D). Yes, D is in (A)+. So B is extraneous.
  • Replace AB -> D with A -> D.
  • F_c now becomes { A -> C, BC -> A, A -> D, B -> C, C -> D }.
• B -> C: LHS is minimal.
• C -> D: LHS is minimal.

After removing extraneous attributes, F_c = { A -> C, BC -> A, A -> D, B -> C, C -> D }.

Step 3: Remove redundant FDs.
We iterate through the FDs and remove any that can be derived from the remaining FDs. If an FD is removed, we restart the process for redundancy checking.

Initial F_c for redundancy check: { A -> C, BC -> A, A -> D, B -> C, C -> D }

Pass 1:

• Consider A -> C: Can C be derived from A using {BC -> A, A -> D, B -> C, C -> D}? (A)+ = {A, D} (from A->D). C is not in (A)+. So A -> C is NOT redundant.
• Consider BC -> A: Can A be derived from BC using {A -> C, A -> D, B -> C, C -> D}? (BC)+ = {B, C, D} (from B->C, C->D). A is not in (BC)+. So BC -> A is NOT redundant.
• Consider A -> D: Can D be derived from A using {A -> C, BC -> A, B -> C, C -> D}? (A)+ = {A, C, D} (from A->C, C->D). Yes, D is in (A)+. So A -> D IS redundant. Remove it.
  • F_c now becomes { A -> C, BC -> A, B -> C, C -> D }.
  • Since an FD was removed, restart redundancy check.

Pass 2:

• Current F_c: { A -> C, BC -> A, B -> C, C -> D }
• Consider A -> C: Can C be derived from A using {BC -> A, B -> C, C -> D}? (A)+ = {A}. C is not in (A)+. So A -> C is NOT redundant.
• Consider BC -> A: Can A be derived from BC using {A -> C, B -> C, C -> D}? (BC)+ = {B, C, D} (from B->C, C->D). A is not in (BC)+. So BC -> A is NOT redundant.
• Consider B -> C: Can C be derived from B using {A -> C, BC -> A, C -> D}? (B)+ = {B}. C is not in (B)+. So B -> C is NOT redundant.
• Consider C -> D: Can D be derived from C using {A -> C, BC -> A, B -> C}? (C)+ = {C}. D is not in (C)+. So C -> D is NOT redundant.

No FDs were removed in Pass 2. The process terminates.

The canonical cover F_c is { A -> C, BC -> A, B -> C, C -> D }.

We need to check for both dependency preservation and lossless join property.

1. Dependency Preservation Check:

• Original FDs F = { A → B, BC → D }
• FDs in R1 = (A, B): The FD A → B is fully contained in R1. So, F1 = { A → B }.
• FDs in R2 = (B, C, D): The FD BC → D is fully contained in R2. So, F2 = { BC → D }.
• Combined FDs F' = F1 ∪ F2 = { A → B, BC → D }.
• Check if F' preserves F:
  • A → B: A+ (using F') = AB. This FD is preserved (direct in F1).
  • BC → D: BC+ (using F') = BCD. This FD is preserved (direct in F2).
• Since all FDs in F can be derived from F', the decomposition IS dependency preserving.

2. Lossless Join Check:

• The decomposition is R1 = (A, B) and R2 = (B, C, D).
• The intersection of R1 and R2 is R1 ∩ R2 = {B}.
• For the decomposition to be lossless, either (R1 ∩ R2) → R1 or (R1 ∩ R2) → R2 must hold in F+. That is, B → A or B → CD must be derivable from F.
• Let's find the closure of B using F: B+ = B.
  • B → A is NOT derivable from F (A is not in B+).
  • B → CD is NOT derivable from F (C and D are not in B+).
• Since neither condition holds, the decomposition is NOT a lossless join decomposition.

Conclusion: The decomposition is dependency preserving but not a lossless join decomposition. Therefore, Option B is correct.

To find the canonical cover, we follow these steps:

Step 1: Split FDs with multiple attributes on the RHS.
All FDs in F already have a single attribute on the RHS. So, F_c = { ABC -> D, C -> E, AC -> B, E -> D, A -> B }.

Step 2: Remove extraneous attributes from the LHS of each FD.

• C -> E, E -> D, A -> B: LHS are minimal.
• ABC -> D:
  • Is C extraneous? Check if D is in (AB)+ using F_c. (AB)+ = {A, B} (from A->B). D is not in (AB)+. So C is not extraneous.
  • Is B extraneous? Check if D is in (AC)+ using F_c. (AC)+ = {A, C, B} (from A->B, AC->B). D is not in (AC)+. So B is not extraneous.
  • Is A extraneous? Check if D is in (BC)+ using F_c. (BC)+ = {B, C, E, D} (from C->E, E->D). Yes, D is in (BC)+. So A is extraneous.
  • Replace ABC -> D with BC -> D.
  • F_c now becomes { BC -> D, C -> E, AC -> B, E -> D, A -> B }.
• AC -> B:
  • Is C extraneous? Check if B is in (A)+ using F_c. (A)+ = {A, B} (from A->B). Yes, B is in (A)+. So C is extraneous.
  • Replace AC -> B with A -> B.
  • F_c now becomes { BC -> D, C -> E, A -> B, E -> D, A -> B }. Remove duplicate A -> B.
  • F_c = { BC -> D, C -> E, A -> B, E -> D }.

After removing extraneous attributes, F_c = { BC -> D, C -> E, A -> B, E -> D }.

Step 3: Remove redundant FDs.
Initial F_c for redundancy check: { BC -> D, C -> E, A -> B, E -> D }

Pass 1:

• Consider BC -> D: Can D be derived from BC using {C -> E, A -> B, E -> D}? (BC)+ = {B, C, E, D} (from C->E, E->D). Yes, D is in (BC)+. So BC -> D IS redundant. Remove it.
  • F_c now becomes { C -> E, A -> B, E -> D }.
  • Since an FD was removed, restart redundancy check.

Pass 2:

• Current F_c: { C -> E, A -> B, E -> D }
• Consider C -> E: Can E be derived from C using {A -> B, E -> D}? (C)+ = {C}. E is not in (C)+. So C -> E is NOT redundant.
• Consider A -> B: Can B be derived from A using {C -> E, E -> D}? (A)+ = {A}. B is not in (A)+. So A -> B is NOT redundant.
• Consider E -> D: Can D be derived from E using {C -> E, A -> B}? (E)+ = {E}. D is not in (E)+. So E -> D is NOT redundant.

No FDs were removed in Pass 2. The process terminates.

The canonical cover F_c is { C -> E, A -> B, E -> D }.

Let F1, F2, F3 be the FDs in R1, R2, R3 respectively. We need to check if F+ is equivalent to (F1 ∪ F2 ∪ F3)+.

1. Original FDs F = { P → Q, Q → R, R → S, ST → P, T → Q }
2. FDs in R1 = (P, Q, R):
   • P → Q and Q → R are fully contained.
   • F1 = { P → Q, Q → R }.
3. FDs in R2 = (R, S, T):
   • R → S is fully contained.
   • T → Q (Q is not in R2) and ST → P (P is not in R2) are not fully contained.
   • F2 = { R → S }.
4. FDs in R3 = (P, T):
   • None of the FDs in F are fully contained in R3 (P → Q requires Q, T → Q requires Q, ST → P requires S).
   • F3 = { } (empty set for non-trivial FDs).
5. Combined FDs F' = F1 ∪ F2 ∪ F3 = { P → Q, Q → R, R → S }
6. Check if F' preserves F:
   • P → Q: P+ (using F') = PQ. Preserved (direct in F1).
   • Q → R: Q+ (using F') = QR. Preserved (direct in F1).
   • R → S: R+ (using F') = RS. Preserved (direct in F2).
   • T → Q: T+ (using F') = T. Q is not derived. Thus, T → Q is NOT preserved.
   • ST → P: ST+ (using F') = ST. P is not derived. Thus, ST → P is NOT preserved.

Since T → Q and ST → P are not preserved, the decomposition is not dependency preserving.
Option D is incorrect because Q → S is derivable from Q → R and R → S (from F').

Let F1, F2, F3 be the FDs in R1, R2, R3 respectively. We need to check if F+ is equivalent to (F1 ∪ F2 ∪ F3)+.

1. Original FDs F = { P → Q, Q → R, RS → P }
2. FDs in R1 = (P, Q):
   • The FD P → Q is fully contained in R1.
   • F1 = { P → Q }.
3. FDs in R2 = (Q, R):
   • The FD Q → R is fully contained in R2.
   • F2 = { Q → R }.
4. FDs in R3 = (R, S):
   • The FD RS → P is NOT fully contained in R3 (P is missing).
   • F3 = { } (empty set for non-trivial FDs).
5. Combined FDs F' = F1 ∪ F2 ∪ F3 = { P → Q, Q → R }
6. Check if F' preserves F:
   • P → Q: P+ (using F') = PQ. Preserved (direct in F1).
   • Q → R: Q+ (using F') = QR. Preserved (direct in F2).
   • RS → P: Let's find (RS)+ using F'.
     (RS)+ = R (given) S (given)
     From F', we cannot derive P from RS. The FDs in F' (P→Q, Q→R) only allow for derivation from P or Q, not involving RS to P.
     Therefore, the functional dependency RS → P is NOT preserved by the decomposition.

Thus, the decomposition is not dependency preserving. Option B correctly identifies the non-preserved FD. Option A is incorrect because P → R is derivable (P → Q, Q → R), but this does not make the entire decomposition dependency preserving if other FDs are not. Option D is incorrect as Q → R is fully preserved within R2.

To find the canonical cover, we follow these steps:

Step 1: Split FDs with multiple attributes on the RHS.
All FDs in F already have a single attribute on the RHS. So, F_c = { AB -> C, C -> A, C -> B, B -> D, D -> A }.

Step 2: Remove extraneous attributes from the LHS of each FD.

• C -> A, C -> B, B -> D, D -> A: LHS are minimal.
• AB -> C:
  • Is B extraneous? Check if C is in (A)+ using F_c. (A)+ = {A} (no FD from A directly yields C). C is not in (A)+. So B is not extraneous.
  • Is A extraneous? Check if C is in (B)+ using F_c. (B)+ = {B, D} (from B->D). Then {B, D, A} (from D->A). Then {B, D, A, C} (from A->C, C->B). Yes, C is in (B)+. So A is extraneous.
  • Replace AB -> C with B -> C.
  • F_c now becomes { B -> C, C -> A, C -> B, B -> D, D -> A }.

After removing extraneous attributes, F_c = { B -> C, C -> A, C -> B, B -> D, D -> A }.

Step 3: Remove redundant FDs.
We iterate through the FDs and remove any that can be derived from the remaining FDs. If an FD is removed, we restart the process for redundancy checking.

Initial F_c for redundancy check: { B -> C, C -> A, C -> B, B -> D, D -> A }

Pass 1:

• Consider B -> C: Can C be derived from B using {C -> A, C -> B, B -> D, D -> A}? (B)+ = {B, D} (from B->D). Then {B, D, A} (from D->A). (A)+ does not directly give C. So C is not in (B)+. B -> C is NOT redundant.
• Consider C -> A: Can A be derived from C using {B -> C, C -> B, B -> D, D -> A}? (C)+ = {C, B} (from C->B). Then {C, B, D} (from B->D). Then {C, B, D, A} (from D->A). Yes, A is in (C)+. So C -> A IS redundant. Remove it.
  • F_c now becomes { B -> C, C -> B, B -> D, D -> A }.
  • Since an FD was removed, restart redundancy check.

Pass 2:

• Current F_c: { B -> C, C -> B, B -> D, D -> A }
• Consider B -> C: Can C be derived from B using {C -> B, B -> D, D -> A}? (B)+ = {B, D} (from B->D). Then {B, D, A} (from D->A). C is not in (B)+. B -> C is NOT redundant.
• Consider C -> B: Can B be derived from C using {B -> C, B -> D, D -> A}? (C)+ = {C}. B is not in (C)+. C -> B is NOT redundant.
• Consider B -> D: Can D be derived from B using {B -> C, C -> B, D -> A}? (B)+ = {B, C} (from B->C, C->B). D is not in (B)+. B -> D is NOT redundant.
• Consider D -> A: Can A be derived from D using {B -> C, C -> B, B -> D}? (D)+ = {D}. A is not in (D)+. D -> A is NOT redundant.

No FDs were removed in Pass 2. The process terminates.

The canonical cover F_c is { B -> C, C -> B, B -> D, D -> A }.

Let F1 be the set of FDs in R1 and F2 be the set of FDs in R2. We need to check if F+ (closure of original FDs) is equivalent to (F1 ∪ F2)+ (closure of FDs in decomposed relations).

1. Original FDs F = { A → B, C → D, AD → E, B → C }
2. FDs in R1 = (A, B, C):
   • From F, we have A → B and B → C. Both are fully contained in R1.
   • Thus, F1 = { A → B, B → C } (which implies A → C).
3. FDs in R2 = (C, D, E):
   • From F, we have C → D. This is fully contained in R2.
   • The FD AD → E from F is not fully contained in R2 (A is missing).
   • Thus, F2 = { C → D }.
4. Combined FDs F' = F1 ∪ F2 = { A → B, B → C, C → D }
5. Check if F' preserves F: We need to verify if every FD X → Y in F can be derived from F'.
   • A → B: A+ (using F') = AB. Preserved (direct in F1).
   • C → D: C+ (using F') = CD. Preserved (direct in F2).
   • B → C: B+ (using F') = BC. Preserved (direct in F1).
   • AD → E: Let's find (AD)+ using F'.
     (AD)+ = A (given) D (given)
     A → B, so (AD)+ = ABD
     B → C, so (AD)+ = ABCD
     C → D, so (AD)+ = ABCD (already have D)
     Since E is not in (AD)+ using F', the functional dependency AD → E is NOT preserved by the decomposition.

Therefore, the decomposition is not dependency preserving. Option C correctly identifies the non-preserved FD.

Canonical covers are used in the 3NF synthesis algorithm. For each FD $\alpha \to \beta$ in the canonical cover, a relation schema $(\alpha \cup \beta)$ is created. This guarantees the resulting decomposition is in 3NF with dependency preservation and lossless join.

Split (all single RHS already). Check $AB \to C$: $A^+ = \{A,B,C\}$ (via $A \to B$, then $AB \to C$, and $A \to C$). $B$ extraneous in $AB \to C$: $(AB-B)^+ = A^+ = \{A,B,C\}$, $C \in A^+$. So $AB \to C$ becomes $A \to C$. Now $F = \{A \to B,\ A \to C,\ A \to C,\ C \to B\}$. Remove duplicate $A \to C$. Check $A \to C$: redundant? $A^+$ without $A \to C$ = $\{A,B\}$ (via $A \to B$, $C \to B$ doesn't help). $C \notin \{A,B\}$. Not redundant. Check $C \to B$: $C^+$ without $C \to B$ = $\{C\}$. Not redundant. Merge: $\{A \to BC,\ C \to B\}$ = 2 FDs.

1. Lossless Join: $R_1 \cap R_2 = \{A\}$. Since $A \to BC$, we have $A \to B$ (decomposition), so $A$ is a superkey for $R_1(A, B)$. The condition $R_1 \cap R_2 \to R_1$ holds. Hence lossless. 2. Dependency Preservation: $A \to B$ is in $R_1$ and $A \to C$ is in $R_2$, both derived from $A \to BC$. All FDs are preserved.

To check for dependency preservation, we need to verify if every FD in F can be logically derived from the union of projected FDs (F1 U F2 U F3)+.

Projected FDs:
F1 on R1(U, V, W): { UV → W }
F2 on R2(W, X): { W → X }
F3 on R3(V, Y, Z): { V → Y }

Let's check each FD in F:

1. UV → W: This FD is directly present in F1, so it is preserved.
2. W → X: This FD is directly present in F2, so it is preserved.
3. V → Y: This FD is directly present in F3, so it is preserved.
4. XY → Z: The attributes {X, Y, Z} are not all contained within any single decomposed relation. We need to check if Z can be derived from XY using (F1 U F2 U F3).
   (XY)+(F1 U F2 U F3): Initially {X, Y}.
   Applying F1, F2, F3: No rules can be applied to derive Z from {X, Y}.
   The closure (XY)+(F1 U F2 U F3) = {X, Y}. It does not contain Z. Therefore, XY → Z is not preserved.

Since XY → Z is not preserved, the decomposition is not dependency preserving.

After splitting: $\{A \to B,\ A \to C,\ CD \to E,\ B \to D,\ E \to A\}$. Check extraneous: No attribute is extraneous on any LHS or RHS. Check redundancy: none is redundant. Merge $A \to B$ and $A \to C$ back to $A \to BC$ (same LHS). Final $F_c = \{A \to BC,\ CD \to E,\ B \to D,\ E \to A\}$.

The first step in computing canonical cover is to decompose (split) each FD so that the RHS has exactly one attribute. E.g., $A \to BC$ becomes $A \to B$ and $A \to C$. This simplifies the process of detecting extraneous attributes.

Check $AB \to C$: is $A$ or $B$ extraneous? $A^+ = \{A,B,C\}$ (via $A \to B$ and $AB \to C$). Wait - to check if $B$ is extraneous in $AB \to C$: $(AB-B)^+ = A^+$ under $F$ = $\{A,B\}$ ($A \to B$, then $AB \to C$? But we're checking without knowing if $C$ is reached). $A^+$: $A \to B$, then $AB \to C$, so $A^+ = \{A,B,C\}$. $C \in A^+$, so $B$ is extraneous. $AB \to C$ becomes $A \to C$. $F_c = \{A \to C,\ A \to B,\ B \to A\}$ - merge: $\{A \to BC,\ B \to A\}$... unique LHS gives 2. Recounting: $\{A \to B,\ A \to C,\ B \to A\}$ with unique LHS after merge = $\{A \to BC,\ B \to A\}$ = 2 FDs. Answer: 2.

To test if $B \in \beta$ is extraneous in RHS of $\alpha \to \beta$: replace $\alpha \to \beta$ with $\alpha \to (\beta - B)$ in $F$, giving $F'$. Compute $(\alpha)^+$ under $F'$. If $B \in (\alpha)^+_{F'}$, then $B$ was extraneous in RHS and can be removed.