Thankfully in answer to the question of whether a stable matching exists, we have a theorem that guarantees exactly that! It states that:
“For any number entities of two disjoint sets (having equal number of elements), no matter how they rank each other, there always exists at least one stable matching”

While the solution is stable, it is not necessarily optimal from all individuals’ points of view. The traditional form of the algorithm is optimal for the initiator (suitor) of the proposals and the stable, suitor-optimal solution may or may not be optimal for the acceptor of the proposals. It will be acceptor pessimal.

To find the solution, we have the Gale-Shapley Algorithm. In 1962,  David Gale and Lloyd Shapley proved that, for any equal number of suitors and acceptors, it is always possible to solve the Stable Marriage Problem.

The Gale-Shapely Algorithm:
Each suitor proposes to his highest preferred acceptor. If the acceptor is not already matched, we automatically match suitor to acceptor. If the acceptor is previously matched; acceptor picks the most preferred suitor. The rejected suitor moves on to his next preferred acceptor. When each suitor is matched the problem is solved.

Download

Download source code. It is an implementation of the algorithm in .NET 4 using Visual Studio 2010 and C#.

/Here Optimal Entity is the Suitor and Pessimal Entity is the acceptor
//The function that implements the Gale-Shapley algorithm in .NET is shown
public static SortedDictionary<T,U> Match(HashSet<SuitorEntity<T, U>> optimalEntities, HashSet<AcceptorEntity<U, T>> pessimalEntities)
        {
            Dictionary<AcceptorEntity<U, T>, SuitorEntity<T, U>> matching = new Dictionary<AcceptorEntity<U, T>, SuitorEntity<T, U>>();
            Stack<SuitorEntity<T,U>> processStack = new Stack<SuitorEntity<T, U>>(optimalEntities);
            while(processStack.Count>0)
            {

                //Store each suitor in a Stack.
                SuitorEntity<T, U> suitorEntity = processStack.Pop();
                // Match the optimal entity to its first preference
                //If its first preference is not previously matched then automatically match and dequeue
                SuitorEntity<T, U> matchedEntity;
                AcceptorEntity<U, T> acceptorEntity = suitorEntity.Preferences.Dequeue();
                if(!matching.TryGetValue(acceptorEntity,out matchedEntity))
                {
                    matching.Add(acceptorEntity, suitorEntity);
                }
                else//Else
                {
                    foreach (SuitorEntity<T,U> entity in acceptorEntity.Preferences)
                    {
                        if(matchedEntity == entity)
                        {
                            //The Pessimal Entity makes a choice: If it already has a better preference then it keeps it
                            processStack.Push(suitorEntity);
                            break;
                        }
                        // Replace the matching of the acceptor with the most preferred new suitor
                        if (suitorEntity != entity) continue;
                        matching[acceptorEntity] = suitorEntity;
                        //Push the previously matched suitor who is now rejected on to the stack for further processing
                        processStack.Push(matchedEntity);
                        break;
                    }

                }

            }
            SortedDictionary<T,U> result = new SortedDictionary<T, U>();
            foreach (KeyValuePair<AcceptorEntity<U, T>, SuitorEntity<T, U>> keyValuePair in matching)
            {
                result.Add(keyValuePair.Value.Entity,keyValuePair.Key.Entity);
            }
            return result;
        }

References

Interactive Flash Demonstration of Stable Marriage Problem

First let me start with basics (more advanced (jaded ) readers can skip this paragraph). A social network has two facets: Structure and Behavior. When we talk about a network, we typically talk about how we are connected to others in the network and also how ‘connected’ we are at the interaction level. Graph Theory is the language of structure, whereas Game Theory is the language of behavior for social networks. A structure is a snapshot of a social network at a particular instance of time. Behaviors define how the structure gets transformed over a period of time. Behavior is the dynamic part of social networks. One might think, that behavior is the cause and structure the effect. But at scale, structure also influences behavior and behavior in turn influences structure, forming a virtuous (or destructive) cycle. A structural model has big implications on the underlying data structures that store and manipulate data. So getting this model right is a fundamental step.

Current Models

In this post, I would like to propose a model for the structural aspects of a contextual stream. Model is a representation of a system or phenomenon. In computer science, a model is used to simulate a process, concept or operation of the system. My premise is that the existing models are no longer sufficient to explain or operate the system. A system is only as good as the model. History abounds with examples where our models were wrong. We moved from “earth is flat” to “earth centric model of the universe” to “Helio centric model of solar system”. Each revision in our models brought about great progress.

The design constraints faced by us today in social networking is similar, because we are limited by our existing models. Before I proceed with a revamped model for the structure of a social network, let me go over what we have today.

A social network is modeled as a graph of ‘friends’. An extension to this in recent years is an affiliation network super imposed on a traditional network of friends.

Traditional way of modelling friendships in social networks

The rise of groups, lists, circles are an example of this. An affiliation network is modeled as a bipartite graph.  A bipartite graph by definition connects two disjoint and independent sets. I took some of my groups from Linked In for illustration purposes.

Groups, Lists, Circles model of social networks

These two structural models served our purposes till now. The affiliate model came about to serve the need to form communities around shared interests. Accessibility is the only difference between a group on Linked In and a circle in Google +. A circle is a private classification , whereas a group on Linked In is public. (Note: I removed the connections among ‘friends’ to  make the model uncluttered)

Contextual Model

A contextual model is a network of ‘contexts’. Here we model our ‘friends’ as contexts too !!!. We can imagine that circles, lists and groups are an attempt to set context. So in effect all circles, lists and groups are contexts in which our social posts reside. By definition public is an over encompassing context. It is a set of all possible contexts. Now the key insight is to model our friend connections as contexts. If you think about it, when we post to our friends, we are implying a context. Ergo it is true of lists and circles. A friend is a circle (list or group) which contains one member. Once we model a friend as a context, then we can use the same language of graph theory to divine better and more information about our connections and the context in which these play out. Historically affiliations are modeled right after friends, in a typical product iteration cycle. So engineers instead of going back to the drawing board, tack on the affiliations. What I am proposing is to revisit our current models and make context the fundamental unit of a social network.

