Ошибка с построением графиков

import math
import numpy as np
import random
import time
import matplotlib.pyplot as plt
 
#Формирование рандомной матрицы
n=3
def Am(n):
    x = np.zeros((n, n))
    for i in range(0,n):
        for j in range(0,n):
            x[i][j] = np.random.uniform(0, 20)
    #print(x)
    
    b = np.zeros((n, 1))
    for i in range(0, n):
        b[i] = np.random.uniform(0, 20)
    #print(b)
    return x, b
 
A = Am(n)[0]
print("\nЛевая часть матрицы: ")
print(A)
B = Am(n)[1]
print("\nПравая часть матрицы: ")
print(B)
 
m = np.concatenate((A,B),axis=1)
print("\nОбщая матрица: ")
print(m)
 
#Метод вращений
def solve_with_rotation(m):
    n = m.shape[0]
 
    # прямой ход
    for i in range(n-1):
        for j in range(i + 1, n):
            c = m[i, i] / (m[i, i]**2 + m[j, i]**2) ** .5
            s = m[j, i] / (m[i, i]**2 + m[j, i]**2) ** .5
            tmp1 = m[i, :] * c + m[j, :] * s
            tmp2 = m[i, :] * -s + m[j, :] * c
            m[i, :] = tmp1
            m[j, :] = tmp2
    
 
    # вывод ошибки
    if is_singular(m):
        print('Данная система имеет бесконечное количество решений')
        return
 
    # обратный метод
    x = np.matrix([0.0 for i in range(n)]).T
    for k in range(n - 1, -1, -1):
        x[k, 0] = (m[k, -1] - m[k, k:n] * x[k:n, 0]) / m[k, k]
 
    # Вывод результатов
    print("\nПреобразованная матрица: ")
    print(m)
    print("\nПо методу вращений:")
    print(x)
 
 
#Проверка на ошибку
def is_singular(m):
    return np.any(np.diag(m) == 0)
 
def bubble_max_row(m, k):
    
    ind = k + np.argmax(np.abs(m[k:, k]))
    if ind != k:
        m[k, :], m[ind, :] = np.copy(m[ind, :]), np.copy(m[k, :])
 
 
def solve_gauss(m):
    
    n = m.shape[0]
    # прямой ход
    for k in range(n - 1):
        bubble_max_row(m, k)
        for i in range(k + 1, n):
            # modify row
            frac = m[i, k] / m[k, k]
            m[i, :] -= m[k, :] * frac
 
    # вывод ошибки
    if is_singular(m):
        print('Данная система имеет бесконечное количество решений')
        return
 
    # обратный ход
    x = np.matrix([0.0 for i in range(n)]).T
    for k in range(n - 1, -1, -1):
        x[k, 0] = (m[k, -1] - m[k, k:n] * x[k:n, 0]) / m[k, k]
 
    # вывод результата
    print(x)
 
 
def is_singular(m):
    
    return np.any(np.diag(m) == 0)
 
#Вывод общих результатов
print(*"\n********МЕТОД ВРАЩЕНИЙ********")
print("\nИсходная матрица:")
print(m)
solve_with_rotation(m)
print("\nРешение по Гауссу: ")
solve_gauss(m)
 
#Расчет невязки между встроенным методом и методом вращений
def discrepancy1(n):
    A = Am(n)[0]
    b = Am(n)[1]
    solve = np.linalg.solve(A, b)
    x1 = solve_with_rotation(m)
    x = np.asarray(x1)
    b1 = A.dot(solve)
    b2 = A.dot(x)
    d1 = 0
    for i in range (0, n - 1):
        d1 = d1 + (b1[i] - b2[i]) ** 2
    d = (1 / n) * math.sqrt(d1)
    return d
 
def T1(n):
    t1 = time.time()
    solve_with_rotation(m)
    t2 = time.time()
    t = t2 - t1
    return t
 
def T2(n):
    t1 = time.time()
    solve_gauss(m)
    t2 = time.time()
    t = t2 - t1
    return t
 
def chart():      
      a = []
      aa = []
      g = []
      for i in range (100, 200):
          a.append(T1(i))
          aa.append(T2(i))
          g.append(i)
      fig, flt = plt.subplots()
      plt.xlim(100, 200)
      flt.semilogy(g, a, 'r', g, aa, 'b')
      flt.legend(['Метод вращений', 'Метод Гаусса'])
      plt.show()
      
      a1 = []
      #a2 = []
      g = []
      for i in range (100, 200):
          g.append(i)
          a1.append(discrepancy1(i + 1))
          #a2.append(discrepancy2(i + 1))
      fig, gt = plt.subplots()
      plt.xlim(100, 200)
      gt.semilogy(g, a1, 'r')#, g, a2, 'b')
      gt.legend(['Вращений - встроенный', 'Гаусс - встроенный'])
      plt.show() 
chart()

...x1 = solve_with_rotation(m)...