*This entry is probably ahead of the story, but I wanted to start moving into this subject and I’m not yet organized. It should make more sense later on when I’ve explained such things as the “magical” function M() more thoroughly.*

## Review: The Magical Function “M()”

As a review for those who may not have seen this function previously on this site, I have invented a mysterious and powerful function over all things used as signs by humans. Named the “*M()*” function, I can apply it to any symbol or set of symbols of any type and it will return what that symbol represents. I call it the “*M()*“ function because it takes something which is a *symbol* and it returns its *meaning *(that’s *all* of its meaning).

## How Meaning Carries Over Symbol Transformations

When we move information from one data structure to another, we may or may not use a reversible process. By this I mean that sometimes a transformation is a one-way operation because some of the meaning is lost in the transformation. Sometimes this loss is trivial, but sometimes it is crucial. *(Alternatively, there can be transformations which actually add meaning through deductive reasoning and projection. SFAT (story for another time))*

Whether a transformation loses information or not, there are some interesting conclusions we can illustrate using my magical, mysterious function *M()*. Imagine a set ** β** of data structure instances (data) in an anchor state. The full meaning of that data can be expressed as

*M(*. Now imagine a transformation operation

**)***β**T*which maps all of the data in

**onto a second set of data**

*β**.*

**Δ***T : β |–> Δ *such that for each symbol

*σ*in

**, there is a corresponding symbol**

*β**δ*in

*that represents the same things, and*

**Δ***σ <> δ*

By definition, since we have defined *T* to be an identity function over the meaning of ** β**, then we can conclude that if we apply

*M()*before and after the transformation, we will find ourselves with an equivalence of meaning, as follows:

By definition: *T(β) = Δ*

Hence: *M( T(β) ) ≡ M( Δ )*

Also, by definition of *T()*, then *M( β ) ≡ M( T(β) )*

Finally, we conclude: *M( β ) ≡ M( Δ )*

Now, obviously this is a trivial example concocted to show the basic idea of *M()*. Through the manner by which we have defined our scenario, we get an obvious conclusion. There are many instances where our transformation functions will not produce equivalent sets of symbols. When *T() *does produce an equivalence, we call it a “loss-less” transformation (borrowing a term from information theory) because no information is lost through its operation.

Another relationship we claim can also be defined in this manner is namely that of semantic equivalence. * *This should be obvious as well, from reflection, as I was careful above to refer to “equivalence of meaning”, which is really what I mean when I say two things are semantically equivalent. In this situation, we defined *T() *as an operation over symbols such that one set of symbols were replaced with a different set of symbols, and the individual pairs of symbols were NOT THE SAME (*σ <> δ*)! In a most practical sense, what is happening is that we are exchanging one kind of data structure (or sign) with another, such that the two symbols are not syntactically equivalent (they have different signs) but they remain semantically equivalent. *(You can see some of my thoughts on semantic and syntactic equivalence by searching entries tagged and/or categorized “**equivalence**” and “comparability“.)*

A quick example might be a data structure holding a person’s name. Let’s say that within ** β** the name is stored as a string of characters in signature order (first name middle name last name) such as “John Everett Doe”. This symbol refers to a person by that name, and so if we apply

*M()*to it, we would recognize the meaning of the symbol to be the thought of that person in our head. Now by applying

*T()*to this symbol, we convert it to a symbol in

*, also constructed from a string data structure, but this time the name components are listed in phone directory order (last name, first name middle name) such as “Doe, John Everett”. Clearly, while the syntactic presentation of the transformed symbol is completely different, the meaning is exactly the same.*

**Δ***T(“John Everett Doe”) = “Doe, John Everett”*

*M( T(“John Everett Doe”) ) ≡ M( “Doe, John Everett” )*

*M( “John Everett Doe” ) ≡ M( T(“John Everett Doe”) )*

*M( “John Everett Doe” ) ≡ M( “Doe, John Everett” )*

*“John Everett Doe” <> “Doe, John Everett”*

When the transformation is loss less, there is a good chance that it is also reversible, that an inverse transformation *T ‘ ()* can be created. As an inverse transformation, we would expect that *T ‘ ()* will convert symbols in * Δ* back into symbols in

*, and that it will also carry the meaning with complete fidelity back onto the symbols of*

*β**. Hence, given this expectation, we can make the following statements about*

*β**T ‘ ()*:

*T ‘ (Δ) = β*

*M( T ‘ (Δ) ) ≡ M( β )*

By definition of *T ‘ ()*, then *M( Δ ) ≡ M( T ‘ (Δ) )*

And again: *M( Δ ) ≡ M( β )*

Extending our example a moment, if we apply *T ‘ () *to our symbol, “Doe, John Everett”, we will get our original symbol “John Everett Doe”*. *

## Meaning Over “Lossy” Transformation

So what happens when our transformation is not loss-less over meaning? Let’s imagine another transformation which transforms all of the symbols *σ* in *β* into symbols

*ε*in

*. Again, we’ll say that*

**Ε***σ*<>

*ε*, but we’ll also define

*T ‘ ‘ ()*as “lossy over meaning” – which just indicates that as the symbols are transformed, some of the meaning of the original symbol is lost in translation. In our evolving notation, this would be stated as follows:

*T ‘ ‘ (β) = Ε*

*M( T ‘ ‘ (β) ) ≡ M( Ε )*

However, by the definition of *T ‘ ‘ ()*, then *M( β ) !≡ M( T ‘ ‘ (β) )*

Therefore: *M( β ) !≡ M( Ε )*

In this case, while every symbol in *β* generates a symbol in

*, the total information content of*

**Ε***is less than that in B. Hence, the symbols of the two sets are no longer semantically equivalent. With transformations such as this, the likelihood that there is an inverse transformation that could restore*

**Ε***from*

*β**becomes more unlikely. Logically, it would seem there could be no circumstances where*

**Ε***could be reconstituted from*

*β**alone, since otherwise the information would have been carried completely across the transformation. I don’t outright make this conclusion, however, since it depends on the nature of the information lost.*

**Ε**An example of a reversible, lossy transformation would include the substitution of a primary key value for an entire row of other data which in itself does not carry all of the information for which it is a key, but which can be used in an index fashion to recall the full set of data. For example, if we created a key value symbol consisting of a person’s social security number and last name, we could use that as a reference for that person. This reference symbol could be passed as a marker to another context (from *β* to

*, say) where it could be interpreted only partially as a reference to a person. But which person and what other attributes are known about that person in the new context*

**Ε***if we define the transformation in such a way that all of the symbols for these other attributes stay in*

**Ε***? Not much, making this transformation one where information is “lost” in*

*β**. However, due to its construction from*

**Ε***, the key symbol could still be used on the inverse transformation back to*

*β**to reconstitute the missing information (presuming*

*β**retains it).*

*β*An example of a one-way transformation might be one that drops the middle name and last name components from a string containing a name. Hence, *T ‘ ‘ (* “John Everett Doe” *)* might be defined to result in a new symbol, “John”. Since many other symbols could map to the same target, creating an inverse transformation without using other information becomes impossible.

Filed under: Comparability, data, Equivalence, M( ), Meaning, Sign, Symbol, Transformation | Tagged: Comparability, Concept, data, Equivalence, Function, M( ), Meaning, Sign, Symbol, Transformation | Leave a comment »