The regex (regular expressions) are very useful for programmers. Using this device you can describe every string that presents to its inside a certain regularity.

We don’t want to talk about formal languages or formal grammars, we are going to bring you some examples that show how it works.

Think about having a web page with a form with the following fields:

• - Name
• - Surname
• - E-mail
• - Phone number

Once you have filled in the format and sent the data to the script, it’s very important to check if they are correct.

You need to define the specific area:

• Name: It’s made by one word only and by alphabetical letter. According to us this is not a compulsory camp.
• Surname: It’s made by one or more words that can be made only by alphabetical letter
• Email: It’s made by 3 part: the first one is made by alphanumeric issues, underscore (_) and period (.), there’s the second one made by alphanumeric issues and dash, followed by a period , which is always followed by 2 to 4 alphabetical letters. This one is compulsory.
• Phone number: made by 2 part. It’s divided by a dash.

All the following fields owe a specific regularity and there are specific expressions that defines them. These are the expression:

• name: [a-zA-Z]*
• surname: [a-zA-Z’ ]+
• email: [a-zA-Z0-9_\.]+@[a-zA-Z0-9-]+\.[a-zA-Z]{0,4}
• phone number: [0-9]+\-[0-9]+

- - -

CLASSES

The operator sign [] it’s made by two square brackets. In this metacharacter can be insert several constant character. Trough this metacharacter it’s possibile to characterize a single occurancy of one of the present characters to its inside, if it’s insert like normal characters or if it’s insert using constants: the characters set defined trough this operator takes the class name. For example the class [a] represents the single occurancy of the a character and allows to verify if it is inside a string and in that case executing some operation on it. Otherwise the class [abcd] represents the single occurency in one of the four characters presents inside it and permit to verify if they are present in the strings and execute operations on them.

- - -

RANGE OPERATOR

- it’s an operator that permits to identify a range, for example:

• a-z for all the lower case letters
• A-Z for all the upper case letters
• 0-9 for all the numbers.

A part from this classic range, it’s always possibile to personalize them, for example the a-f contains all the lower case letters from a to f, it’s very useful to characterize hexadecimal numbers.
The class [a-fA-F0-9] individualizes all the figures and the letters from a to f ( lower case and upper case) all the characters that are inside an hexadecimal figure.

- - -

CLASS REPETITION

Now we are going to describe the class repetition operators.

The first one we are going to analyse it’s the star *. It’s the one that can verify how many time a class is repeated inside a string and to select all the consecutive occurency.
For example, the following regular expression [a-z]* selects in a string all the consecutive occurency of alphabetical letters, how it’s shown here:

I have got 7 telephone number, but this is my cell-phone: 0004578907

This operator considers an empty set as positive solution and it’s used to verify the exactness of the NAME field, it could also be empty, but if it’s not it must be made by one word only. The regular expression refereed to it is: [a-zA-Z]*

That expression contains all the alphabetic letter a-z and A-Z.
Very similar to the star it’s the plus + operator that works in the same way, but it verify if a class it’s repeated inside a string one or more times. We use it for the SURNAME fields, that can contain one or more words separated by spaces. This is the regular expression refereed to it: [a-zA-Z]+

Another operator it’s made by 2 {} braces, in their inside it can be a number {3} or a numerical range {12,58}. The first one individualizes all the repetitions of 3 characters that verify the class. The second one individualizes from 12 to 58 repetitions of characters that verify the class.

For example [0-9]{3,4}\-[0-9]{7} individualizes all the telephone number in an area code made by 3 or 4 figures and a suffix of 7 figures.

- - -

BACKSLASH

In the last example we also talked about another operator the backslash \. We put this sign before a character if it is an operator and it makes not considering it as character, if we put it before a letter it is a constant. The dash it’s used to indicate a range and therefore if we want to use as a character we have to write it down this way: \-

Now you can understand the regex that we used to verify the email:

• [a-zA-z0-9_\.]+@[a-zA-Z0-9-]+\.[a-zA-Z]{0,4}

And the one for the telephone number:

• [0-9]+\[0-9]+

- - -

REPETITION OPERATOR’S SPECIFIC CHARACTERISTIC

