functional-dependencies

I was looking at this video on normalization on youtube and I have to say I am confused now, I there might be errors in the video even though it has 25 likes and only 1 dislike. Normalization Specifically regarding the 2NF section which can be found at the 5 minute mark. The author says the 'Assignment Description' column depends on the Assignment ID column...yet there are there are different Assignment Descriptions for the same Assignment ID. He then 'normalizes' this table into 2NF by breaking it into two tables...one of them containing only Assignment ID and Assignment Description. And this

Does anyone of them implies the other? My logic is that if all dependencies are preserved, then there is no loss of information and similarly, if decomposition is lossless then no functional dependency must have been violated. So essentially, dependency preservation is a way to ensure that your decomposition is lossless. I am having a hard time accepting/denying it. So do both of these guarantee one another or are there cases where one can be achieved without the other? In general these are two independent things: you can have a lossless decomposition without dependency preservation, as well

Is it possible to create type family instances from a fundep class? For example, let's say that I have the class class A a b | a -> b with some instances (imported an external library) and want to create all corresponding instances for the type family type family A' a :: * such that A' a ~ b iff A a b , without having to manually copy and modify the instances from the external source. How would I do that (if it is possible)? My most promising attempt so far, class A' a where type A'_b a :: * instance forall a b. A a b => A' a where type A'_b a = b gives the error message The RHS of an

I can tell the number of parameters of a function with the following code {-#Language MultiParamTypeClasses#-} {-#Language FunctionalDependencies#-} {-#Language UndecidableInstances#-} data Zero data Succ a class Number a instance Number Zero instance (Number a) => Number (Succ a) class NotFunction a instance NotFunction Int instance NotFunction Float instance NotFunction (IO a) class (Number n) => FunctionLevel f n | f -> n where functionLevel :: f -> n instance FunctionLevel Int Zero where functionLevel = undefined instance FunctionLevel Float Zero where functionLevel = undefined instance

I'm looking for an easy to understand algorithm to compute (by hand) a closure of a set of functional dependencies. Some sources, including my instructor says I should just play with Armstrong's axioms and see what I can get at. To me, that's not a systematic way about doing it (i.e. easy to miss something). Our course textbook (DB systems - the complete book, 2nd ed) doesn't give an algorithm for this either. If by "play" he meant an exhaustive search, then in no way this is not-systematic ;) And a simple solution could look like iterative expansion*) of the set of dependencies on the rule-by