Modelling contexts as a fundamental unit of social networks

This is just not a jumbled ‘affiliation’ network. There are two key differences, each ‘friend’ is a context (on par with the groups) and the presence of links between groups (Circles) – shown as dashed lines.

Till now, we have viewed these ‘affiliations’ as existing ‘outside’ the network. With the conceptual model we put affiliations, friends and any other ‘contexts’ in the network as nodes. Using such a formulation, we get additional insights by observing the co-evolution of contexts and friendships by treating them through a common framework. Theoretically a context can be anything. For e.g. it can be location (check in features), interests, causes, deals, alumni groups, affiliations (as shown above) etc, all unified in one. (To be totally facetious, I am calling it “The General Theory of Social Networks”   )

Why this is important and powerful, needs a little bit of explanation and theoretical exploration. It has got to do with Closures and Hypergraphs.

Closures

Closure is the “act of closing”. It is the primary mechanism through which PYMK (People you may know) feature is implemented. Closures imbue social networks with the ability to grow organically. In literature there are three types of closures which have been extensively studied: Triadic Closure, Focal Closure and Membership Closure.

Each closure above corresponds to the closing of a triangle in social-affiliation networks

Here focus corresponds to a group, interests, lists or circles.

Triadic Closure

If two people in a social network have a friend in common, then there is an increased likelihood of they becoming friends themselves at some point in the future. If A and B have edges to C, then there is a high probability that an edge will form between A and B. PYMK feature is based on this principle of triadic closure.

Focal Closure

By introducing affiliations in to the network, focal closure comes in to play. If two people have an affiliation (focus) in common, then there is an increased likelihood of they becoming friends. If A and B are members of  C, then there is high probability that an edge will form between A and B. This has intuitive appeal, as by their membership of C, they have indicated that they share common interests and passions. So it is advantageous for them to be friends themselves.

Membership Closure

If two people are friends and one of them is a member of a particular affiliation, then it is quite likely that the member would introduce his friend to the group and in turn becomes its member. That is membership gets ‘closed’ as result. More formally, if A is a friend of B and B is a member of C, then there is high probability that A will also become a member of C in future.

Contextual Closure

We do see all of the above closures happening today on social-affiliation networks. But there is one more closure, that is yet to happen. This is not a new type of closure, but an artifact of modelling contexts as fundamental units of social networks. This type of closure is the ‘general’ solution to all of the above. If all three contexts are people, then it becomes triadic closure. If one of the contexts is a focus (or group/circle/list), then it can become either a focal or membership closure (See above).

The interesting thing that happens above and beyond this is the case when we operate on three contexts. Either two of them are groups and one person OR all three are groups.  In the case of two groups, nothing can be gained by an individual instance of a person belonging to two groups. Interesting things happen, when we see the results in aggregate. If a multitude of people contexts are members of two separate group contexts, then we can safely predict that either these group contexts will merge in to one or will have a ‘connection’ to each other. If all three are group contexts and one group context is linked to two other groups, there is a high likelihood of triadic closure happening on group contexts.  Also there is an increased likelihood of focal and membership closures happening on people contexts contained within the group contexts.

An artifact of modelling everything as a context

This brings us to the point, where we understand how contextual modelling helps us achieve greater and more organic growth of social networks. Since it is more contextual it is more valuable to the end user as well as the social network. More information can be mined and more ‘intents’ can be readily perceived. The forcing functions of selection and social influence are amplified to a great extent. I can only wonder, if we pull this off at scale, it would be a gold mine of hidden motivations and real social behaviors. From a computational stand point, we only need one common language to handle all the nodes and edges in the network. We can co-locate ‘disparate’ data in one storage model, since they are all contexts. This greatly simplifies data mining and querying capabilities. Each new node and edge adds more context, like pieces of a puzzle, the later pieces provide ‘global context’ for solving the whole puzzle.

Our existing 2 planar network will not suffice. With the explosion of contexts and the fact that a context can belong to other contexts, it would soon become just data and no information. We would need a mathematical structure that underpins this form and help us navigate the contextual social network. The traditional two vertices connected by an edge will not be enough. So what can replace this? What kind of data structures can support this? It should be robust and computationally solid. Also the new solution, keeping the central theme going, should also support current investments as well as provide a solution to n-planar networks. What this means is that 2-planar network model should be a an instance of a more general solution. Enter Hypergraphs!!!

Hypergraphs

In mathematics, a hypergraph is a generalization of a graph, where the edges can connect any number of vertices. Formally, a hypergraph H is a pair (X,E), where X is a set of vertices (nodes) and E is a non empty set of subsets of X, called hyperedges. So E is a subset of P(X), where P(X) is a power set of X.

A hypergraph with all hyperedges of cardinality 2 is a graph as we know it. More generally we can define a k-uniform  hypergraph as a hypergraph, such that all its hyperedges have size k. So a graph is just a 2-uniform hypergraph, satisfying our requirement of fitting current models, while enabling us to extend.

Hypergraph traversals are very important in the fields of machine learning, data mining, game theory etc. It is too vast a subject to explore in this post.

Conclusion

In conclusion, we can see how moving to a contextual model, helps us immensely, both from a conceptual as well as computational stand point. Better models and underlying mathematical structures will force streams in to the next evolutionary phase. Of course there is a lot to do on the UI/UX side to make all of this intuitive to the end user. But I suspect that it would be easier than the contortions that the users go  through now. Modelling behavior is another beast that we need to tackle sooner than later. Current behavioral models are quite complex and I would imagine a contextual behavioral model would be even more so.

As always, please let me know if there is any work in progress in this direction somewhere. My limited search abilities did not uncover anything of substance. If there is anything at all, I am sure it is spread out in different fields, areas and silos. The need of the hour is to bring all of this to the main stream.

I have some experience in dealing with this problem. Till recently I was an architect on the stream team @ myspace. What was lost in all the noise of myspace’s fall from grace, is the cool stuff that was done by engineers there. Quite early in the design phase of ‘futura’ (redesign of MySpace to my___ )  , we were tasked with solving two major problems: Relevance and Stream clogging (now known as Scoble effect!). These are still unsolved in the sense that there is no universal or elegant solution. There are solutions which achieve the results to varied degrees. It is still an open problem.