One of the characteristics of the repetition operators is selecting everything is related to the expressions. This characteristic could be counterproductive sometimes. If we want to eliminate from a html page all the tags, we can use the following regular expression:

• <.+>

This kind of regex selects a consecutive series of characters inside a string. The first one is < followed by some different consecutive characters followed by a >. Therefore the regular expression described before in the following string will be such this:

• <HTML><HEAD> <TITLE> REGULAR EXPRESSIONS </TITLE> </HEAD> <BODY> </BODY> </HTML>

Inside a line we take everything that is between the firs part of the character < and the last part of the character >.

If this operation doesn’t satisfy our demand we need to use one of the following method:

• 1. <.+?>
• 2. <[ ^<>]+>

The first one makes the repetition operator less strong and it makes it stops in the first part of the closing character.

The second individuates inside a strings a series of characters that start with < followed by any characters different from < and > followed by an >.

The regex that we have just described will appear in the former string like this:

• <HTML><HEAD> <TITLE> REGULAR EXPRESSIONS </TITLE> </HEAD> <BODY> </BODY> </HTML>

- - -

CLASS DENING

Let’s focus on a different problem. Let’s suppose having a story and we need to individuate all the sentences present inside it. If inside the story the period is used only at the end of the sentences, we have to deny a class in order to individuate a sentence in a easier way.

• [^\.]+

The ^ sign if it’s put immediately after the first bracket of a class, it denies the class. Therefore in our case it’s individuated the consecutive repetition of all that characters that are not the period. Basically a sentences it is individuated.

- - -

THE PERIOD

The period it’s a constant, and if it is inserted in a regex it’s equivalent to a class that has all the characters but the “new line”.

This is just an example to better understand the function of the period:

• c.s.

The former regex individuates all the 4 characters sequences that starts with c followed by any characters and then followed by a an s. It creates different combinations such as:

• case
• casa
• cosa
• cose
• c%s9
• c£sl

- - -

ALTERNANCY OPERATOR

Another very useful operator is the pipe | which has the same function of th OR. For example, the regex george|stuart individuates inside a string the word george or the word stuart:

• Both george and stuart are two famous seo, but george has a forum, stuart has a web agency.

- - -

ANCHORS

Another problem can be faced if you need to modify one or more elements inside a CSV (comma-separeted value) database, a textual database in which fields are separated by commas and which records are divided by a new line. The following database is an example that represents the daily gain of an adsense made by three friends.

• 12€, 50€, 70€
• 30€, 46€, 68€
• 15€, 52€, 73€
• 16€, 30€, 85€

If one day one of the friends was banned from adsense, his data would not be useful anymore and could be necessary to remove them. In the former example there are very few data therefore it is very easy to do a manual change. If there were thousands data the regex would be the fastest solution. If the data of the banned friend is the ones in the third column, the fastest solution to remove them would be to eliminate all the occurency in the following regex:

• ,[0-9]*€$

The $ character doesn’t identify any characters, but a position, the end of a line. Therefore the former regex finds all the consecutive characters series that start with a comma followed by some numbers, followed by the €, followed by the ending of a line.

It’s always possible to identify the beginning of a line with the ^ character. This one has to be used very carefully because you can use it to deny a class itself. Therefore you always have to remember to use it outside a class. Also the $ operator must be used this way, if it is used inside a class you can refer to it as a character.

- - -

GROUPS

We can consider a characters series as a single group, we can operate on it using some of the operators that build the regex. We could find out inside a text a code we don’t know its lenght, which is composed by 5 numbers followed by a letter, followed by 5 numbers followed by a letter etc etc…until it terminates with a new line. There is only a solution to find this code, we need to use a group. In this example the group it’s made by a class which has numbers only repeated five times, followed by an only letters class. This group has to be repeated at least once and must end with a new line. It could be written down as:

• ([0-9]{5}[a-zA-Z])+$

The regex creates this effect:

• My secret code is 12345T45345R12343F34567j
• Phil’s secret code is 34526g54638j92725K63723H72829D12345I
• 12345T45345R12343F34567j is not phil’s code.

- - -

BACKREFERENCES

