first commit
This commit is contained in:
406
TD3b/TD3.md
Normal file
406
TD3b/TD3.md
Normal file
@@ -0,0 +1,406 @@
|
||||
```python
|
||||
# matrices from the document
|
||||
R1 = [[1,0,1],[0,1,0],[1,0,0]]
|
||||
R2 = [[1,1,0],[0,0,1],[1,0,1]]
|
||||
R3 = [[1, 1, 1], [0, 0, 1], [0, 0, 1]]
|
||||
R4 = [[1, 1, 0, 1], [1, 1, 0, 1], [0, 0, 1, 0], [1, 1, 0, 1]]
|
||||
R5 = [[0, 1, 0], [0, 0, 1], [1, 0, 0]]
|
||||
R6 = [[1, 1, 1], [0, 0, 1], [1, 0, 0]]
|
||||
|
||||
tests = [R1, R2, R3, R4, R5, R6]
|
||||
|
||||
CHAMPIONS = [[1,1,0,1,1],
|
||||
[0,1,0,0,0],
|
||||
[1,1,1,1,1],
|
||||
[1,1,0,1,1],
|
||||
[0,1,0,0,1]]
|
||||
```
|
||||
|
||||
|
||||
```python
|
||||
# Check if a matrix is reflexive
|
||||
def reflexive(R):
|
||||
for i in range(len(R)):
|
||||
if R[i][i] != 1:
|
||||
return False
|
||||
return True
|
||||
|
||||
# Check if a matrix is symmetric
|
||||
def symmetrical(R):
|
||||
for i in range(len(R)):
|
||||
for j in range(len(R)):
|
||||
if R[i][j] != R[j][i]:
|
||||
return False
|
||||
return True
|
||||
|
||||
# Check if a matrix is anti-symmetric
|
||||
def anti_symmetrical(R):
|
||||
for i in range(len(R)):
|
||||
for j in range(len(R)):
|
||||
if R[i][j] > 0 and R[j][i] > 0 and i != j:
|
||||
return False
|
||||
return True
|
||||
|
||||
# Check if a matrix is asymmetrical
|
||||
def asymmetrical(R):
|
||||
for i in range(len(R)):
|
||||
for j in range(len(R)):
|
||||
if R[i][j] > 0 and R[j][i] > 0:
|
||||
return False
|
||||
return True
|
||||
|
||||
# Check if a matrix is irreflexive
|
||||
def irreflexive(R):
|
||||
for i in range(len(R)):
|
||||
if R[i][i] > 0:
|
||||
return False
|
||||
return True
|
||||
|
||||
# Check if a matrix is transitive
|
||||
def transitive(matrix):
|
||||
is_transitive = True
|
||||
for i in range(len(matrix)):
|
||||
for j in range(len(matrix)):
|
||||
if matrix[i][j] > 0:
|
||||
for k in range(len(matrix)):
|
||||
if matrix[j][k] > 0:
|
||||
is_transitive = is_transitive and matrix[i][k] > 0
|
||||
|
||||
return is_transitive
|
||||
|
||||
# Check if a matrix is intransitive
|
||||
def intransitive(matrix):
|
||||
is_transitive = True
|
||||
for i in range(len(matrix)):
|
||||
for j in range(len(matrix)):
|
||||
if matrix[i][j] > 0:
|
||||
for k in range(len(matrix)):
|
||||
if matrix[j][k] > 0:
|
||||
is_transitive = is_transitive and matrix[i][k] != 1
|
||||
|
||||
return is_transitive
|
||||
|
||||
# Check if a matrix is non-transitive
|
||||
def non_transitive(matrix):
|
||||
n = len(matrix)
|
||||
|
||||
for i in range(n):
|
||||
for j in range(n):
|
||||
if matrix[i][j] > 0:
|
||||
for k in range(n):
|
||||
if matrix[j][k] > 0 and matrix[i][k] == 0:
|
||||
return True
|
||||
return False
|
||||
```
|
||||
|
||||
|
||||
```python
|
||||
# Testing all the matrices from the slides
|
||||
|
||||
for i in range(len(tests)):
|
||||
print("--------------------------------------------------")
|
||||
print("Matrix: R", i+1)
|
||||
a = reflexive(tests[i])
|
||||
print("reflexive: ", a)
|
||||
a = irreflexive(tests[i])
|
||||
print("irreflexive: ", a)
|
||||
a = symmetrical(tests[i])
|
||||
print("symmetrical: ", a)
|
||||
a = anti_symmetrical(tests[i])
|
||||
print("anti_symmetrical: ", a)
|
||||
a = asymmetrical(tests[i])
|
||||
print("asymmetrical: ", a)
|
||||
a = transitive(tests[i])
|
||||
print("transitive: ", a)
|
||||
a = intransitive(tests[i])
|
||||
print("intransitive: ", a)
|
||||
a = non_transitive(tests[i])
|
||||
print("non_transitive: ", a)
|
||||
```
|
||||
|
||||
--------------------------------------------------
|
||||
Matrix: R 1
|
||||
reflexive: False
|
||||
irreflexive: False
|
||||
symmetrical: True
|
||||
anti_symmetrical: False
|
||||
asymmetrical: False
|
||||
transitive: False
|
||||
intransitive: False
|
||||
non_transitive: True
|
||||
--------------------------------------------------
|
||||
Matrix: R 2
|
||||
reflexive: False
|
||||
irreflexive: False
|
||||
symmetrical: False
|
||||
anti_symmetrical: True
|
||||
asymmetrical: False
|
||||
transitive: False
|
||||
intransitive: False
|
||||
non_transitive: True
|
||||
--------------------------------------------------
|
||||
Matrix: R 3
|
||||
reflexive: False
|
||||
irreflexive: False
|
||||
symmetrical: False
|
||||
anti_symmetrical: True
|
||||
asymmetrical: False
|
||||
transitive: True
|
||||
intransitive: False
|
||||
non_transitive: False
|
||||
--------------------------------------------------
|
||||
Matrix: R 4
|
||||
reflexive: True
|
||||
irreflexive: False
|
||||
symmetrical: True
|
||||
anti_symmetrical: False
|
||||
asymmetrical: False
|
||||
transitive: True
|
||||
intransitive: False
|
||||
non_transitive: False
|
||||
--------------------------------------------------
|
||||
Matrix: R 5
|
||||
reflexive: False
|
||||
irreflexive: True
|
||||
symmetrical: False
|
||||
anti_symmetrical: True
|
||||
asymmetrical: True
|
||||
transitive: False
|
||||
intransitive: True
|
||||
non_transitive: True
|
||||
--------------------------------------------------
|
||||
Matrix: R 6
|
||||
reflexive: False
|
||||
irreflexive: False
|
||||
symmetrical: False
|
||||
anti_symmetrical: False
|
||||
asymmetrical: False
|
||||
transitive: False
|
||||
intransitive: False
|
||||
non_transitive: True
|
||||
|
||||
|
||||
|
||||
```python
|
||||
# Equivalence classes
|
||||
|
||||
def equivalence_classes(R):
|
||||
n = len(R)
|
||||
classes = []
|
||||
scores = []
|
||||
|
||||
# Count number of (x,y) existing on each row
|
||||
for x in range(n):
|
||||
score = 0
|
||||
for y in range(n):
|
||||
if R[x][y] > 0:
|
||||
score += 1
|
||||
scores.append(score)
|
||||
|
||||
lastScore = 0
|
||||
|
||||
for i in range(n):
|
||||
max_score = 0
|
||||
max_index = 0
|
||||
for j in range(n):
|
||||
if scores[j] > max_score:
|
||||
max_score = scores[j]
|
||||
max_index = j
|
||||
|
||||
if(max_score == lastScore):
|
||||
classes[len(classes)-1].append(max_index)
|
||||
else:
|
||||
# Add the class to the list of classes
|
||||
classes.append([max_index])
|
||||
|
||||
lastScore = max_score
|
||||
scores[max_index] = 0
|
||||
|
||||
return classes, scores
|
||||
|
||||
```
|
||||
|
||||
|
||||
```python
|
||||
print(equivalence_classes(CHAMPIONS))
|
||||
```
|
||||
|
||||
([[2], [0, 3], [4], [1]], [0, 0, 0, 0, 0])
|
||||
|
||||
|
||||
|
||||
```python
|
||||
def transitive_closure(adjacency_matrix):
|
||||
"""
|
||||
Calculate the transitive closure of a directed graph represented as an adjacency matrix.
|
||||
|
||||
Args:
|
||||
adjacency_matrix (list of lists): The adjacency matrix of the graph.
|
||||
|
||||
Returns:
|
||||
list of lists: The transitive closure matrix.
|
||||
"""
|
||||
n = len(adjacency_matrix)
|
||||
|
||||
# Initialize the transitive closure matrix as a copy of the adjacency matrix
|
||||
closure_matrix = [row[:] for row in adjacency_matrix]
|
||||
|
||||
# Perform the Floyd-Warshall algorithm to compute transitive closure
|
||||
for k in range(n):
|
||||
for i in range(n):
|
||||
for j in range(n):
|
||||
closure_matrix[i][j] = closure_matrix[i][j] or (closure_matrix[i][k] and closure_matrix[k][j])
|
||||
|
||||
return closure_matrix
|
||||
|
||||
# Example usage:
|
||||
adjacency_matrix = [
|
||||
[0, 1, 0, 0],
|
||||
[0, 0, 0, 1],
|
||||
[1, 0, 0, 0],
|
||||
[0, 0, 1, 0]
|
||||
]
|
||||
|
||||
ex_cours = [
|
||||
[0, 0, 1, 0],
|
||||
[0, 0, 0, 0],
|
||||
[0, 1, 1, 1],
|
||||
[1, 0, 0, 0]
|
||||
]
|
||||
|
||||
transitive_closure_matrix = transitive_closure(ex_cours)
|
||||
|
||||
# Print the transitive closure matrix
|
||||
for row in transitive_closure_matrix:
|
||||
print(row)
|
||||
|
||||
```
|
||||
|
||||
[1, 1, 1, 1]
|
||||
[0, 0, 0, 0]
|
||||
[1, 1, 1, 1]
|
||||
[1, 1, 1, 1]
|
||||
|
||||
|
||||
|
||||
```python
|
||||
# Make transitive closure
|
||||
|
||||
transitive_closure_matrix = [
|
||||
[1, 0, 0, 0],
|
||||
[0, 1, 0, 1],
|
||||
[1, 0, 0, 0],
|
||||
[0, 0, 1, 1]
|
||||
]
|
||||
|
||||
def transitive_closure(matrix):
|
||||
modification = True
|
||||
while modification:
|
||||
modification = False
|
||||
for i in range(len(matrix)):
|
||||
for j in range(len(matrix)):
|
||||
for k in range(len(matrix)):
|
||||
if matrix[i][j] > 0 and matrix[j][k] > 0 and matrix[i][k] == 0:
|
||||
matrix[i][k] = matrix[i][j] + matrix[j][k]
|
||||
modification = True
|
||||
else:
|
||||
modification = False
|
||||
|
||||
return matrix
|
||||
|
||||
full_closure = transitive_closure(ex_cours)
|
||||
|
||||
for row in full_closure:
|
||||
print(row)
|
||||
```
|
||||
|
||||
[3, 2, 1, 2]
|
||||
[0, 0, 0, 0]
|
||||
[2, 1, 1, 1]
|
||||
[1, 3, 2, 3]
|
||||
|
||||
|
||||
|
||||
```python
|
||||
# Remove transitive closure
|
||||
|
||||
transitive_closure_matrix = [
|
||||
[1, 0, 0, 0],
|
||||
[0, 1, 2, 1],
|
||||
[1, 0, 0, 0],
|
||||
[2, 0, 1, 1]
|
||||
]
|
||||
|
||||
m = [
|
||||
[1,1,1,1,1,1,1],
|
||||
[0,1,0,0,1,1,1],
|
||||
[0,0,1,0,0,0,1],
|
||||
[0,0,0,1,1,1,1],
|
||||
[0,0,0,0,1,1,1],
|
||||
[0,0,0,0,0,1,1],
|
||||
[0,0,0,0,0,0,1]
|
||||
]
|
||||
|
||||
def remove_transitive_closure(matrix):
|
||||
n = len(matrix)
|
||||
modification = True
|
||||
|
||||
while modification:
|
||||
# reset modification
|
||||
modification = False
|
||||
for i in range(n):
|
||||
for j in range(n):
|
||||
# checking if there is a path from i to j
|
||||
if matrix[i][j] > 0:
|
||||
for k in range(j,n):
|
||||
# checking if there is a path from i k to to k
|
||||
if matrix[i][k] > 0 and matrix[j][k] > 0:
|
||||
matrix[i][k] = 0
|
||||
modification = True
|
||||
print("Removing ", i, k)
|
||||
# restart while loop
|
||||
break
|
||||
if modification:
|
||||
break
|
||||
|
||||
return matrix
|
||||
|
||||
no_closure = remove_transitive_closure(transitive_closure_matrix)
|
||||
|
||||
for row in no_closure:
|
||||
print(row)
|
||||
|
||||
no_closure = remove_transitive_closure(m)
|
||||
|
||||
for row in no_closure:
|
||||
print(row)
|
||||
```
|
||||
|
||||
Removing 0 0
|
||||
Removing 1 1
|
||||
Removing 1 3
|
||||
Removing 3 3
|
||||
[0, 0, 0, 0]
|
||||
[0, 0, 2, 0]
|
||||
[1, 0, 0, 0]
|
||||
[2, 0, 1, 0]
|
||||
Removing 0 0
|
||||
Removing 1 1
|
||||
Removing 2 2
|
||||
Removing 3 3
|
||||
Removing 4 4
|
||||
Removing 5 5
|
||||
Removing 6 6
|
||||
Removing 0 4
|
||||
Removing 1 5
|
||||
Removing 3 5
|
||||
Removing 4 6
|
||||
Removing 0 6
|
||||
[0, 1, 1, 1, 0, 1, 0]
|
||||
[0, 0, 0, 0, 1, 0, 1]
|
||||
[0, 0, 0, 0, 0, 0, 1]
|
||||
[0, 0, 0, 0, 1, 0, 1]
|
||||
[0, 0, 0, 0, 0, 1, 0]
|
||||
[0, 0, 0, 0, 0, 0, 1]
|
||||
[0, 0, 0, 0, 0, 0, 0]
|
||||
|
||||
Reference in New Issue
Block a user