Evolution of Man

Before I layout a proposed solution, let me talk a bit about Stream Evolution. Each evolutionary phase builds on top of the previous. Like evolution, each phase was born out of a need to survive the changing landscape of user needs and adoption. The frustration of users is valid in the sense that we want our machines to anticipate and mimic our real life. Our online world should reflect our offline world. Circles of g+,  Groups of facebook, follow model of twitter are all different facets of human behavior (among others).  From my perspective (Origin of Streams ! ) every stream product follows an evolutionary path:

Chronological Stream (CS)

This is the classic stream solution, where we show the activities based on a reverse chronological order. Newest ones first. As activities occur, we store them. Then based on a user pull, we display a paged view of the activities. This worked for a while as the amount of data was manageable. We could fit all the information in a few ‘pages’ which could be traversed easily. This was a single dimension solution

Categorized Chronological Stream (CCS)

CCS came about when the number of activities increased by an order of magnitude, since humans have a limited capacity to consume at one go, CCS attempted to divide it in to smaller pieces. It was an answer to the question: “How do you eat an elephant?” Answer: In small pieces. But the need was to be categorized rather than partitioned based on date time. So a solution was devised to categorized based on an extra dimension of ‘friend lists/groups/circles’.  The user is given an option to filter the stream by groups of friends. This gave them the ability to consume only those parts, which interested them at that particular moment in time.

Bucketed Chronological Stream (BCS)

BCS was built on top of the previous two, by providing the ability to consume by ‘type’. It evolved to satisfy the need to consume in three dimensions: Date, Groups and Buckets (In this context buckets refer to media types). For e.g. a user wanted to see all Videos shared by friends (all or a select few), or see only photos, events etc. The need and the forcing function here was, the user knew what type of content to consume, but was not sure when and who provided it in the first place. It enabled discovery for the first time.

Real Time Stream (RTS)

RTS was the answer to the problem of immediacy. Users wanted their data now! It was push based model, instead of  pull. Yes this evolutionary phase incorporated all the advantages of the previous phases. Now the stream was a fast flowing stream, a flood!!!. The innovation here was only in how to scale the infrastructure. Each solution in this phase had variations on solving scaling for more and more data. Twitter’s scaling problems come to mind. But more importantly user’s were not satisfied. They had this nagging feeling that they might have missed something interesting. So the solution joined the advantages all the above phases.

Aggregated Stream (AS)

AS was an answer to RTS’s inherent weakness of missing something important. The solution was to aggregate activities by type so that we can fit more data in a small space. The evolution of thumbnails, profile pics are a manifestation of this. This enabled one to increase the amount of data per screen item. The solution was limited only by the amount of data that we could aggregate in a specific time window. If a user uploaded 20 photos, we don’t need to show 20 single items, but as one item. The item itself contained jump off points for the more interested consumer. Aggregation is not trivial as it is often confused with collection. A collection is a special case of aggregation. Aggregation can span across multiple dimensions for e.g. Multiple friends + Same Type, Same User + multiple types etc. Adding the dimension of date adds more complexity to it.

Asynchronous Interaction Activated Stream (AIAS)

AIAS can be considered as parallel evolution. AIAS solutions are based on the premise that, any interaction that occurs on a piece of content in the stream needs to be resurfaced to the top as it is fresh. More the interaction, more it can be thought of as new content. Here the content that is added, is the interaction event itself. It is asynchronous as interaction can occur out of band. Different users will see the same piece of content at varying levels of sort order. The premise is also that if it is interacted most, then it must be relevant to all users. AIAS works only when there is a fast flowing stream, otherwise you would see duplication in the same view.

Till now we have see how we moved from Caveman phase (Chronological) to Agricultural phase (Categorized, Bucketed), to Industrial phase (Real Time), to Information phase (Aggregated, Asynchronous Interaction).  We now examine the Digital phase of Relevant Stream and Diversity Infused Relevant Stream.

Relevant Stream (RS)

Relevant stream was an answer to the exponential data rates that we are encountering. None of the previous evolutionary adaptations could handle this. Even with better infrastructure, better  and more hardware, it was realized that there is no chance of survival. As more and more companies were competing, the need arose to differentiate. My contribution was to come up with a relevance algorithm for real time streams. Since it is patented (Inventor: Me, Owned By: Myspace), I can only discuss the high level heuristics of any solutions that belong to this family.

Essentially any relevance solution comprises of tracking a bunch of signals, normalizing them and folding the resulting values in to a relevance metric. This relevance measure can then be used to sort the list of activities. Then we take the top n of the list and display to the user. We can combine the features of the previous evolutionary phases to improve the throughput.  There are as many implementations of this approach as are companies. One more key heuristic is the use of serendipity. We introduce a random element to promote discovery. Otherwise, we will have the case of “rich getting richer and the poor getting poorer”.  We would never discover new items. The same old people keeping showing up. Scoble effect is a prime example of this. Virality comes in to play because of serendipity. In fact nature by and large is a successful system, as it includes serendipity as a fundamental design principle. Relevance at first blush is a great solution. You would find an initial improvement in user satisfaction and then as more prolific/enterprising users ‘discover’ or ‘uncover’ the signals/algorithms, it is prone to gaming. If we can determine the signals, we can simulate behavior that games the relevance algorithm. We see examples of these in nature too. Insects having ‘big eyes’ on their backs to scare potential predators, camouflage etc. So no system is impenetrable or opaque. At best we can have a first movers advantage. If one doesn’t evolve it will soon be extinct.

Diversity Infused Relevant Stream (DIRS)

DIRS came about to make relevance and serendipity more effective. I might want to see at least some of my less frequent friend activities, than more of a prolific friend. I would trade the excess of something with what I have less of. In case of Scoble effect (Stream clogging), I neither want to turn Scoble off or keep him fully on. I want just enough!!!! Now just enough is not something that computers understand. We need to map something that is fuzzy to binary. There are of course many variations on this theme. There could be a facility to mute or volume control. But it soon becomes a pain to manage. We don’t have any visual cues to help us. It is always trial and error and that makes a lot of people uncomfortable. I went with a simpler guiding principle. Like previous (regarding relevance patent) I cannot discuss the entire solution, but I can share the guiding principle behind diversity algorithms, which are in the public domain.

