Cari tahu apakah dua matriks simetris adalah sama hingga permutasi baris/kolomnya

Berikut adalah solusi vektor berdasarkan sorting dan memanfaatkan searchsorted -

import pandas as pd

# Sort rows for a and b
aS = np.sort(a,axis=1)
bS = np.sort(b,axis=1)

# Scale down each row to a scalar each
scale = np.r_[(np.maximum(aS.max(0),bS.max(0))+1)[::-1].cumprod()[::-1][1:],1]
aS1D = aS.dot(scale)
bS1D = bS.dot(scale)

# Use searchsorted to get the correspondence on indexing
sidx = aS1D.argsort()
searchsorted_idx = np.searchsorted(aS1D,bS1D,sorter=sidx)
searchsorted_idx[searchsorted_idx==len(aS1D)] = len(aS1D)-1
df = pd.DataFrame({'A':searchsorted_idx})
new_order = sidx[df.groupby('A').cumcount().values+searchsorted_idx]
# new_order is the permuted order, i.e. [5, 7, 1, 3, 2, 4, 6]

# Finally index into a with the new_order and compare against b
out = np.array_equal(a[new_order[:,None], new_order],b)

Saya berasumsi bahwa Anda memiliki daftar permutasi baris/kolom a yang menghasilkan b, mis. sesuatu seperti ini

p = np.array([5, 7, 1, 3, 2, 4, 6]) - 1

Kemudian Anda cukup melakukan hal berikut di a

a_p = a[p]
a_p = a_p[:, p]

dan periksa apakah b dan a_p yang diijinkan sama:

(a_p == b).all()

Edit: karena Anda tidak memiliki daftar seperti p di atas, Anda dapat (setidaknya untuk array kecil a dan b) membuat permutasi indeks dan memeriksa masing-masing indeks:

from itertools import permutations

def a_p(a, b, p):
    p = np.array(p)
    a_p = a[p]
    a_p = a_p[:, p]
    return a_p

for p in permutations(range(a.shape[0])):
    if (a_p(a, b, p) == b).all():
        print('True')
        break
else:
    print('False')

Perhatikan bahwa metode brute force ini juga berfungsi untuk matriks non-simetris. Namun karena jumlah permutasi sangat besar untuk array besar a dan b, metode ini bisa sangat lambat. Jadi solusi Anda dengan menghitung nilai eigen jauh lebih baik.

Berikut patokannya:

def Yduqoli(a, b):
    ''' I suppose your solution is similar'''
    if (np.array(np.unique(a, return_counts=True)) == np.array(np.unique(b, return_counts=True))).all():
        a_eigs = np.sort(np.linalg.eigvals(a))
        b_eigs = np.sort(np.linalg.eigvals(b))
        return np.allclose(a_eigs, b_eigs)
    else:
        return False

def AndyK(a, b):
    for p in permutations(range(a.shape[0])):
        if (a_p(a, b, p) == b).all():
            return True
    return False  

%timeit AndyK(a,b)
103 ms ± 4.54 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

%timeit Yduqoli(a,b)
408 µs ± 65.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

dimana saya menggunakan matriks simetris a dan b yang disediakan oleh OP.

Pembaruan: Seperti yang disebutkan oleh Paul Panzer, memeriksa nilai eigen saja dapat memberikan hasil yang salah dalam beberapa kasus, misalnya. a = np.array([[4, 0], [0, 0]]), b = np.array([[2, 2], [2, 2]]) mempunyai nilai eigen yang sama, namun tidak dapat dikocok satu sama lain. Jadi pertama-tama kita perlu memeriksa apakah array a dan b memiliki elemen yang sama (terlepas dari posisinya).

Anda selalu dapat mengurutkan matriks berdasarkan norma baris dan melihat apakah matriksnya berbeda. Jika dua baris memiliki norma yang sama, Anda harus memeriksa permutasi baris yang memiliki norma yang sama. Namun hal ini mengurangi masalah menjadi hanya baris dengan norma yang sama. Dalam banyak kasus, Anda dapat mengurutkan terlebih dahulu berdasarkan 2 norma, lalu 1 norma, dan terakhir melakukan brute force pada permutasi yang tersisa.

import numpy as np

def get_row_norm(a):
    """
    Sort by 2-norm
    """
    row_norms = np.sum(a**2, axis=1)
    return row_norms

def sort(a):
    """
    Return the matrix a sorted by 2-norm
    """
    n = a.shape[0]
    # Get the norms
    row_norms = get_row_norm(a)
    # Get the order
    order = np.argsort(row_norms)[::-1]

    sorted_a = a.copy()

    for m in range(n):
        i = order[m]
        for k in range(m+1): 
            j = order[k]
            sorted_a[m, k] = a[i, j]
            sorted_a[k, m] = a[i, j]

    return sorted_a


a = np.array([
    #1 #2 #3 #4 #5 #6 #7
    [0, 1, 1, 0, 0, 0, 1], #1
    [1, 0, 1, 2, 1, 1, 2], #2
    [1, 1, 0, 0, 0, 0, 1], #3
    [0, 2, 0, 0, 4, 0, 4], #4
    [0, 1, 0, 4, 0, 1, 2], #5
    [0, 1, 0, 0, 1, 0, 0], #6
    [1, 2, 1, 4, 2, 0, 0]  #7
])  
b = np.array([
    #5 #7 #1,3#3,1#2 #4 #6 
    [0, 2, 0, 0, 1, 4, 1], #5
    [2, 0, 1, 1, 2, 4, 0], #7
    [0, 1, 0, 1, 1, 0, 0], #1,3 could be either
    [0, 1, 1, 0, 1, 0, 0], #1,3 could be either
    [1, 2, 1, 1, 0, 2, 1], #2
    [4, 4, 0, 0, 2, 0, 0], #4
    [1, 0, 0, 0, 1, 0, 0]  #6
])

# Sort a and b
A = sort(a)
B = sort(b)
# Print the norms
print(get_row_norm(a)) # [ 3. 12.  3. 36. 22.  2. 26.]
print(get_row_norm(A)) # [36. 26. 22. 12.  3.  3.  2.]
print(get_row_norm(B)) # [36. 26. 22. 12.  3.  3.  2.]
# Assert that they are equal
print( (A == B).all())

Perhatikan bahwa jika keduanya tidak sama, Anda masih harus memeriksa permutasi baris kelima dan keenam, karena normanya sama.