We could need to modify the positions of different part of text inside a string. For example, let’s suppose having a database csv made by 5 columns and 10000 rows with an error: the second column is in the fourth column position. Changing the position manually it will take hours and hours, but with regex we can solve that problem in less than 5 seconds.

One of the group property is to memorize in a variable the selected text trough them, in order to use it in a substitution phase. For example, we need to create 5 groups that selects the fields present in a inside a rows of our csv. We have to admit that the database it’s structured as it follows:

• 1,45,589, phil, bob
• 2,56,79,mary,bob
• 3,57,89,phil,frank
• ..,..,..,..,..

We can use the following regex to select to select each of the single fields inside a row:

• ([^,]+),([^,]+),([^,]+),([^,]+),([^,]+),$

With the former regex each fields will be memorized in a variable, the first will have the first one, the second will have the second one and etc etc. We need only to substitute the text selected with a new structure (1,4,3,2,5) to get the result we desire.

But there’s a little problem because the way to retrieve the variables is very different.

Htaccess, dreamweaver, PERL retrieve the variables using the $ character. Example: $1 to retrieve the first one, $2 to retrieve the second one. Furthermore $0 retrieves the match of the whole regex. In the former example we would have replaced with this row:

• $1,$4,$3,$2,$5

EditPad pro, PowerGREP retrieve the variables using the \ character. Example: \1 retrieves the first one, \2 retrieve the second one. Furthermore \0 retrieves the match of the whole regex. In the former example we would have replaced the regex with the following expression:

• \1,\4,\3,\2,\5

.NET, Javascript, PHP, etc.. each of them retrieves the variables in different ways and we advice you to read their guides.

WARNING: if you use the repetition to repeat whole groups, the variables will be refereed each to a single selected group and not to the whole group repeated another time. If you use the regex ([0-9]{5}[a-zA-Z])+$ to select the code on this text

My secret code is 12345T45345R12343F34567j

the 1 variable will correspond with the selected part of the text and not to the whole code. This kind of things happens because the repetition is outside the backreference, therefore to solve this problem the solution is to change the group we have to repeat without backreference ( in order not to save it) and set up the backreference on the whole repetition:

• ((?:[0-9]{5}[a-zA-Z]?)+)$

In the former regex you can notice this particular structure (?: ?) in which are inserted two classes. This kind of structure is a group without backreferences; we can apply a repetition and memorize it.
Now the variable 1 the following code (bold):

My secret code is 12345T45345R12343F34567j

- - -

QUESTION MARK

In the groups the question mark can be used to avoid the match memorization. We have already seen that question mark could be used to restrict the repetitions. Now we will see that exit a lot of different functions for this simple character.

The first function makes a group optional, as you can see in the following example:

• michael (owen)?

In the former regex the group (owen) is made optional and therefore it will be possible to select both the simple occurency of the word michael and the occurency of the word couple michael owen.

The second function is being an anchor. As we have already seen there are a lot of operators such as ^ and $ that could be keepers, they individuate inside a string a position. The question mark can be also used in the groups as a keeper, to individuate it as a position inside the text. Example:

• michael(?=owen)

The former regex selects the word michael in a text only if it is followed by the group (owen) that will not be selected. Examples:

• michael owen
• michael
• today owen scored a goal
• yesterday michael owen didn’t scored

You can also use the question mark to individuate the absence of a position. For example the following function selects the word michael only if it’s not followed by the group ( owen):

• michael(?!owen)

Example:

• michael owen
• michael
• today owen scored a goal
• yesterday michael owen didn’t scored

The two properties that we have just described works only when the anchor follows the text (or group or class) that has to be selected. If the anchor it’s placed before the selected text, we have to use two structure, the first one to verify the presence of the anchor, the second to verify the absence:

• (?<=owen) michael
• (?<!owen) michael

Basically the character < is inserted after the question mark.

For these reasons I have chosen the title of Grey Hat SEO: a grey seo, equidistant from the good and the evil, indifferent to both.

Let this be quite clear: I am not going to provide you with codes to develop spam engines, but I am going to use what I’ve learnt through these engines in order to provide you with theories and/or information that can be implemented both in white hat and black hat sites.