Definitions:

If there are two users u_i  and u_j  connected to user C. Define Candidate(U, p) as the count of number of items from user U in pool p.  Define Count(U) as the number of items from user U displayed in C’s  stream.

Guiding Principle:

Stream Diversity: if Candidate(u_i , p)>0, and Count(u_i )= 0, then Count(u_j)≥ k  until Count(u_i )≥1.

Outcome:

If there is an item from u_i then we  should show not more than k items from u_j unless we also show at least one item from u_i.

This diversity has been shown to increases  ’perceived’ relevance. Diversity underpins system level robustness, allowing for multiple responses to external shocks and internal adaptations;  it provides the seeds for large events by creating outliers that fuel tipping points; it drives novelty and innovation.

We use an algorithmic way to simulate the real world. Like all simulations, it is only an approximation of reality. If we look hard we can perceive cracks where reality seeps in. The famous Red Pill or Blue Pill scene from Matrix is a good metaphor.

Improvements in these areas are possible by increasing diversity. Here too we would reach an asymptote soon. We also need to watch out for diversity turning in to randomness and chaos. The good news is we haven’t reached the plateau yet. More can be done in this area. My small contribution not withstanding, I believe we would see more innovation in this direction.

Situation as it stands today

Most, if not all streams are at this point in evolution. But I could be wrong. I am not privy to the inner workings of companies. My observation is based on what I see and guesstimate the evolutionary phase. So what else can we do to trigger the next evolutionary phase? Is there a theoretical limit to what can be achieved? Can a truly relevant/diverse system be designed?Can the holy grail of absolute relevance be achieved?

These are the questions that I struggled with. Then inspiration hit me! Nature abounds with solutions to hard problems. How can small insects like ants and bees be successful species? They perform complex tasks which are disproportionate with their brain capacity. Of course this is nothing new. There is research going on Nature inspired Computing, Artificial Intelligence, Computational Intelligence, Bio Mimicry, Neural nets etc.

What we need is to apply the insights from these fields on to human consumption behavior. The nearest system I can think of is the foraging behavior of ants. If we feel too uncomfortable with that, let me say we are like bees: social, intelligent and actually do a dance to communicate!!!! (waggle dance).

If you want a taste of these algorithms, you can start reading on my blog Clever Algorithms in Python .

Though we have not seen the next evolutionary phase, we can at least describe the shape of what it would be. I would hasten to add that like biological evolution, extrapolation would be widely inaccurate. For e.g. if we as an observer went back in time to dinosaur age, would be predict the evolution of humans or more grotesque creatures straight out of a Alien movie?

All is not lost though. I can safely venture to say, that we can predict the next nearest evolutionary step with a fair degree of accuracy than the shape of evolution many steps away….

So let us start. Please note this is only my opinion and like I said could be totally wrong.

Context Based Adaptive Stream (Contextual Stream)(CBAS, COS)

I would like to propose that the next evolutionary step would be the rise of Contextual Streams. Some key characteristics would be natural serendipity, redundant systems, scale invariant, adaptive and sense making. The idea is to provide a non deterministic view to every user. Each user sees a highly customized view specific to him. Even more, this view is not deterministically customized by the user, but organically grown. Think snowflakes, than manufacturing toasters. Each action of the user simultaneously determines the future as well as the ‘past’. You might say, how can the past change? Keep in mind, ‘past’ is only a representation made by us. Individual facts cannot be contravened, but the way we combine them could produce new meaning, in light of the present facts!!!!

Without degenerating this in to an Issac Asimov narrative, I would like to conclude that a lot of emergent systems theory, complex adaptive systems and nature inspired algorithms would definitely be a part of the solution in some form.

In part 2 we look at the following Stochastic Algorithms: Iterated Local Search, Guided Local Search, Variable Neighborhood Search, Greedy Randomized Adaptive Search, Tabu Search and Reactive Tabu Search. This completes Stochastic Algorithms.

We apply the above algorithms to the Berlin52 instance of the Travelling Salesman Problem. The solution attempts to find a permutation of the cities (called a tour) order that minimizes the total distance traveled. The optimal distance for Berlin52 TSP is at 7542 units.

Download

Download source code. Unzip and import the attached folder in to your Eclipse workspace. It includes a test suite for exercising the algorithms

Iterated Local Search

We use Stochastic 2-opt move for doing local search and the double bridge move for creating a ‘perturbation’. The idea is to escape the local minima by going to neighborhoods which are beyond the local search method.  Advanced usage of ILS takes in to account search history for perturbation and acceptance criteria. I tried to keep the code as near to the pseudo code as possible. This would enable one to understand the algorithm and incorporate search history. Search History can be used to either ‘intensify’ or ‘diversify’  (or a blend) the candidates in the search space. The way I have used is to intensify the search using  a ‘search history’ of ONE.

Variable Neighborhood Search

Variable Neighborhood Search explores larger and larger neighborhoods of a given local optima until an improvement is found. After an improvement is found the search is repeated on expanding neighborhoods. This strategy is based on the following three principles:

A local minimum for one neighborhood may not be the local minimum for for a different neighborhood.

A global minimum is a local minimum for all neighborhoods.

Local minima are assumed to be clustered for many problem domains.

One can see these three principles in action, by repeatedly applying the stochastic 2 opt move in a given neighborhood, doing the same at a larger frequency for the embedded local search heuristic and expanding the search to other neighborhoods when we reach a local optimum.

Greedy Randomized Adaptive Search

