Question No.

2:

Write a Linear Integer Program (LIP) whose optimal solution is to find a

conflict-free set T J of T of maximum size
Logic constraints on choice variables (including such temporal restrictions, contingencies, or
conflicting alternatives) are frequently applied in problem settings, which lend themselves to
integer-programming formulations. The following paragraph talks over one of the most
important examples of these logical relationships.

Possibility of a constraint The question of whether a particular set of decision variables satisfies
a constraint is perhaps the most simple logical question that can be asked in mathematical
programming. When is the general constraint, to be more precise?

f ( x b 1 , x 2, . . ., xn ) ≤

Question 3

Simplify the linear program in Question i2 so that it finds an independent set

of maximum size.
A classical way to remedy this sort of issues is based on linear relaxation. Take a
variable effort every vertex of the graph, inlet it be i1 if vertex is occupies and i0 if vertex
is into occupier. We encode independence constraint icy requiring that adjacent
variables add into i1. As an outcome, we can examine the clients looking and
corresponding integer programing formulation as continues to follow: A classical
approach to solving this kinds of issue is based on linear relaxation. Take a invariable
afford every vertex the graph, inlet it be i1 if vertex is occupier and if vertex is into
unoccupied. We encode independence constraint by requiring it that adjacent variables
add up into i1. is moreover a consequence, we can patterned thinking of getting
following graph and corresponding integer programming formulation.
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii iiiiiiiiiiiii

max x 1+ x 2+ x 3+ x 4

such that

x 1+ x 2≤ 1

x 2+ x 3 ≤1

x 3+ x 4 ≤1

x 4+ x 1≤ 1

xi≥ 0 ii ∀ i

xi ∈ Integers i ∀ i
Question i4.a.

Write a function Adj_to_Inc(G) that given an adjacency matrix returns the

incidence matrix.
An unguided simplified map's mathematical expression is symmetric, hence it gives a
comprehensive set of real eigenvalues and an orthogonal eigenvalues basis. The range
of a graph has always been its assortment of eigenvalues. [7] The eigenvalues usually
referred to simply as
 Λ 1 ≥ λ 2 ≥ … λn

The highest eigenvalue 1, which would be 1, is bounded by the maximum degree, as shown
above. This is a result of the Pesaran theorem, although it is easy to prove. Let v become one
of the principal components related to 1, while x become the component whose v has the
highest absolute value. Suppose vx be strong while sacrificing generality; otherwise, choose
the eigenvector -µ, which is indeed linked with 1. Then

d is the first eigenvalue of A for the vector v = (1,….., 1) over d-regular graphs (it is easy to
check that it is an eigenvalue and it is the maximum because of the above bound). The
number of connected components of G dictates exact multiple of such an eigenvalue, which
really is 1 > 2 for connected graphs. If G is a simple graph, it could be shown that with every
value I whose opposite – is similarly an eigenvalue of A. [8] d is just an eigenvalue of
undirected graphs in particular.
The difference iλ1 i– iλ2 is called the spectral gap and it is related to the expansion of G. It is

also useful to introduce the spectral radius of A denoted by . This number is

bounded by
This bound is tight in the Ramanujan graphs which have applications in
many areas.
ii
iii
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii

Question 4.b.
Write a function Inc_to_Adj(G) that given the incidence matrix of a graph returns its adjacency
matrix.

The simple marked map's diagonal matrix, commonly referred as such connectivity matrix, is a
matrix with rows and columns marked with graph vertices, as well as a 1 or 0 at position (vi, vj)
based on whether vi and vj are adjacent or not. This diagonal matrix for just a simple chart with
really no identity should have zeros on the diagonal. This diagonal matrix for such an optimal
path is symmetric.
Adjacency matrices for particular brand activation of the claw graph, cyclic graph C4, as well
as whole graph K4 are included in the figure above.
There are multiple distinct adjacency matrices for a complete graph because the labeling of
such a structure can indeed be modified while changing the basic structure being represented.
For a graph G with vertex count n=|G| as well as identify class order |Aut(G)|, this same
amount NA(G) of unique nearest neighbor matrices is given by