It’s up to you how to make best use of this knowledge and it’s also up to you to prove me wrong whenever you want to.

Enough of digressions, let’s start…

(please read slowly or you’ll have to learn about Markov Chains on Wikipedia)

Let’s suppose we are in a town of 100,000 inhabitants where everyone meets, during his/her life, only a certain number of people from that town, each of them at a different frequency. And let’s suppose that I am an inhabitant of this strange place and that one day I will meet by chance a good friend of mine called Giorgio.

It’s no neews, on the contrary, I have to say that I do meet this friend of mine very often, almost once a day to be precise. But today something has happened that does not happen very often: we met in front of a bar at 8am and there was no-one there. So we decided to go to Stefano’s place, a friend of ours, who lives not far away from this bar. I do not see him very often, but he does know him very well, he has known him for a couple of years and he says they meet up at least five times a week. Now that I’m thinking about it I have never happened to meet Stefano alone, the few times I’ve seen him Giorgio was almost always with us.

Anyway, we get to his place in a couple of minutes and ring the intercom, we are told to wait a little, Stefano is getting ready; also, he says we have to go and see a certain Stuart Delta, a friend of his who has just called a few minutes before, telling him he’s moving and asking whether he could help him. Stefano says hello, he says he will be ready right away and I ask Giorgio who this Stuart is. He replies that he has just got to know him, adding that he is a very good friend of Stefano’s, and they are almost always together and that the three of them go out every saturday night: he’s the person Giorgio sees the most when he goes out with Stefano.
But here comes Stefano, he says he’s sorry for taking so much time. We are told that Stuart lives just a bit further on and that it would be nice of us to help him moving.

We get to his place and a few minutes later Enrico, a very good friend of Stefano’s and Stuart’s, joins us: he has come to help. To my great surprise I find out that he is an old friend of mine and I tell him I was not expecting to see him there. He says “Hi” and asks me how come I am at Stuart’s and then, without waiting for a reply, turns around and shakes hands with Giorgio, introducing himself.

Markov chains base on one or more starting parameters (Giorgio and Me) to obtain one or more final parameters according to the probability the starting parameters are connected to the final parameter (Stefano): I do not know Stefano very well, Giorgio often sees him, I almost always meet him when Giorgio is with us: Me -/ Giorgio -/ Stefano.

Giorgio does not know Stuart very well, Stefano often sees him, that’s why he and Giorgio are meeting Stuart today, because, as I said, he is the person they see the most when they are together, so: Giorgio -/ Stefano -/ Stuart.

And this is why I have met Stuart today, because: Me -/ Giorgio -/ Stefano -/ Stuart.

And, finally, the fact that I know Enrico is not decisive for him coming to Stuart’s place. He actually did not even take too much notice of me. Giorgio had never met him, anyway.

And yet I might meet Jacopo tomorrow: a friend of mine, of Giorgio’s and Stefano’s. We might meet him just because we are together (Giorgio, Stefano and Me). Or maybe one day we decide to meet him, only Giorgio and Me. Or maybe I will meet him alone.

With a Markov chain, it is not necessary to have a certain number of starting parameters to obtain a final parameter. The final parameter, though, is likely to be generated by the starting paramenters, and the probability depends on these.

Just don’t worry if it’s not all clear, I will give more examples and as we go further into the issue you wil find out why it is interesting both for the Black Hat SEOs and for the White Hat SEOs.

Let’s now suppose we have a start set (it was the town in the above example) where the two following cases are established: an ordered relationship among the elements (in the above example it was: Giorgio and Me; Stefano and Me, Enrico and Me; Stuart and Me; Giorgio and Me; Giorgio and Stefano; Giorgio and Stuart; Giorgio and Enrico; ..), and an ordered relationship between an ordered subset of elements and one element (In the town example it was: [Me and Giorgio] -/ Stefano is different from [Giorgio and Me] -/ Stefano).

Also, let’s suppose that every kind of relationship is coupled with a frequency ranging from 0 to 1.

Example (forget about Me, Stefano, Giorgio and so on.. let’s now use letters only and let’s define a new type of relationship):

