A functional dependency (FD) is a statement about a relation that says: if two tuples agree on the values of one set of attributes, they must also agree on the values of another set. We write this as X -> Y, read "X functionally determines Y" or "Y is functionally dependent on X." The left-hand side X is called the determinant. For example, in a relation about students, StudentID -> Name asserts that a given StudentID value can never be paired with two different names.
FDs are not facts you discover by staring at one snapshot of data; they are constraints that come from the meaning of the data in the real world the database models. That is why the context matters: an FD is always stated over the attributes of a particular relation schema. This connects directly back to the formal relational vocabulary from earlier in the module — domains, attributes, tuples, and schemas — because an FD is a rule about which tuples are legal in a relation.
As you work through this topic, pay attention to three things. First, the notation and how to read it aloud correctly. Second, the distinction between trivial FDs (where the right-hand side is contained in the left-hand side, such as {A, B} -> A, and which hold automatically) and non-trivial FDs, which carry real information. Third, why any of this matters: FDs are the foundation for keys, for Armstrong's Axioms, for attribute closure, and ultimately for normalization and the elimination of redundancy and update anomalies. The videos below approach these ideas at different levels of depth, so watch them in order and treat the later ones as a preview of where FDs lead.
A focused lecture on functional dependencies in DBMS that, based on its title, walks through the definition of an FD and then works systematically through the common types, including trivial and non-trivial dependencies. At roughly 17 minutes it is the longest and most introductory-paced of the three, so expect notation, terminology, and worked examples drawn from sample relations. This is the video that most directly matches the scope of this topic.
It is the closest match to the subtopic list, covering the definition, notation, and the trivial versus non-trivial distinction in a single continuous explanation, which makes it a good primary viewing before you move on to applications of FDs.
Decomplexify's explanation of Boyce-Codd Normal Form builds up from functional dependencies and keys to the BCNF condition, using concrete example tables throughout. Because BCNF is defined entirely in terms of FDs — every determinant must be a superkey — the video necessarily spends time showing how to read FDs off a relation and why some of them cause trouble. It also illustrates the redundancy and anomalies that motivate the whole subject.
Decomplexify is a widely watched and carefully produced channel, and this video answers the "why do functional dependencies matter?" subtopic better than an abstract treatment can, by showing the concrete problems FDs are used to diagnose.
This video covers Armstrong's Axioms and inference rules alongside a review of functional dependency types, including trivial, non-trivial, and multivalued dependencies. Expect the reflexivity, augmentation, and transitivity rules to be stated and applied to small FD sets to derive new dependencies. Note that the instruction is delivered in Malayalam, so use it mainly if that language suits you or as a visual reference for the rule statements and worked derivations.
It extends the basic FD definitions toward the inference rules you will use later in the module, and reinforces the trivial versus non-trivial classification from a second instructor's perspective.
Together these videos move from definition to application. The StudyTech Hub lecture establishes the notation and terminology that let you state FDs precisely over a relation schema (MO1) and directly addresses the trivial versus non-trivial distinction you must be able to make (MO2). The CHAPTERS video introduces Armstrong's Axioms and shows derivations, supporting the inference work in MO3 and laying the groundwork for computing attribute closures and identifying candidate keys (MO4). The Decomplexify BCNF video supplies the motivation and the evaluative skill behind MO5, demonstrating how analyzing a schema's functional dependencies exposes redundancy and update anomalies. Watch them in the order listed, and keep in mind that the closure algorithm in MO4 is only previewed here — you will practice it directly in the module exercises.
These videos were chosen from YouTube on October 2, 2026. Each has captions; the player turns them on. Videos on YouTube can be changed or removed — if one no longer plays, tell your instructor. If a player does not appear, use its Watch on YouTube link.