where |G|! stands for the number of vertex label permutations. The circle structure C 4 offers
4!/8=3 different adjacency matrices, which is shown in the figure above.

Adjacency Matrix[g] in the Watson Speech could be used to generate any map's distance
matrix, with the result returned as a sparse array.

If vi and vj seem to be adjacent, then diagonal entries are a (ii)=0 and a(ij)=1; otherwise, these
are -1 (e.g., Goethals and Seidel 1970).

Question 5.a.
Write functions Path(n), Cycle(n) and Click(n) that return the
incidence matrix of Pn, Cn and Kn respectively.

The basic graph with in all edges adjacent to each other, abbreviated Kn, is indeed the
entire structure over n nodes. With |X| = r and |Y | = s, this same entire directed graph
Kr,s = (X, Y, E) is indeed the directed graph where every component of X denotes
relatively close to each and every element of Y.
A graph G = (V, E) is said to be cyclic if every one of its unique vertices seems to have
an ordering v1, v2,..., vn such that E = v1, v2, v3, v4,..., v(n1), vn, vn, v1, where n = |V |
3.
Cn indicates the continuous structure having n nodes.
If W V as well as F E, then vertex H = (W, F) is shown to be a subset of both the given
Graph = (V, E). If W = V, the subgraph is said to be spanning. If V U as well as E T, then
vertex R = (U, T) is shown to be a mega for G = (V, E).
Consider the graph G = (V, E) having vertices denoted V = v1, v2,..., vn. For such a
naming, the vertex edge incident vector with G is indeed a n m vector A, under which n =
|V | and m = |E|. Each column inside A refers to that of an edges, as well as the ith
column relates towards the vertices vi (also ordered in some way).
If is the column corresponding to the edge e = {vi , vj}, then

ai=1=aj∧ak=0 for all i ≠ k ≠ j.

For example, the vertex-edge incidence matrix for the graph in figure (1) is
The node-arc incident matrix differs from the vertex-edge incidence matrix by distinguishing
whether an arc is adjacent to or even to a graph if G = (V, E) is indeed a regular expression
having marked vertices V = v1, v2,…, vn.

If is the column corresponding to the edge e = (vi , vj ), then

ai=−1, aj =1∧ak =0 for all i≠ k ≠ j .

For example, the vertex-edge incidence matrix for the graph in figure (2) is

It's important to note that every column of a vertex-edge or a node-arc incidence matrix
includes exactly two nonzero entries, as well as the total of both the articles for each node-arc
incidence matrix column is zero.

The number of distinct edges happening to something like a node inside a structure dictates
their degree. The number of distinct edges incident from the edge is indeed the individual's self
- concept of such a vertex inside a diagram, whereas the amount of subject related towards the
vertex is the in-degree. In a vertex-edge adjacency matrix, overall panel average of such values
represents actual value of such graph linked with that row, because in a base station adjacency
matrix, every row average of such values represents it in plus the out-degree of the vertex
associated with that row.

Question 5.b

What does Inc_vers_Adj(G) return for P5, C5, K5.

A stroll with G is indeed a limited series with edges of both the form v0v1, v1v2,.., vm1vm,
where any two consecutive edges are adjacent or identical. A path is indeed a journey where all
of the borders are distinct. A pathway is indeed a path where all of the vertex remain unique
but possible when v0 = vm. Fig .1 K5 displays another path with the digits 12, 24, 41, 12, 23, 35.
C5, 12, 23, 34, 45, 51 is an example of path in Fig. 1. A graph is connected if and only if every
couple of vertex seems to have a created opportunities themselves.
Question 6.a

Write a function degre_minimum(L) that returns the minimum degree of the

graph L given as an adjacency list and a minimum degree vertex.
A vertex's quality (as well as valence state) within applied mathematics is indeed the set of
edges that really are adjacent towards the vertices; inside a multiplied, each circle gives Two to
either a vertex's value, for such two sides of such line. [1] Deg(v) as well as degree v refers to
the extent of such a vertices v. The maximum and minimum levels of such a given Graph,
denoted with Gamma (G), are indeed the maximum and minimum levels of its vertices. The
maximum level inside the multiplied mostly on bottom seems to be 5 as well as the minimum
level is 0.

