Re: Can relvars be dissymetrically decomposed? (vadim and x insight demanded on that subject)

From: Cimode <>
Date: 17 Jul 2006 09:41:50 -0700
Message-ID: <>

erk wrote:
> Cimode wrote:
> > erk wrote:
> > I see your point. I use the term *projection* in as *encoding* or
> > *representation* as an RTable. I consider this representation as
> > varying over time and operations made on and with the relation.
> I still wouldn't call that an encoding or representation. An encoding
> would be, perhaps, the on-disk string of bytes which holds the contents
> of the relvar. A relvar really has only one operation: assignment
> (assigning a new value to the relational variable). There are, of
> course, many relational expressions, but any that use relvars are
> really using the current values (relvals) of the relvars; thus only
> assignment "does anything" to the relvar.
> Of course, other people should chime in, as my terminology might be
> idiosynchratic.
I am not bothered with terminology at the moment.

> > > A relvar can have different values at different points in time - like
> > > any variable. The values are relvals (of course).
> > What you said is logically correct but I would not say it that way. A
> > relvar holds different values over time because the relations expressed
> > by relvars have a *behavior* that changes over time (Caution: behavior
> > has nothing to do with OO fuzzy concepts, it is meant in a mathematical
> > function describing sense). For instance, some relvar may be used to
> > express several relations the same way the variable *x* may express
> > several functions. And of course, x may *hold* different values
> > (relvalues in RM) over time.
> I don't agree at all here, at least not to the extent that I understand
> you. If a variable x can "express several functions" over time, then I
> assume x has several assignment statements which change it.
I realize now after reading that my sentence was confusing because I packed up too many ideas at once. I admit and I apologize for it. Let's make it short...

First statement, A relvar holds different content (relvalue) over time BECAUSE the relation it describes has a time bound behavior. That the first statement.
Second, a variable may help express functions in general (not over time). For instance, the variable *x* may express function F(X) = A(x) + B as it may express function Y(x) = D(x) + G

The confusion came from the fact I used *For instance* which established a relationship between the two concepts.

> This
> implies that the type of variable x is a supertype of all the assigned
> functions, or the assignment would make no sense. This isn't the case
> with relations; if I create a relvar, and consider its type T (e.g. {A,
> B C} as attributes), I can't assign arbitrary relvals to it unless they
> are also of type T.
> > [snip]
> > For instance, if you consider the function F(X) = A(X) and you add
> > the value B to F(X), you are basically doing a translation making a new
> > function T(X) = F(X) + B = A(X) + B In this case, the result of adding
> > B to the function can be expressed (characterized) as a mathematical
> > translation (jumping from F(X) to T(X)). It says a lot about the
> > function F(X) behavior and may help describe it better over time.
> But F isn't changing. You're creating a new function, not changing an
> existing one. Assuming the expression F(X)+B makes sense, T has the
Now that's finally getting interesting... If I follow your reasoning that would mean that once an INSERT is done, there would be necessarily a new relation resulting from the INSERT operation performed?

> same type as F, but it's not the same function, as its post-conditions
> are different.
What are *post conditions*?

> > The
> > challenge of this thread is to do a similar effort on relations. For
> > instance, an interesting question raised would be: is an INSERT
> > operation equivalent to a translation in relational perspective?
I rephrase then : is an INSERT operation equivalent to a translation in relational perspective resulting in a new relation?

> > Overall, how does a relation R1 *changes* when an INSERT, UPDATE,
> > DELETE operation is made on it? Characterizing such change would help
> > describe better relations themselves.
Are operations in general performed on relations create new relations.?

> The data changes, as "facts" are changed (each tuple is a fact). I
> don't see how this changes behavior, or anything other than the results
> of logical deductions (e.g. queries) made using that relation.
> > [snip]
> > For instance, if one considers the function F(x) = A(x) + B.... such
> > function is expressed as an equality using 1 relvar (in this case *x*),
> > 2 operators (in this case *X* and *+*) and 2 values (a and b). By
> > characterizing relation R1, I mean how would it be possible to
> > express in a similar fashion some relation R1 (NOT a the relvar but the
> > relation itself) using as relvalues domains and some operator.
> > [snip]
> Sorry, not getting this at all. What operator is *X*? If x is a
> relation, then isn't A(x) a relational expression, and thus B and F(x)
> too, rather than values?
I used *X* as the multiply operator in the expression A * (x) + B to be able to put between quotes.

> - erk
Received on Mon Jul 17 2006 - 18:41:50 CEST

Original text of this message