## 1. Overview

The core of this course is the concept of the network - the network is a mode of interrelationship between things. For example, the social network we are in reflects the social connection between friends. wait.

### 1.1 basic problems of network

##### Let's start with the network structure in several societies

The presentation and annotation of loan networks among financial institutions reveal different parts and their functions.

The network structure of political blog before 2004 US presidential election

##### Behavior and dynamics

When people talk about the connectivity of complex systems, they are actually talking about two related issues - connectivity at the structural level (who is connected with whom); connectivity at the behavioral level (each individual's actions have implicit consequences for each other in the system)

Changes in the amount of Youtube queries on Google over time

The visibility of this increase is the aggregation effect of the whole crowd behavior. To understand how these processes work, and how they are implemented by many people's interconnected behaviors, we need to study the dynamics of aggregation behavior.

##### The interweaving of multidisciplinary thoughts

Will use the idea of mathematical modeling, modeling is a very important idea, is the process of converting practical problems into mathematical problems. "Knowledge that cannot be described in mathematical language cannot be called science, and practical problems that cannot be modeled cannot be considered as practical solutions." (bragging from someone) it's important anyway.

One of the central objectives of this book is to combine research practices in various fields to help form such a synthesis.

### 1.2 core content of the book

Two main theories are graph theory and game theory.

Needless to say, people who have not studied graph theory cannot be called computer learners.

Game theory is the feature of this book - game theory provides a model of individual behavior, the point is that the result of individual behavior depends on the behavior of other individuals.

## 2. Experiment

### 2.1 calculation of aggregation coefficient and neighborhood overlap

#### requirement

Input: adjacency matrix of any graph

Output:

1) Aggregation factor per node

2) Neighborhood overlap of each node pair

#### Related definitions

1) Ternary closure: in a social circle, if two people have a common friend, the possibility of these two people becoming friends in the future will increase.

2) Aggregation coefficient: the aggregation coefficient of node a is defined as the probability that any two friends of node a are friends with each other - that is, the ratio of the actual number of edges between adjacent nodes of node A / the number of pairs of adjacent nodes of node a

The aggregation coefficient a) is 1 / 6 B) is 1 / 2 in the figure below

3) Bridge and local bridge: Bridge refers to the only path between two endpoints, as shown in the figure below, the edge between A and B is the bridge.

Shortcut: if endpoint A and B of edge AB have no common friends, then edge AB is called shortcut. As shown below

Relationship: it is obvious from the figure that the bridge must be a shortcut, but the shortcut is not necessarily a bridge

4) Strong ternary closure property: all relationships in social networks are divided into two types: strong connection (friend) and weak connection (acquaintance). If the relationship between node A and node B and C is strong, and there is no connection (strong or weak) between node B and C, then node a violates the strong ternary closure property. Otherwise, node a satisfies the strong ternary closure property

All points in the following graph satisfy the strong ternary closure property

5) Shortcut and weak connection: in social networks, if node A satisfies the strong ternary closure property and has at least two strong connection edges connected with it, then any shortcut connected with it is weak connection

The proof is as follows:

6) Neighborhood overlap degree: defines the neighborhood overlap degree of an edge as: the number of nodes with A and B as neighbors / the number of nodes with A and B as neighbors (excluding A and B)

It can be seen that when the molecule is zero, that is, the neighborhood overlap is zero, this side is a shortcut

#### Algorithm and code

Algorithm: 1) calculate the aggregation coefficient: first, calculate the number of possible connections between all nodes connected with the current node (calculation method: (degree (degree-1) / 2) (using the sequence of equal difference numbers), which will be used as the denominator, and then calculate how many nodes are actually connected, which will be used as the numerator. 2) Find neighborhood overlap: define the ratio of "node number of neighbors with A and B" and "node number of neighbors with at least one of A and B" of (A, B) edge

The input is as follows:

Graph structure (use adjacency matrix to store graph structure. The UML class diagrams of the three main classes are as follows):

Main code:

graph