1. I -/ G = 1/2;
2. G -/ I = 1/3;
3. I -/ S = 1/7;
4. S -/ G = 1/4;
5. G -/ S = 1/6;
6. [G -/ I] -/ S = 1/20;
7. [I -/ G] -/ S = 1/10

As you can see now, unlike in the town example, frequency is based on the elements order, too. But don’t worry, let’s get rid of letters and give an example with words.

Let’s suppose we have a text document dealing with dogs. This document is our set, whereas the words composing it are the elements.

Each word in the document will be followed by another with a certain frequency (number of cases of the ordered couple divided by the number of cases of the first word). For example, the word the is followed in the text by the word dog with a frequency of 1/20, as there are 200 cases of the word the and 10 of the ordered couple the dog. I’ll make clear what I mean with ordered couple for those who haven’t quite understood it: the dog is a couple formed by the and by dog, but it is different from the couple dog the: in fact, the couple the dog can have a different frequency compared to the couple dog the.

Also, in our document every ordered couple of words is followed by another couple with a certain frequency, for example in our document only these words follow the ordered couple the dog:

1. is
2. white
3. Snoopy

The word is follows the couple the dog with a frequency of 1/2; in fact, there are 5 cases of the ordered triple the dog is in the document, out of a total of 10 cases of the couple the dog. The word white follows the couple the dog with a frequency of 2/5 and the word Snoopy follows the couple the dog with a frequency of 1/10.

Let’s suppose we know the frequency linking every couple of the document to each word of the document; we are talking about an ordered type of link. We will use this information in an array and will define a start couple, randomly chosen among all couples.

If we have a big array available we can get a fairly long and correct text, even if it’s nonsense to us humans.

Let’s suppose our start couple is the dog.

If we look for it in the array we will find out that it can be followed by 3 words (is; white; Snoopy), each of them with a certain frequency. One of these word is chosen at random (is) and we continue.

We now have the couple dog is, we look for it in the array and find out that it can be followed by 2 words (white, black). One of these two words is chosen randomly, based on the frequency (the word white is chosen) and we keep on with looking for the couple is white in the array …

Clearly, the text produced will be getting to a dead end in the following cases only:

1. look in the array for a couple not associated with any other word (if it exists, there is only one for each array)
2. look in the array for a couple A associated with a single word only and the second word in the couple forms a couple associated with one word only, and so on until you either get to a couple not associated with any word, or to a couple among those that necessarily follow couple A. In this second case, we are basically creating a loop.

Ok.. I have now explained to you what a Markov chain is, or at least I have explained them to you from the point of view of random text production. At this point spammers can stop reading. This is what my friends White SEOs might be interested in:

The question to be asked is: why do spammers use these texts? Because they are lazy? Or just because they want to reach many rankings right away and for many keywords without having to write the contents?
Sure! 99% do it for that reason, but the rest 1% is wondering: why do search engines “like” these texts?

My idea is that these texts, if they are produced correctly, can interpret the trend of a SERP both from the point of view of the topic and of the language. This way, they climb up the very SERP, because search engines consider them appropriate.

This kind of pages may be considered as a good feeler to roughly comprehend what is the trend of a SERP and to understand how to create clean pages based on the results of the Markov pages.

Ranking processes most likely rely on the mathematical/geometric idea of similitude. Therefore a search engine will consider appropriate a page that is similar to all the other pages that have been considered interesting inside a certain SERP and a page that is, at the same time, different from each one of these pages, as much as the copyproof filters are overcome.

It can be deduced that Search Engines Trend can actually exist, at least as an ideal model a web page tends to, determining its ranking in a certain SERP.

Therefore, it should come natural to talk about traffic and links, but I prefer to surprise you and divert the topic onto somenthing less visible, less tangible and perhaps, something existing only in my perverse mind: search engines trend.

Let’s start right away, with a little example.
Let’s suppose we are today creating a site dealing with a nonexistent subject and basing on nonexistent keywords. Even though Google is not a semantic search engine, it generally attaches a correlation between keywords of the same sector in order to understand what a site is talking about and whether this site has the right or not to be at the top of a certain SERP. It is basically the same principle of query expansion that has been discussed for a while. Giorgio Taverniti explained it very well , not very technically perhaps, but in a way that is clear to unexperienced SEOs, too. It should be specified, though, that query expansion is not a tool meant for SEOs, it is rather a tool allowing search engines to correlate more topics.