GRASP is related to ILS in terms of identifying candidate solutions which are ‘greedy’. This is achieved by constructing a Restricted Candidate List (RCL) which are used to penalize solutions. We start of by constructing a greedy candidate solution and then use a local embedded search to refine the result.  The greedy solution uses a factor ‘alpha’ to control how greedy we need the solution to be. By increasing alpha [0,1] our solution becomes generalized, whereas alpha near zero are more greedy. The approach is to select each ‘feature’ (here a feature is the cost of adding a point to the solution), is within a certain distance from the minimum cost. The code listing that is provided contains extensive comments, which explain in more detail.

Guided Local Search

GLS uses a scaling factor to calculated an ‘augmented cost function’ which is used to restart a search. The augmented cost function is specific to the embedded local search. The main search procedure is oblivious to this function. The aim is to diversify, so that we can escape local optima.  See code listing for more details.

Tabu Search

Tabu Search maintains a tabu list of edges that have been rewired in stochastic 2-opt move. This is used to prevent the generation of candidate solutions from revisiting already visited paths (called cycles). By preventing cycles we search a broader candidate space, there by converging to the global optima faster.

Reactive Tabu Search

Reactive Tabu Search is an extension of Tabu Search. Here we monitor the search and react to occurrence of cycles, by increasing or decreasing our candidate space. This algorithm is the most involved in terms of use of certain heuristics for prohibition period, repetition interval etc. The intent is to diversify the search once a threshold of cycle repetitions is reached. The aim here is to ‘react’ to the search direction and change it.

Note: The descriptions are purposely kept short, to encourage delving in to the code itself. I would recommend reading the pseudo code provided in Clever Algorithms and follow my code along. I went out-of-the-way to keep my code similar to pseudo code.

Visualization of Stochastic 2-opt and Double Bridge Moves

Stochastic 2-opt Move : Original tour on the left and resulting tour on the right

Double Bridge Move : The four dotted edges are removed and the remaining parts A, B, C, D are reconnected by the dashed edges.

Stochastic Algorithms are primarily global optimization algorithms. A stochastic process is one whose behavior is non-deterministic. The system’s subsequent state is determined both by the process’ predictable actions and by a random element. The main strategy (with some exceptions) are based on sampling the search space, calculating the ‘cost’ and using that to improve on the result. This can be either through a random process, changing search direction or step size. There is no ‘inspiring’ system, either natural or biological on which these are based.  The first part details the implementation in python of four algorithms: Random Search (RS), Adaptive Random Search (ARS), Stochastic Hill Climbing (SHC) and Scatter Search (SC).  Out of these except for Stochastic Hill Climbing , the remaining three use the same objective function for calculating the cost.

The objective function I chose for RS, ARS and SC was a variation on the one provided by Jason. He used a function that was a ‘sum of squares” , I used a variation that would provide a non trivial solution value, while keeping the structure of the function the same.

Objective function used in Clever Algorithms

Objective Function that I used

The optimal solution (minimum) for  my basin function can be found at the value -10. The input value would be 2.

For SHC I used the same ‘One Max‘ Problem from the original Clever Algorithms book.

Download

Download source code. Unzip and import the attached folder in to your Eclipse workspace. It includes a test suite for exercising the algorithms

Random Search (RS)

Random search has no memory of previous search candidates. So it might revisit previously considered candidate solutions. The advantage is, it is a minimal solution. Its worst case performance is worse than a straight linear approach. But it has its uses in a domain where the values are continuous. Most commonly it is used as an embedded heuristic in other search algorithms for refining a local optima. It is one of the building blocks for other more advanced search techniques.

Adaptive Random Search (ARS)

Adaptive Random Search seeks to avoid the problems of localized random search by sampling with larger or smaller step sizes. We keep trying larger step sizes as long as we have improvement in the result. We go back to smaller step sizes if we don’t see an improvement in the result after a preset max count. The initial starting point is selected similar to that of RS.

Scatter Search (SC)

Scatter search is a global optimization algorithm, which has some Evolutionary computation features. The premise of SC is that the desired result is present in some combination of a diverse set of high quality candidate sets. By combining and recombining the values from a reference set of elite solutions to create ‘offsprings’. We then test these offsprings for best values by applying the objective function to them. We use an embedded heuristic of RS for refining a local candidate solution.

Stochastic Hill Climbing (SHC)

Stochastic Hill Climbing iterates the process by randomly selecting a neighbor of a local candidate solution and evaluating it. It is an improvement on RS, where we don’t sample randomly, but near neighbors of randomly selected candidate solution. I noticed an error in the code listing provided by Jason Brownlee. Specifically on page 40 last line. ( mutant[pos] = (mutant[pos]==’1′) ? ’0′ : ’1′ ) . It should instead check for ’0′ and replace it with ’1′. I believe it is a typo in the book. I also tried to evaluate the search efficacy for the OneMax problem. Since the idea is to replace all zeros in the bitstring with 1. A search efficacy metric can be defined as (FinalOneMaxCount – InitialOneMaxCount)/finalIteration. If we set our max iterations to the length of the initial bitstring, we get a nice metric for measuring the search efficacy.

Visualization of the two objective functions:

Visualizing the original basin function

Visualizing my basin function

My first attempt at reading through it was frustrating to say the least. It was not Jason’s writing style per-se, but the nature of the subject itself. It is not amenable for reading as a programming book. Jason himself cautions in the first paragraph: “rather than being read cover to cover”, it is a handbook and a technique guide-book. In-spite of that warning I plunged in trying to gather as much as possible. Only later I realized that to make this knowledge my own, I needed to go slow and experiment with each algorithm. But blindly copying what he had done, would be of no avail.

So I set myself up with the following goals:

Goal 1: I will try to implement the algorithms in a language that I have no familiarity with.

Goal 2: I will try to stick to the original pseudo code as far as possible to increase my understanding of the technique

Goal 3: I will try to question and verify every line in the code listing provided by him, so that my implementation would be from understanding, rather than duplicating, or worse copying.

Goal 4: Have an alternate (or accompanying, if you will) source for people who come across this book, with more contextual information on implementing these algorithms. (sort of standing on the shoulders of giants!)

Goal 5: Provide a narrative of my experience, implementing these excellent algorithmic techniques.