template <class T> class graph{ public: virtual ~graph(){}; virtual int numberOfVertices() const = 0; virtual int numberOfEdges() const = 0; virtual bool existsEdge(int ,int ) const = 0; virtual void insertEdge(edge<T>* ) = 0;//edge is a template class virtual void easeEdge(int ,int ) = 0; virtual int degree(int) const = 0; virtual int inDegree(int ) const = 0; virtual int outDegree(int ) const = 0; virtual bool directed() const = 0; virtual bool weighted() const = 0; //Access adjacent vertices s of specified vertices virtual vertexIterator<T>* iterators(int ) = 0; };

adjacencyWDigraph

template <class T> class adjacencyWDigraph : public graph<T>{ protected: int n; int e; T noEdge;//Indicates an edge that does not exist public: T **a;//adjacency matrix //1. Constructor with default parameters adjacencyWDigraph(int nV = 0,T theNoEdge =0){ if(nV < 0){ throw "Number of vertices must be greater than 0!"; } n = nV; e = 0; noEdge = theNoEdge; //make2dArray(a,n+1,n+1); //Create adjacency matrix a = new T*[n+1];//The array of arrays is a two-dimensional array for (int j = 1; j <=n ; ++j) { a[j] = new T[n+1]; } for (int i = 1; i <= n ; ++i) { //Initialize adjacency matrix for (int j = 1; j <=n ; ++j) { a[i][j] = noEdge; } } } int numberOfVertices() const { return n;} int numberOfEdges() const { return e;} bool directed() const { return true;} bool weighted() const { return true;} //2. Judge whether (i, j) edge exists bool existsEdge(int i,int j) const{ if (i<1||j<1||i>n||j>n||a[i][j] == noEdge){ return false; } else{ return true; } } //3. Insert edge void insertEdge(edge<T>* theEdge){ int v1 = theEdge->vertex1(); int v2 = theEdge->vertex2(); if(v1<1||v2<1||v1>n||v2>n||v1==v2){ throw "This insertion is illegal!"; } else{ if (a[v1][v2] == noEdge){ e++; } a[v1][v2] = theEdge->weight(); } } //4. Delete edge void easeEdge(int i,int j){ if(existsEdge(i,j)){ a[i][j] = noEdge; e--; } } //5. Degree of vertex int degree(int theV) const{ throw "Directed graph has the difference between in degree and out degree!"; } //6. In and out int outDegree(int theV) const { int sum = 0; for (int i = 1; i <= n; ++i) { if (a[theV][i] != noEdge){ sum++; } } return sum ; } int inDegree(int theV) const{ int sum = 0; for (int i = 1; i <= n ; ++i) { if(a[i][theV] != noEdge){ sum++; } } return sum; } //7. Ergodic class class myIterator : public vertexIterator<T>{ public: myIterator(T* theRow,T theNoEdge,int numberOfV){ row = theRow; noEdge = theNoEdge; n = numberOfV; currentVertex = 1; } ~myIterator(){} int next(T & theWeight){ for (int i = currentVertex; i <= n ; ++i) { if (row[i] != noEdge){ currentVertex = i+1; theWeight = row[i]; return i; } } //There is no next adjacent vertex currentVertex = n+1; return 0; } int next(){ for (int i = currentVertex; i <= n ; ++i) { if (row[i] != noEdge){ currentVertex = i+1; return i; } } //There is no next adjacent vertex currentVertex = n+1; return 0; } protected: T* row; T noEdge; int n; int currentVertex; }; myIterator* iterators(int theV){ return new myIterator(a[theV],noEdge,n); } };

adjacencyWGraph

template<class T> class adjacencyWGraph : public adjacencyWDigraph<T> { public: adjacencyWGraph(int numberOfVertices = 0, T theNoEdge = 0) : adjacencyWDigraph<T>(numberOfVertices, theNoEdge) {} void insertEdge(int v1, int v2, int weight) { if (v1 < 1 || v2 < 1 || v1 > this->n || v2 > this->n || v1 == v2) { throw "Illegal insertion!"; } //Insert if edge does not exist if (this->a[v1][v2] == this->noEdge) this->e++; this->a[v1][v2] = weight; this->a[v2][v1] = weight; } bool directed() const { return false; } void eraseEdge(int i, int j) { if (i >= 1 && j >= 1 && i <= this->n && j <= this->n && this->a[i][j] != this->noEdge) { this->a[i][j] = this->noEdge; this->a[j][i] = this->noEdge; this->e--; } } int degree(int theVertex) const { int sum = 0; for (int j = 1; j <= this->n; j++) if (this->a[theVertex][j] != this->noEdge) sum++; return sum; } int outDegree(int theVertex) const { return degree(theVertex); } int inDegree(int theVertex) const { return degree(theVertex); } //Any two friends returned to A are also friends int getFriendsIsFriends(int iE) { int *friends = new int[degree(iE)]; int start = 0; for (int j = 1; j <= this->n; ++j) { if (this->existsEdge(iE, j)) { friends[start++] = j; //Cout < < adjacent vertices are: < J < < endl; } } int friendsIsFriends = 0; //Check whether friends are friends for (int i = 0; i < degree(iE); i++) { //Check the value of this line for (int k = 0; k < degree(iE) - 1 - i; k++) { int a = friends[i]; int b = friends[i + 1 + k]; if (this->existsEdge(a, b)) { friendsIsFriends++; } } } return friendsIsFriends; } //Returns the vertex adjacent to vertex i int *getEdges(int i) { int *my_result = new int[this->degree(i)]; //Cout < < I < < the degree is: < this - > degree (I) < endl; int start = 0; for (int j = 1; j <= this->n ; ++j) { if (this->existsEdge(i,j)){ my_result[start++] = j; // The critical points of cout < I < are < J < endl; } } //Several adjacent points of cout < < I < < are: < sizeof (my_ Result) < endl; / / returns the size of the pointer return my_result; } };

Find the aggregation coefficient

string aggCoeff[n+1];//Record the aggregation coefficient of each vertex for (int k = 1; k <= n; ++k) { int my_degree = 0; my_degree = graph.degree(k); //Cout < < degree is < < My_ degree<<endl;cout<<endl; int denominator = my_degree*(my_degree-1)/2; if (denominator==0){ aggCoeff[k]="0"; } else{ int molecule = graph.getFriendsIsFriends(k); //Cout < < molecular is: < molecular < < endl; if(molecule==0){ aggCoeff[k]="0"; } else{ int temp=molecule/denominator; if(temp==1){ aggCoeff[k]="1"; } else{ aggCoeff[k]=to_string(molecule)+"/"+to_string(denominator); } } } } for (int l = 1; l <= n; ++l) { cout<<"vertex"<<l<<"The aggregation coefficient of is:"<<aggCoeff[l]<<endl; }

Find the aggregation coefficient between neighbors

//Record the neighborhood overlap of each pair of adjacent nodes string *degreeEdges = new string[e]; int start2 = 0; for (int m = 1; m < n ; ++m) { for (int i = m+1; i <=n ; ++i) { if (graph.existsEdge(m,i)){ //Obtain the vertex adjacent to A and B int *getAEdges = graph.getEdges(m); int *getBEdges = graph.getEdges(i); int legA = graph.degree(m); int legB = graph.degree(i); if(legA==1&&legB==1){ degreeEdges[start2++]="0"; } else{ int denominator = getDeno(getAEdges,getBEdges,legA,legB); int molecule = getCoin(getAEdges,getBEdges,legA,legB); if(denominator==molecule){ degreeEdges[start2++]="1"; } else if(molecule==0){ degreeEdges[start2++]="0"; } else{ degreeEdges[start2++]=to_string(molecule)+"/"+to_string(denominator); } } cout<<"Side("<<m<<","<<i<<")The degree of neighborhood overlap between them is:"<<degreeEdges[start2-1]<<endl; } } }

### 2.2 Schelling model simulation

#### requirement

Input: matrix of n*n, two nodes of random layout

Output:

1) Output corresponding results after adjusting parameters

2) Need interface display

#### Related definitions

1) Homogeneity: we and our friends tend to have the same characteristics, that is, as the proverb goes, "birds of a feather flock together, and people flock together."

2) Choice and social influence: Choice - people choose friends with more similar characteristics, which is a subjective behavior. Social impact - people change their behavior because they need to be consistent with their friends, which is an objective impact.

