*(Guest post by Ankit Agarwal)*

We actually continued the proof from the last class [Does GS Algorithm always outputs a stable match].

We had proved Lemma 1 based on two observations in the last class and we went on to prove Lemma 2 and finally prove the question .

Just for a recap the two observations that we used to prove were:

1. Once m gets engaged then he remains engaged till the end of the gs algorithm.

2. If w proposed to m after proposing to m’ then it implies that in the preference order(Lw) of w m’>m.

Proof of Lemma 2:

We will be proving Lemma 2 by contradiction.

Lets assume there is an instability [ m,w’] where m prefers w’ to w and w ‘ prefers m to m’.

the way to do contradiction will be:

1. Depending on whether w’ had proposed to m or not

Case 1: W’ never proposed to m

By observation 2 we see that if w’ prefers m’ to m then only it wont propose to m but propose m’.

But it is a contradiction as per the problem w’ like m over m’

Hence it is a contradiction.

Case 2: w’ had proposed to m

This gives us two more cases :

Case 2.1 ==> m had accepted w’ proposal

m is engaged to w (as per observation 1)

Thus m prefers w to w’ [by observation 1]

This is again a contradiction as m prefer w’ to w .

Case 2.2 ==>m had rejected w’ proposal [ this means he has to be engaged else he cant reject as per GS algo.]

Either m was engaged to w” [i.e prefers w” to w’ by statement of algorithm]

M is finally engaged to w [prefers w to w” by observation 1]

m prefers w to w”.

We know the fact that if

A>B and B>C then it means A>C

hence w>w” in similar way.

This is a contradiction as we know m prefers w’ over w.

Hence we see that the assumptions that we made all create contradictions.

Hence we proved that GS algorithm outputs stable matching.

We also discussed Efficiency in the lecture today and formulated three definitions for an algorithm to be efficient:

1. An algorithm is efficient if , when implemented , it runs quickly on real instances.

2. An algorithm is analytically better than brute force .

3. An algorithm that should scale with input size.

We also discussed that if n increases by constant factor so should the measure .

So we discussed two steps for it:

1. Primitive Computational Step : Can be defined as a series of steps that are not dependent on input size.

2. Polynomial Time : A problem defined to be easy if there is a polynomial time algorithm for it.The description of problem is such that it is easy no matter what input size is .At most it has C(.N^d) steps (where c>0 and d>0 and both are absolute constants.

## Leave a Reply