To realize goal 1, I chose python as the language to implement the algorithms. As you can see I am a .NET guy throughout my career. So trying to implement the algorithms in python would force me to re-evaluate every line of code that I write. The problem is compounded by the fact that Jason’s original code listing is in Ruby. I had to learn just enough Ruby to understand his code and translate that in to python!. This has a dual advantage: one i get to learn a new language while applying it to a non trivial problem, two it forced me to look at each line of code from an algorithmic stand point.

To realize goal 2, I changed my implementation functions and structure to reflect the pseudo code listing that he provided. This makes it easy to follow how the pseudo code translates to implementation. In all fairness to Jason, he did a great job of it. But I wanted to take it one step further and make it more consumable. The subject matter is hard enough, I wanted to remove any further obstacles to assimilating this seminal work from Jason.

To realize goal 3, I changed some of the objective functions that he provided to others where possible. I also made some changes to some data structures and input variables to further kick the tires. I also included a test suite that exercises the algorithms. So anyone who just want to see how the algorithms behave for different inputs, can do so easily. I also put in a lot more comments in places where I ran in to difficulties. I hope it would make it more valuable to someone trying to follow along.

To realize goal 4, I want people to see how the algorithms play out in a different language. By writing this in a language that I am unfamiliar with, I hope it gives one confidence to attempt them in your language of choice. Each .py file also has a header which lays out the Name, Taxonomy, Strategy and Heuristics of the algorithm. (This is mostly from Jason’s Clever Algorithms book and algorithm template that he designed). The reason I chose to do so was, while understanding one algorithm, I wanted the code and the algorithm context at the same place. I found that very helpful in understanding and assimilating each algorithm.

To realize goal 5, I would be blogging about this. His 45 algorithms are divided in to Stochastic Algorithms, Evolutionary Algorithms, Physical Algorithms, Probabilistic Algorithms, Swarm Algorithms, Immune Algorithms and Neural Algorithms. As I finish implementing each category of algorithms, I will write a blog describing it.