3) Community: the focus of social interaction.

4) Affiliation Networks: indicates the individual's affiliation to the community. It's a bipartite graph.

5) Social affiliation network: it includes not only the social networks among individuals, but also the affiliation networks between individuals and communities.

The principle of ternary closure has a new development in social belonging network

6) Social closure: two individuals tend to establish a connection because they participate in the same community.

7) membership closure: individual B will tend to join the community in which friend A participates.

We can see that community closure is a subjective choice and membership closure is an objective social impact.

8) Schelling model: describes the effect of homogeneity on spatial isolation. (Chinatown and ghettos in the United States are examples of Schelling's model. )

#### Algorithm and code

1) Thought:

The basic constraint of this model is that each agent must be a neighbor with a certain number of similar agents. We assume that the threshold value t is applicable to all agents: if an agent finds that he has fewer neighbors than t, he is interested in moving to other units. We call such agents dissatisfied with the status quo. For example, figure (a) is a kind of annotation of figure (b). Unsatisfactory agents use "*" to indicate that the corresponding threshold value is equal to 3. We also add a number after each agent, which is equivalent to giving each agent a name. However, the key here is to distinguish whether the agent belongs to a thousand X type or an O type.

Figure (b)

Figure (a)

2) Algorithm: gradually detect whether each pixel is lower than the threshold value, if lower than the threshold value, move.

3) Key code:

%Calculate the number of pixels according to the percentage empty_tmp = round(m * empty / 100); ratio_tmp = round((m - empty_tmp) * ratio / 100); sim_tmp = sim / 100; str_tmp = get(handles.round_text,'String'); %obtain ROUND NUMBER String of not_satis_red=[]; %Initialization dissatisfied red dot sequence not_satis_blue=[];%Not satisfied with the initialization of blue dot sequence empty_now=[];%Initializing a sequence of blank pixels %R(i,j)=1 For empty, 2 for red dot, 3 for blue dot for i=1:size for j=1:size switch R(i,j) case 1 empty_now = [empty_now (j-1)*size+i]; case 2 satis_tmp = 0; amount_tmp = 0; %Unsatisfied detection if i ~= 1 && R(i-1,j) == R(i,j) satis_tmp = satis_tmp + 1; end if i ~= 1 && j ~= 1 && R(i-1,j-1) == R(i,j) satis_tmp = satis_tmp + 1; end if i ~= 1 && j ~= size && R(i-1,j+1) == R(i,j) satis_tmp = satis_tmp + 1; end if j ~= 1 && R(i,j-1) == R(i,j) satis_tmp = satis_tmp + 1; end if j ~= size && R(i,j+1) == R(i,j) satis_tmp = satis_tmp + 1; end if i ~= size && j ~= 1 && R(i+1,j-1) == R(i,j) satis_tmp = satis_tmp + 1; end if i ~= size && R(i+1,j) == R(i,j) satis_tmp = satis_tmp + 1; end if i ~= size && j ~= size && R(i+1,j+1) == R(i,j) satis_tmp = satis_tmp + 1; end if i ~= 1 && j ~= 1 && R(i-1,j-1) ~= 1 amount_tmp = amount_tmp + 1; end if i ~= 1 && R(i-1,j) ~= 1 amount_tmp = amount_tmp + 1; end if i ~= 1 && j ~= size && R(i-1,j+1) ~= 1 amount_tmp = amount_tmp + 1; end if j ~= 1 && R(i,j-1) ~= 1 amount_tmp = amount_tmp + 1; end if j ~= size && R(i,j+1) ~= 1 amount_tmp = amount_tmp + 1; end if i ~= size && j ~= 1 && R(i+1,j-1) ~= 1 amount_tmp = amount_tmp + 1; end if i ~= size && R(i+1,j) ~= 1 amount_tmp = amount_tmp + 1; end if i ~= size && j ~= size && R(i+1,j+1) ~= 1 amount_tmp = amount_tmp + 1; end if satis_tmp<round(sim_tmp*amount_tmp) not_satis_red =[not_satis_red (j-1)*size+i]; end case 3 satis_tmp = 0; amount_tmp = 0; if i ~= 1 && R(i-1,j) == R(i,j) satis_tmp = satis_tmp + 1; end if i ~= 1 && j ~= 1 && R(i-1,j-1) == R(i,j) satis_tmp = satis_tmp + 1; end if i ~= 1 && j ~= size && R(i-1,j+1) == R(i,j) satis_tmp = satis_tmp + 1; end if j ~= 1 && R(i,j-1) == R(i,j) satis_tmp = satis_tmp + 1; end if j ~= size && R(i,j+1) == R(i,j) satis_tmp = satis_tmp + 1; end if i ~= size && j ~= 1 && R(i+1,j-1) == R(i,j) satis_tmp = satis_tmp + 1; end if i ~= size && R(i+1,j) == R(i,j) satis_tmp = satis_tmp + 1; end if i ~= size && j ~= size && R(i+1,j+1) == R(i,j) satis_tmp = satis_tmp + 1; end if i ~= 1 && j ~= 1 && R(i-1,j-1) ~= 1 amount_tmp = amount_tmp + 1; end if i ~= 1 && R(i-1,j) ~= 1 amount_tmp = amount_tmp + 1; end if i ~= 1 && j ~= size && R(i-1,j+1) ~= 1 amount_tmp = amount_tmp + 1; end if j ~= 1 && R(i,j-1) ~= 1 amount_tmp = amount_tmp + 1; end if j ~= size && R(i,j+1) ~= 1 amount_tmp = amount_tmp + 1; end if i ~= size && j ~= 1 && R(i+1,j-1) ~= 1 amount_tmp = amount_tmp + 1; end if i ~= size && R(i+1,j) ~= 1 amount_tmp = amount_tmp + 1; end if i ~= size && j ~= size && R(i+1,j+1) ~= 1 amount_tmp = amount_tmp + 1; end if satis_tmp<round(sim_tmp*amount_tmp) not_satis_blue =[not_satis_blue (j-1)*size+i]; end end end end