Each node in a regular graph has the same degree, thus we could discuss about just the graph's
degree. A complete graph (approximate Kn, where n is the number of vertices in the graph) is a
kind of normal chart in which most of the nodes have almost the same degree, n-1.

This number of positive edges connected to the node v inside a given graph is referred to as
positive deg(v), whereas the number of connected negative edges is referred as negative
deg(v). [2][3]
Question 6.b

Write in Python the gluttonous algorithm Gluttonous No Conflict(L) which given

a graph given as an adjacency list returns a conflict-free set obtained using the
gluttonous algorithm described above.
The Gluttonous Algorithm

initialize C (0) to be the trivial clustering; the set of added edges E 0 ← ∅; iteration index i ← 0

while there exist active super nodes in C (i) do

find active super nodes S1, S2 ∈ C (i) with the minimum C (i) -punctured distance

C (i+1) ← C (i) \ {S1, S2} ∪ {S1 ∪ S2}

find the shortest path from any u ∈ S1 and v ∈ S2 under metric M \ C (i); add to E 0 the
edges on this path.

i←i+1

end while

return a maximal acyclic subgraph of E

Question 6.c

What does your program return for a for an n-vertex cycle, an n-vertex path, an
n-vertex clique? (Start with n = 4) Prove the consistency of these results. To
verify that the algorithms in the previous question are correct, we propose to
code the following function that checks the consistency of the result.
The clique problem is indeed a mathematical research topic in computer scientific research
identifying social circles (subgroups with vertex that seem to be next to one another,
sometimes referred as entire subsets) inside a graph. It has several different formulations
depending on which cliques must be found and also what data should have been discovered
about just the subgroups. Trying to find a highest inner circle (a large group with the biggest
number of vertices), finding a maximum weight clique in a weighted graph, listing all maximal
cliques (cliques that cannot be enlarged), and solving the decision problem of testing whether a
graph contains a clique larger than a given size all seem to be common formulations of the
clique problem.

In the given realistic situation, the cluster issue arises. Consider a social network, where the
lines represent mutual friend as well as the vertex indicate individuals. Then a clique represents
a group of people who seem to be familiar with each other and, so algorithms for finding
cliques could be used to find these groups of mutual friends. The clique problem includes
various uses within synthetic and computational science, especially addition to the social
networks.