As in the case of BackLinks, the existence of both a visible correlation (the one we get by using the code ~ before the query) and an invisible correlation is likely to be supposed. In any case, both the former and the latter must establish the pertinence degree a web page has, compared to a certain query or at least compared to a certain subject.

Just to avoid empty theories and provide some tools useful for ranking, I recommend to all query expansion lovers to use clusty.com. For those who don’t know what I am talking about, clusty is a search engine basing on keyword clustering. Therefore, unlike Google & Co., it stands a bit closer to a semantic search engine, at least as far as the consistency of its results is concerned.

I personally use this search engine for query expansion. I will now explain how to do it, but, since it is very simple, I reckon you will grasp it immediately. Search for the keyword you are interested in with clusty.com (for example, I am searching for the word Fashion) and look to your left. Clusty will provide a list of Topics, believed to be correlated to that specific query.

In my case, it thought appropriate to correlate the query fashion to the following keywords (Subjects):

• Fashion Week (32)
• Clothing (35)
• Magazine (27)
• Photography (22)
• Beauty (18)
• Schools, Design (14)
• Women’s (11)
• Models (11)
• Fashion industry (10)
• Dress (9)

Every Topic can be expanded and the related keywords can be further extended: we are talking about a very useful tool, if used properly and especially if used together with a tool for Keyword Suggestion as the SEO Book and the classical dictionary of synonims and antonyms.

So, now that I have provided you with something practical you can use as you like, let’s go back to the main topic: what does this have to do with Search Engines Trend?

In the first example, you were told to assume you are creating a site dealing with a totally new subject, with new keywords and a slang slightly different from the one used by other sites in the same language: it is possible to think that this first site will affect the Trend of the new SERPS it is creating, by suggesting to the search engine the opportunity of correlating certain keywords with others belonging to the same sector.

Therefore, it is possible to suppose there are algorithms whose task is managing Search Engines Trend. Likewise, we can also assume it is these algorithms that provide Google with much information, such as information about topic, language and “level of spam“. We are talking about information created both onPage and offPage, through both page contents and the links to the page. In other words, the idea of language, topic and spam are not stable in the search engine, they actually may undergo a slight change through onPage and offPage factors. So, after the creation of the word SEO, this term is now part of various languages and certain subjects such as: marketing, google, msn, yahoo, webmaster, internet, blog and so on.

What I am stating is that a search engine should not be thought of as a classifying tool based on a certain idea of language, topic, and so on. A search engine is a tool undergoing deep changes, as Trends change. So for example developing new technologies may upset your SERPs because it generally involves both an interest shift and the development of new related terms.

Besides: The flapping of a butterfly’s wing in Brazil can set off a tornado in Texas.

In this article, I aim at explaining to myself and to those who follow me what I think about passing on information, and I would like to stress that I will be analyzing only how it is connected to links. Therefore, I am not going to talk about all other information useful for search engines, such as: whois, structure and traffic.

Links are crucial both for the SEO (in their mind the idea that links give the site a boost is inculcated ever since they were children), and for the search engine. Through this system, the engine can get to know the different aspects of one site, simply by connecting it to the different sites it is linked by and to the sites it links to.

However, the link is not not be considered as a mere boost, as it is a sort of vectorial container of information. It does make more sense to think of it as a Complete Force (needless to say, as Forces always have this nature, despite the average SEO being convinced of the contrary), a force featuring magnitude, direction and orientation.

Let’s suppose that every link is determined by these three factors only and let’s see how links are far complexer than one would think.

We shall define the magnitude of a link as the value indicating the boost it will have on the linked page; we shall define orientation and direction as what links head for in a multidimensional space.

It does not matter what these dimensions actually are in the search engines (they may be languages, topics or other things). Now what matters is that we understand that any link has a boost determined by magnitude, but it also features a direction and an orientation this magnitude is applied to, moving our object (the page) towards a specific place.

As SEOs, we do not want to just move the page, but we do want to move it aiming at a specific target.

