# Re: Principle of Orthogonal Design

From: mAsterdam <mAsterdam_at_vrijdag.org>
Date: Fri, 25 Jan 2008 09:18:32 +0100
Message-ID: <47999a9d\$0\$85779\$e4fe514c_at_news.xs4all.nl>

> DEFINITION: Two relations R and S are said to have overlap in meaning
> if there is a dependency that requires that sometimes some tuples of R
> are also in S after renaming the attribute names, or vice versa.

..and start simple ;-)

1. The 'renaming etc...' is only there to exclude trivialities, caused by a clumsy (at least for this coffee-machine) definition of tuple-types, clumsy because it includes attribute names. We'll have a definiton without attribute names (to be formulated later if necessary).
2. It is not at all clear a priori what if anything this has to with meaning. To avoid distraction by connotation we'll substitute the definiendum by one with less connotation, and see if we can substitute it back when the conclusions are clear. My first hunch was 'symbolic redundancy' (thinking of Neo) but that would be loaded as well. It is the chaff to be filtered out by the PoOD, so PoOD-chaff. Clean enough?
3. 'renaming etc...' -- out
4. PoOD-chaff

DEFINITION: Two relations R and S are said to have PoOD-chaff if there is a dependency that requires that sometimes some tuples of R are also in S.

> It's a bit hand-wavy for my taste, because it doesn't define the type
> of dependencies but it will probably do for the moment.
Ok.

Note: The isomorphy of R and S is implicit. The tuples can be in both R and S so R-tuples and S-tuples have to be of the same type.

>
> DEFINITION: A join dependency is said to be a proper if it does not
> hold that any of its components is a subset of another component.

Proper is a nicer than non-trivial.

> Now the rule:
>
> DEFINITION: A schema is said to violate POOD if it contains relations
> R and S such that a component C of a proper join dependency of R
> overlaps in meaning with a component D of a proper join dependency of
> S, and either R and S are different, C and D are different, or both.
>

```>>> So far so good?
>> Does PoODling flush bathwater, baby, or part of both?
>> The jury isn't even out yet.
```

>
> I suspect with the new POOD the baby is quite safe. :-)

DEFINITION: A schema is said to violate POOD if it contains relations R and S such that a component C of a proper join dependency of R has PoOD-chaff with a component D of a proper join dependency of S, and either R and S are different, C and D are different, or both.

Now let's see if there is meaning overlap, that is, is it ok to s/PoOD-chaff/meaning overlap/ back? To check that, I'll first have to make sure I understand the definition.

I don't have much experience with reasoning about 5NF. Aside: The reason for that may be, that whenever I come across

```        the not immediately obvious, I start stating easily understood
natural language sentences, expressing the elementary facts we
are modeling. From consensus on those we'll formalize to
predicates and check again. From these predicates the already
normalized relations follow (except the naming, but there
is strong support in the predicates).
```
Received on Fri Jan 25 2008 - 09:18:32 CET

Original text of this message