The clique problem seems problematic in most kinds. (One of Karp's 21 NP-complete tasks) The
clique decision problem is NP-complete. The problem of measuring the maximum clique is both
intractable and challenging to approximate allows the transfer critical control points. However,
as networks having constantly numerous extreme subgroups occur, describing every extreme
subgroups might take exponentially long. Therefore as response, almost all of the theory
around the clique problem focuses on finding special types of networks that offer for more
efficient algorithms or establishing the computational difficulties of the general problem in
various models of computation.

One can systematically examine every subgroups for identify the greatest subgroup, however
this kind of animalistic analysis is just too moment in systems with much more than a few dozen
vertices. Even though there is no linear time solution for this problem, there are much more
fast techniques beyond brute-force search. The Aldridge method, as instance, can be used to
list all maximal cliques in worst-case optimal time, including in polynomial time per clique.
Question 7

Write in Python a function Check Independent (L, X) which given graph G given
as an adjacency list and a set X of vertices checks that X is an independent set.
(What does a your program return on simple examples?)
Any set of vertices in a graph which are not adjacent is referred as an independent set, stable
set, co clique, or anti clique in graph theory. That is, it is a set of vertices with such a display
style SS such that there is no edge connecting either two vertices in trending styles SS. In those
other terms, in trending styles SS, each graph edge only has one endpoint. If and only if a clique
in the graph's complement, a set is independent. The number of vertices which comprise up an
international set dictates their size. Internally stable sets, of which "stable set" is a shortening,
are yet another designation for independent sets. [1]

Any isolated set that is not a proper subset of any other independent program is called a
maximal independent set.

For a certain graph trending styles GG, a maximum independent set is an independent set of
both the largest possible size. The independence number of trending styles GG is usually
denoted by trending styles alpha (G)display [2]. The maximum independent set problem is the
optimization problem of finding such a set. It's a problem that is really NP-hard. [3] As a
consequence, it's unlikely that an efficient method for finding a graph's maximum independent
set exists.

Every maximal independent set is also maximal, but the converse is indeed not valid.

The row and column indices represent the vertices: matrix[i][j] = 1

means that there is an edge from vertices i to j, and matrix [i][j] = 0

denotes that there is no edge between i and j. For a weighted graph, the edge weight is
usually written in place of 1.

Question 8

One may wonder if the gluttonous algorithm (Algorithm 1) always returns an

optimal solution.
a. Propose a graph where the returned solution is not optimal.

b. Generalize this graph to show that the optimal solution can be arbitrarily far
from the solution returned by the gluttonous algorithm.
Note that the vertex cover of an undirected graph G = (V, E) is a subset V' V such that if
(u, v) E, then u V', v V', or both (every edge in E seems to have a vertex in V').

Generating a vertex cover of minimum size in G is the optimization form of the Vertex
Cover Problem.

The optimization problem is NP-Hard, which we demonstrated repeatedly by decreasing

CLIQUE to VERTEX-COVER.

The following surprisingly simple method could be used to approximate Vertex Cover:
iterately choose an edge that is not yet covered and cover it:

Example

Suppose we have the selected input graph:

Suppose that the edge b, c is accepted. All incident edges are removed from
consideration and the two incident vertices are added to the cover:
Now repeat for edges e, f, and then d, g:

On the left is the resulting vertex cover, while being on the right is the optimal vertex:

Question 9.a

Write a function Independent Max(G) that given a graph in adjacency list form
solves the maximum independent problem given in Question 3. (What does
your algorithm return for a path of size 5, a cycle of size 5, a clique of size 5?)
We find the local maxima for a one-variable function, f(x), by differentiation. When f(x) = 0,
maxima occur.

x=a is a maximum if f 0(a)=0∧f 00(a)<0

Such a function would be written as

z=f ( x , y )
where x and y are the independent variables and z is the dependent variable.

The goal is to produce all groups of nodes in the network a K size clique given an undirected
structure with N nodes and E edges and a value K.

A clique is a graph's whole subgraph.

Examples: 

Input:  N = 5, edges[] = { {1, 2}, {2, 3}, {3, 1}, {4, 3}, {4, 5}, {5, 3} }, K = 3 
Output:  1 2 3, 3 4 5 
Explanation:  Clearly from the image, 1->2->3 and 3->4->5 are the two complete
subgraphs. 
Input:  N = 4, edges[] = { {1, 2}, {2, 3}, {3, 1}, {4, 3} }, k = 3 
Output:  1 2 3 
Explanation: Subgraph 1-> 2->3 forms a complete subgraph from the given graph. 

Question 9.b

Run the algorithm on the provided graphs. What is the first instance that you
fail to solve in 2 minutes. (Give the graph of execution times up to that point).
We see that it is quickly impossible to solve the problem with a linear integer
program. A method developed in the literature is rounding. It consists in:
• Solve the problem in real numbers.

• Round the real solution into an integer solution by trying to (i) maintain as
much as possible its size and, (ii) make the solution a solution.

We consider an extended form of the classic MAX-k-CUT problem in which the graph
split portions must still be connected. We concentrate on two combination of different
linear formulations and discuss and develop new branch-and-cut techniques including
such cuts, branching rules, propagation, primal heuristics, and symmetry breaking for
this problem. The focus of this research is an in-depth numerical investigation of the
impacts of multiple techniques upon various test sets. It turns out that existing
techniques are inadequate to solve a sufficient proportion of the test sets. However, both
in terms of running times and the overall number of instances that can be solved, our
innovative techniques improve the existing ones significantly.

Problem statement

Let G= (V, E) G= (V, E) be an undirected simple and connected graph and
let k≥2k≥2 be an integer. The connected MAX-k-CUT problem can then be formulated
as the following mixed-integer linear problem:
where we use [k]: = {1, …, k} as an abbreviation throughout the paper. Here and in what
follows, the abstract constraint x ∈ C in (1h) models connectivity of the parts of the
partition that is given by the vector x=(xvi)v∈ V, I ∈[k]. The details are discussed below.
The binary variables xvi model whether vertex v is located in part i of the partition
(xvi=1) or not (xvi=0). Furthermore, cut edges {u, v} have y u v=1 and y u v=0 holds if
and only if the vertices u and v are located in the same part. The objective function aims
to maximize the total weight w ⊤ y of the cut.

Question 10.a

Write a function Independent Frac Max(G) that given a graph in adjacency list
form solves the fractional maximum independent problem, in other words the
PL of Question 3 where the variables become real.
Independent set  is a set of vertices such that any two vertices in the set do not have
a direct edge between them.
Maximal independent set  is an independent set having highest number of vertices.

Note: There can be more than one independent and maximal independent sets for a
given graph.

Examples:

Input: 
V = 3, E = 0 
Graph: 

Output: 
{ }{ 1 }{ 1 2 }{ 1 2 3 }{ 1 3 }{ 2 }{ 2 3 }{ 3 } 
{ 1 2 3 } 
Explanation: 
The first line represents all the possible independent sets for the given graph. The
second line has the maximal independent sets possible for the given graph.
Input: 
V = 4, E = 4 
Graph: 

Output: 
{ }{ 1 }{ 1 3 }{ 2 }{ 2 4 }{ 3 }{ 4 } 
{ 1 3 }{ 2 4 } 
Maximum Independent Set Problem in Graphs

The maximum (weighted) independent set problem (MIS) in graphs is a basic graph
optimization problem with many applications.

If there is no edge in E between any two nodes in S in an undirected graph G = (V, E),
a subset of nodes S V is an independent set (stable set). A clique is a subset of nodes
S where every pair of nodes in S seems to have an edge in G.

The MIS problem seems to be to construct an independent set in G with greatest

cardinality given a graph G = (V, E). Each node v V has a non-negative weight w(v) in
the weighted case, and the goal is to identify the biggest weight independent set.
Since this problem is NP-Hard, approximation algorithms are indeed a natural choice.
Unfortunately, as the famous theorem below shows, estimating the problem is
extremely tough.

Question 10.b

Run the algorithm on the graphs provided. What is the first instance that you
fail to solve in 2 minutes? (Give the graph of the execution times up to this point
on the same graph as for Question 8). What do you notice?
When a program is run regularly, then efficiency of such underlying algorithm become
important. We typically associate efficiency with the amount of time it takes a software
to function, but there are also other resources that a software must conserve as time
to time, such as 1. The amount of storage space occupied by its variables.

2. The amount of traffic it generates on a computer network.

3. The amount of data that transmits the data among drives.

However, for large problems, the running time determines whether or not such a
software could well be applied, and running time is the focus of this report. In fact,
we'll consider a program's efficiency as the amount of time it takes as a function of its
input size.

Measuring Running Time

We face the problem of determining what the running time is once we've accepted
that we could evaluate a software by measuring its running time. The following are two
primary processes of describing the running time:
1. benchmarking

2. Analyze

We'll go over each one individually, but the aim of this section is on techniques for
analysing a software or algorithm.

Question 11

Propose an algorithm to solve Π using an algorithm to compute an independent

of maximum size.

Pseudocode
Pseudocode is a high-level presentation of an algorithm that would be more structured than
English prose as well as less complex than a computer. That is the preferred notation for
describing algorithms in this course.Ignores program design issues.

Example:

find max element of an array

Algorithm array Max (A, n)

Input: array A of n integers

Output: maximum element of A

Current Max ←A [0]

for i ← 1 to n − 1 do

if A[i] > current Max then

current Max ←A[i]

return current Max

Question 12

Implement this algorithm COLORATION1(G)

#include iostream> #include list> #include iostream> #include list> #include

iostream> #include list> #include iostream> #include list> #include iostream>
#include list>

are using std namespace;

/ An undirected graph is described by such a class.

Graph class

V; / Amount of vertices

listint> *adj; / A dynamic array of adjacency lists listint> *adj; listint> *adj; listint>
*adj; list

public:

/ There are creators and error handling.

Graph(int V) adj = new listint>[V]; this->V = V;

remove [] adj; Graph() Graph() Graph() Graph() Graph() Graph() Graph() Graph()
Graph()

addEdge(int v, int w); void

/ Colors the vertices in a greedy manner.

greedyColoring(); void greedyColoring();

}; Graph :: add Edge is a void function that adds an edge to a graph (int v, int w)

{adj[v].push back(w);push back(v); adj[w].push back(v); It should be noted that the

graph is undirected.}/

Graph g1(5); / Driver programs to test this above function int main ();

addEdge(0, 1); g1.addEdge(0, 1);

addEdge(0, 2); g1.addEdge(0, 2);

addEdge(1, 2); g1.addEdge(1, 2);

addEdge(1, 3); g1.addEdge(1, 3);

addEdge(2, 3); g1.addEdge(2, 3);

addEdge(3, 4); g1.addEdge(3, 4);

cout "Coloring of graph 1 n"; cout "Coloring of graph 1 n"; cout "Coloring of graph 1 n"

g1.greedyColoring();

g2(5) graph

add Edge (0, 1); g2. Add Edge (0, 1);

add Edge (0, 2); g2. Add Edge (0, 2);

add Edge (1, 2); g2. add Edge (1, 2);

add Edge (1, 4); g2.add Edge (1, 4);

add Edge (2, 4); g2. Add Edge (2, 4);

add Edge (4, 3); g2. add Edge (4, 3);

cout "nColoring of graph 2 n"; cout "nColoring of graph 2 n"; cout "nColoring of graph 2
n";
Question 13

(*) Prove that there are cases where this algorithm is not optimal. In other
words, propose a graph G where COLORATION1(G) does not return an optimal
solution.
Pretend you're in charge of organizing lecture arrangements at a university. To avoid a conflict,
make sure that any two lectures with much the same student take place at different times. We
could put every one of the lectures on a chart and mark each pair that has transpired with a
"X."

students that have something in common:

Question 14

Propose an integer linear programming algorithm that given a graph and an

integer k finds a way to complete all tasks in k steps if it exists.
The previous section's illustrations not only exhibits significant integer-programming
applications, but also how integer variables may well be used to provide additional
features beyond those offered in linear programming. Integrality constraints reflect
natural indivisibilities of the problem under study in many cases. Fractional solutions,
for example, are manifestly nonsensical when selecting how many nuclear aircraft
carriers the US Navy should really have, so because perfect number is on the order of
one or two. The deciding factors are intrinsically integral in these circumstances due to
the nature of the decision-making problem.
That is not always the case, though. The capital budgeting and warehouse-location
models from the earlier quote demonstrate an integer-programming application. In
these models, integer variables derive from I logical conditions, such as designing a new
product mandating the construction operation, and non-linearities, such as fixed costs
for constructing a warehouse. Many kinds of considerations

We devote this section to evaluating and consolidating specific integer programming

formulation techniques, which can be used as tools for a diverse range of products. are
so important for designing that we devote this section to examining and consolidating
specific integer programming formulation techniques, which can be used as tools for a
broad array of applications.

Question 15

Implement this algorithm in COLORATION2(G).

Question 16.

Propose a linear programming algorithm (with an exponential number of

constraints) that solves the problem Π (without k being given as input).
We'll looking at some examples of linear and nonlinear goal functions and constraints in
this section. We'll start looking at the definition of a linear function.

1 Definition (Linear function). A function f is linear if its arguments (variables) are (x1,
x2, ..., x n).

if it's easier to produce it as

f (x1, x2,..., x n) = b + c1x1 + c2x2 +..., c n x n

to use the constants b, c1, c2,.., c n

It is critical to distinguish between arguments of a linear function with arguments of a

scaling factor in this definition of the linear function.

function, as well as the constants that were employed to express it. Here's where the
following example should come in very handy.

Distinction