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

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.

> > 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. 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 same type as F, but it's not the same function, as its post-conditions are different.

> 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?
> 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.

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?

• erk