So, only by considering the link as a force endowed with magnitude, direction and orientation, it is possible to sense 3 main ideas:

1. Linking a page in order to reach a good ranking is not enough, it is necessary to give the link a specific direction and orientation, otherwise we may end up further away from our goal.
2. An absolute penalty for search engines does not exist, but relative penalties do exist: that is, penalties due to failure to reach a goal. Introducing a link that moves us towards the wrong direction is a relative penalty, as it moves us further away from the goal we had targeted, but it does take us closer to something else. Nevertheless, this “something else” might be not only totally useless to us, but even harmful.
3. Also, it is clear that the “penalty” is not due to the magnitude of the link, but to its direction. In order to reach our goal, the direction we are heading for is more important than how strongly we are heading for that direction.

The task of a skilled webmaster is not to link a web page, but to understand where the link will take us.

Now forget about links as vector forces. I’ll make myself clearer: what search engines use is probably the idea of links as vector forces, but restricting ourselves to that might be counterproductive. What currently matters to us most is the information behind links, rather than their mathematical side.

So let’s concentrate on the links and continue to define them as vectors, but devoid of direction and orientation: vectors featuring magnitude and information only.

Magnitude is, as usual, the simplest side and it is always possible to define it as the boost a page gets.

The information content, on the contrary, becomes our direction and our orientation and indicates where we are moving to.

As many of you know, the information I prefer to talk about is language. This is in fact the information we can be more easily aware of, for example by doing a simple test such as that by Tagliaerbe [Link in Italian]. It is generally easy to experience that a page with a context in language A, linked mainly and massively by pages with contents (and/or BackLinks) in language B, will be considered by the search engine as a page written in the language B. Also, it is clear how this is not an absolute penalty, but rather a penalty relative to our goal. This is due to the fact that, in general, the goal of all sites in language A is to rank by the term in language A and, above all, in the search engine in language A, whereas being ranked by terms in language B is totally useless to these sites.

However, this is not due to the search engine. It is our fault for having passed the wrong information.

A different type of information considered by the search engines and passed on (also) through links is the topic. The topic characterizes our page and it brings it closer or moves it away from specific keywords. I doubt whether there is much to be said about this, as it is very easily understood what is the interest that connects this information to the search engine. It is perhaps more difficult to understand how the search engine manages to determine how close to or how far from a certain topic we are.

As far as this is concerned, I only have vague theories, therefore I suggest you don’t trust what I’ll be saying and I hope someone will provide a better explanation.

I believe all information passed on through links is organized in a multidimensional space that considers the page as a point in this space. Therefore, a single piece of information does not exist, for example:

1. Language: English
2. Topic: cooking

More probably, information composed of all possible entries and of the extent to which each entry is true does exist (through Fuzzy logic).

The objection that may be raised in this case is:

if the logic of search engines is not boolean but fuzzy, then why do links in english to an italian page make it lose positions in italian search engines? These data on the italian language, in fact, do not get lost, neither are they less than before: so, if my page was at the first place on a SERP and had 50 italian links and 0 english links and it is now at the 57^th place in the SERP and has 67 italian links and 565 english links, why has a “penalty” occurred? My page is not less italian than before, it is only more english!

Remembering that I do not know the truth about these issues, I will suggest my theory: the language factor is composed of weights that are distributed in proportion to the main language. So, in the above example, it is true that the web page did not lose any italian links (on the contrary, it has got some more compared to before), but these links move the page more to the english sector and away from the italian one, due to their being less than the english links.

The same thing happens in the case of the topic.

There is more information passed on through the link: the information usually defined as the trust of a site that basically gives a consistency value both to the site and to us when we are linked.

I am definitely lacking knowledge on this subject, but based on the opinion I formed, the trust may very well be passed on as a single fuzzy value and not as a value composed of the different information contents that have created it. This value, however, will contain all those data defining the consistency of a site and moving it closer to or away from spam, that is information about whois, structure and probably traffic.

I’ll better be talking about those next time. Also, I will be talking more in detail about the Graph theory: I preferred not to mention it, despite being strictly connected to the ideas expressed in this article, as it is not crucial for defining the link as information passing on, but it is essential in passing on the information.