I would like to sincerely thank Jason Brownlee for making available his Clever Algorithms. (By the way, Jason Brownlee did his Phd from the same university that I went to: Swinburne University Melbourne (I am from class of 2000)

Note: I tried as far as possible to write the code in a ‘pythonic’ way. Since I was learning python for this, I would like to beg forgiveness in advance from expert python developers. Any suggestions are always welcome to improve my code.

I am using Python 2.7.2 with Eclipse IDE for Java Developers Version: Helios Service Release 2. I have the PyDev ver 2.1.0xxx plugin for eclipse to work in python.

• Given two line segments p₀p₁ and p₁p₂, if we traverse from p₀ to p₂, did we make a left, right or no turn at p₁?
• Do line segments p₁p₂ and p₃p₄ intersect?

We build on what we learned in Part 1, the cross product.

Download the demo application here

Determining whether consecutive segments turn left or right

Given two line segments p₀p₁ and p₁p₂ we simply check whether the directed segment p₀p₂ is clockwise or counterclockwise relative to directed segment p₀p₁. This is similar to the solution to question 2 in Part 1. If the cross product is negative, then p₀p₂ is counterclockwise to p₀p₁. Hence we should turn left when we reach p₁ to reach p₂ while traversing p₀, p₁ and p₂. If the cross product is 0 (boundary condition) then it means all the three points are collinear (on the same line). The image below shows the three possible scenarios

Using the cross product to determine how p0p1 and p1p2 turn at p1

Determining whether two line segments intersect

Two line segments intersect if and only if either or both of the following conditions are true:

• Each line segment straddles the other line segment.
• An end point of one line segment is on the other line segment

A line segment p₁p₂ straddles another line if p₁ and p₂ are on opposite sides of the line. A boundary condition occurs when one of the end points is on the other line.

Algorithm

Calculate the orientation (using cross product!) d_i for each point of one segment w.r.t the end points of the other segment. For line segments p₁p₂ and p₃p₄ we will get d₁, d₂, d₃ and d₄.

if none of the d_i are collinear (i.e. d_i !=0) we check if d₁ and d₂ and d₃ and d₄ have opposite orientations (if one is clockwise,other should be counterclockwise). If this condition is true then we know that the line segments straddle each other and hence intersect. If it is false we can straight away say they don’t intersect.

If any d_i is collinear (boundary condition) and the corresponding p_i is on the other line segment, the lines intersect.

Shows the different cases that we encounter visually

bool Intersects(p1, p2, p3, p4)
{
    d1 = CrossProduct (p1p3, p1p2)
    d2 = CrossProduct (p1p4, p1p2)
    d3 = CrossProduct (p3p1, p3p4)
    d4 = CrossProduct (p3p2, p3p4)

    if( ((d1 > 0 and d2<0) or (d2 > 0 and d1<0)) and  ((d3 > 0 and d4<0) or (d4 > 0 and d3<0)))
    {
      then return true
    }
    else if (d1 = 0 and PointOnLine (p3, p4, p1))
    {
       then return true
    }
    else if (d2 = 0 and PointOnLine (p3, p4, p2))
    {
       then return true
    }
    else if (d3 = 0 and PointOnLine (p1, p2, p3))
    {
       then return true
    }
    else if (d4 = 0 and PointOnLine (p1, p2, p4))
    {
       then return true
    }
    else
    {
       return false
    }
}

bool PointOnLine (pi, pj, pk)
{
    if ( Min (xi, xj)<= xk <= Max (xi, xj) and Min (yi, yj)<= yk <= Max (yi, yj) )
    {
        return true
    }
    else
    {
        return false
    }
}

1. Given two points p₁ & p₂ in a co-ordinate plane, is the directed segment p₀p₁ clockwise, counterclockwise or colinear to directed segment p₀p₂? Where p₀ is the origin of the co-ordinate plane
2. Given two directed segments p₀p₁ and p₀p₂, is p₀p₁ clockwise, counterclockwise or colinear to p₀p₂ with respect to the common end point p₀?
3. Given two line segments p₀p₁ and p₁p₂, if we traverse from p₀ to p₂, did we make a left, right or no turn at p₁?
4. Do line segments p₁p₂ and p₃p₄ intersect?

Download the demo application here

Before we proceed any further a few definitions. Clockwise and Counterclockwise are intuitively easy to understand. They have the usual colloquial meaning. There is one thing to note though. A co-ordinate plane is not a watch face! Here we are determining the relative orientations of one segment w.r.t the other. Instead of trying to explain it in words, I will show you a picture (should replace a thousand words!).

The darkly shaded orientation region contains vectors counterclockwise relative to p. The lightly shaded region contains vectors clockwise to p

Two vectors are colinear if they are pointing in the same or opposite direction. In the picture all vectors that lie along the diagonal will be colinear to p.

With definitions out of the way, let us proceed to answer the initial queries that we posed. A brute force method of computing whether two line segments intersect, would be to find the line equations of the form y=mx + c where m is the slope and c the y-intercept and then compute the point of intersection, and verify whether this point lies on both lines. This involves a lot of expensive computational resources. Further this involves division which is sensitive to round-off errors depending upon the precision of the division operation. For e.g. almost parallel line segments will give incorrect results.

The algorithms given here will only use additions, multiplications, subtractions and comparisons ! No trigonometry also !
We do this by computing the cross product. This is a fundamental technique that is at the base of most CG algorithms. Let me say that again. Cross Product is a most fundamental and important technique for solving CG problems. A cross product p₁ X p₂ is defined as the determinant of the matrix comprising of x and y values of the points.

Determinant of the above matrix will be equal to (x1y2-x2y1)

If the cross product is positive then p₁ is clockwise to p₂. A boundary condition occurs if the cross product is 0. In that case p₁ and p₂ are colinear.

Proof: We use trigonometric function tan on the angle formed by the point (x,y), origin (0,0) and (x,0) for both the points. If the ratio of one tangent to other determines orientation depending upon whether the value is greater than 1 or not.

//Clockwise:
x1y2-x2y1>0

//So
x1y2>x2y1

//alternatively
(x1y2)/(x2y1)>1

//rearranging the terms
(y2/x2)/(y1/x1)>1

//Notice that tan θ is the ratio of opposite side by adjacent side
//in a right-angled triangle
//so the numerator of the above fraction is tan θ2 and
//denominator tan θ1

(tan θ2)/(tan θ1)>1

If the angle θ2 is greater than θ1
then we have proved that p1 is clockwise to p2

The above technique of using cross product makes for an easy and efficient way to answer Question 1.
To answer Question 2 just involves an extra pre-processing step before doing the cross product. To determine whether two directed segments p₀p₁ and p₀p₂, is p₀p₁ clockwise, counterclockwise or colinear to p₀p₂ with respect to the common end point p₀ we just translate the axis to use p₀ as the origin and use the cross product as above.

// To translate the origin to the common end point p0
//We let p1' (p prime) be the point where 

x1' =x1 - x0 and
y1' =y1 - y0

//We do the above for  p2 and calculate its prime: p2' 

x2' =x2 - x0 and
y2' =y2 - y0

//Then we calculate the cross product of p1' x p2' 

If it is positive then the directed segment p0p1 is clockwise to
directed segment p0p2

In Part 2 we will answer questions 3 & 4 using the techniques and principles learned here.

     string data="query string";
     string encodedData = String.Empty;
       try
       {
           byte[] data_byte = Encoding.UTF8.GetBytes(data);
           encodedData = HttpUtility.UrlEncode(Convert.ToBase64String(data_byte));
        }
        catch (Exception exception)
        {
           //Log exception
        }
        return encodedData;

While this works, it provides only obfuscation, but no security. Anyone can do the reverse:

        string data="encoded data";
        string decodedData = String.Empty;
        try
        {
             byte[] data_byte = Convert.FromBase64String(HttpUtiltity.UrlDecode(data));
             decodedData = Encoding.UTF8.GetString(data_byte);
        }
        catch (Exception exception)
        {
             //Log exception
         }
         return decodedData;

A little more advanced method is to use PasswordDeriveBytes class in .NET to do proper encryption. This has since been replaced with Rfc2898DeriveBytes in .NET 2.0. The reason you would want to use Rfc2898DeriveBytes is because it meets the PKCS #5 standard, which PasswordDerrivedBytes, does not. Both of them are present in System.Security.Cryptography namespace.

What we need to do is:

• Generate the encryption key and IV(Initialization Vector) from the password and salt.
• Create a new instance of the encryptor with the key and IV.
• Encrypt the query string.

We are not done yet. Improper use of Rfc2898DeriveBytes will result in a performance impact on large sets of data. The cause is the call to GetBytes(int32) method on Rfc2898DeriveBytes class. It uses a pseudo-random number generator based on HMACSHA1. GetBytes initializes a new instance of HMAC is the killer in terms of performance. But the redeeming factor is, subsequent calls to GetBytes does not need to do this initialization.

So we change our implementation to do this expensive call once. Since there is no need to create a new instance of Rfc2898DeriveBytes for each call to encrypt, we will use the same key but change the IV for each message. So remove Rfc2898DeriveBytes from the Encrypt method and pass along the key and IV instead of the password and salt.

Putting all this together here is the final code (fast and efficient):

      public static class MyHelper
      {

          #region Private variables and Constants
          private const string ENCRYPTION_KEY = "Wx0Te1rc0pA";
          // Generated from Pass Phrase  "xxxxxxxx12012010" or some pass phrase that you can remember from
          // https://www.bigbiz.com/genkey.html Key Generator Site

          private const string QUERY_PARTS_DELIMITOR = "&";
          private const string QUERY_PARAMS_DELIMITOR = "=";

          ///
          /// The salt value used to strengthen the encryption.
          ///
          private readonly static byte[] SALT = Encoding.ASCII.GetBytes(ENCRYPTION_KEY);
          private readonly static byte[] key;
          private readonly static byte[] iv;
          private static readonly Rfc2898DeriveBytes keyGenerator;

          #endregion

         #region Constructor

         static MyHelper()
         {
            //We create the Rfc2898DerveBytes once as
            //Rfc2898DeriveBytes uses a pseudo-random number generator based on HMACSHA1.
            //When calling GetBytes it initializes a new instance of HMAC which takes some time.
            //Subsequent calls to GetBytes does not need to do this initialization.
            keyGenerator =new Rfc2898DeriveBytes(ENCRYPTION_KEY,SALT);
            key = keyGenerator.GetBytes(32);
            //Generate Initialization Vector - This will be less expensive as we have already intialized Rfc2898DeriveBytes
            iv = keyGenerator.GetBytes(16);
        }

       #endregion

       #region Encrypt/Decrypt Methods

        ///

        /// Encrypts any string using the Rijndael algorithm.
        /// 

        ///
The string to encrypt.
        ///
The name of the query string paramater
        /// A Base64 encrypted string.
        public static string Encrypt(string inputText, string queryStringParam)
        {
            //Create a new RijndaelManaged cipher for the symmetric algorithm from the key and iv
            RijndaelManaged rijndaelCipher = new RijndaelManaged {Key = key, IV = iv};

            byte[] plainText = Encoding.Unicode.GetBytes(inputText);

            using (ICryptoTransform encryptor = rijndaelCipher.CreateEncryptor())
            {
                using (MemoryStream memoryStream = new MemoryStream())
                {
                    using (CryptoStream cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
                    {
                        cryptoStream.Write(plainText, 0, plainText.Length);
                        cryptoStream.FlushFinalBlock();
                        return "?" + queryStringParam + "=" + Convert.ToBase64String(memoryStream.ToArray());
                    }
                }
            }
        }

        ///

        /// Decrypts a previously encrypted string.
        /// 

        ///
The encrypted string to decrypt.
        /// A decrypted string.
        public static string Decrypt(string inputText)
        {
            RijndaelManaged rijndaelCipher = new RijndaelManaged();
            byte[] encryptedData = Convert.FromBase64String(inputText);

            using (ICryptoTransform decryptor = rijndaelCipher.CreateDecryptor(key, iv))
            {
                using (MemoryStream memoryStream = new MemoryStream(encryptedData))
                {
                    using (CryptoStream cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read))
                    {
                        byte[] plainText = new byte[encryptedData.Length];
                        int decryptedCount = cryptoStream.Read(plainText, 0, plainText.Length);
                        return Encoding.Unicode.GetString(plainText, 0, decryptedCount);
                    }
                }
            }
        }

        #endregion

       }

The only draw back is this doesn’t give you full security. This method will provide basic security in terms of stopping the hacker from deterministically manipulating the encrypted string. So it is a more a deterrence than a verification strategy. We can tell if someone tampers with the encrypted string only if the decryption ‘fails’ to decrypt to something you recognize or expect.

GodMode: A feature that transforms a folder to a shortcut pointing to some windows tasks, just by appending a folder name with a period (‘.’), followed by a special string (‘{GUID}’).

It includes direct access to all kinds of settings, from choosing a location to managing power settings to identifying biometric sensors, to name a few.

To keep them all grouped together and ‘know’ what they do with a glance, I followed this pattern-
[folder name].{GUID}
In my case, I chose ‘GodMode’ as the folder name. Once the shortcut is made, I change the name to the following format before moving on to the next God Mode- [folder name].[feature name] For e.g. with the Control Panel God Mode, I would call it something like ‘GodMode.ControlPanel’.

This is how it looks on my computer:

God Mode Folders

Here is a list of God Modes that I have found so far with a short description:

Control Panel : {ED7BA470-8E54-465E-825C-99712043E01C}
Description: A shortcut to all Control Panel functions

Location Info : {00C6D95F-329C-409a-81D7-C46C66EA7F33}
Description: A shortcut to set up default location for programs to use when a location sensor, such as GPS receiver, is unavailable. On can also enter Geographic location (latitude and longitude) too.

Biometric Info : {0142e4d0-fb7a-11dc-ba4a-000ffe7ab428}
Description: A shortcut showing the information of any biometric device like fingerprint reader etc, if installed.

Power Plan : {025A5937-A6BE-4686-A844-36FE4BEC8B6D}
Description: A shortcut to select the power consumption settings for your computer.

System Tray : {05d7b0f4-2121-4eff-bf6b-ed3f69b894d9}
Description: A shortcut which opens the icon and notifications settings, where you can set whether you want to show/hide icons in system tray and whether to show only notifications etc.

Windows Vault : {1206F5F1-0569-412C-8FEC-3204630DFB70}
Description: A shortcut which points to Windows Vault. We can store credentials for automatic logon here.

Program Install: {15eae92e-f17a-4431-9f28-805e482dafd4}
Description: A shortcut to install a program from the network.

Default Programs: {17cd9488-1228-4b2f-88ce-4298e93e0966}
Description: A shortcut to choose programs that Windows uses by default.

Manage Wireless: {1FA9085F-25A2-489B-85D4-86326EEDCD87}
Description: A shortcut to manage wireless networks.

Manage Network: {208D2C60-3AEA-1069-A2D7-08002B30309D}
Description: A shortcut to network computers, websites, FTP sites etc.
Remarks: This God Mode doesn’t allow us to rename the folder to anything else. It keeps changing back to ‘Network (MS)’

Manage Network: {1D2680C9-0E2A-469d-B787-065558BC7D43}
Description: A shortcut to GAC (Global Assembly Cache).
Remarks: This God Mode doesn’t change its folder icon or hide its GUID string like others. But it correctly points to the GAC on the computer.

Computer Drives: {20D04FE0-3AEA-1069-A2D8-08002B30309D}
Description: A shortcut which shows the current drives on the computer.

Printers: {2227A280-3AEA-1069-A2DE-08002B30309D}
Description: A shortcut to the printers added to the computer.

Remote Connections: {241D7C96-F8BF-4F85-B01F-E2B043341A4B}
Description: A shortcut to manage your RemoteApp and Desktop Connections.

Windows Firewall: {4026492F-2F69-46B8-B9BF-5654FC07E423}
Description: A shortcut to setup Windows Firewall settings to prevent malicious hackers from getting access to your computer.

Computer Performance: {78F3955E-3B90-4184-BD14-5397C15F1EFC}
Description: A shortcut to get your computer’s speed and performance information.