使用Python和NumPy生成并筛选具有特定结构和关联条件的3x3矩阵教程

from itertools import product
import numpy as np

m = 3  # 行数
n = 3  # 列数

# 生成所有可能的 3x3 矩阵，元素来自 "012"
# product("012", repeat=m*n) 会生成所有长度为 m*n 的字符串组合，
# 例如 "000000000", "000000001", ...
all_flat_matrices = product("012", repeat=m*n)

# 将扁平的字符串组合转换为 3x3 的 NumPy 矩阵列表
# list(i[x:x+m]) 将每个长度为 m*n 的字符串切片成 m 个长度为 m 的子字符串，
# 从而形成一行。外层列表推导式将这些行组合成矩阵。
# 注意：初始转换为字符串列表，后续需要转换为整数类型的 NumPy 数组。
initial_matrices = []
for p_tuple in all_flat_matrices:
    # 将元组连接成字符串，然后切片
    s = "".join(p_tuple)
    matrix_rows = []
    for x in range(0, len(s), m):
        matrix_rows.append(list(s[x:x+m]))
    initial_matrices.append(matrix_rows)

print(f"共生成 {len(initial_matrices)} 个初始矩阵。") # 3^(3*3) = 3^9 = 19683

# ... (接上面的代码)

filtered_matrices = []
for j_list in initial_matrices:
    # 将列表转换为整数类型的 NumPy 数组，以便进行数值操作
    j = np.array(j_list, dtype=int)

    # 检查条件
    condition_1 = np.all(j[0, :] == np.arange(m))
    condition_2 = np.all(j[:, 0] == np.arange(n))

    # 检查复杂内部关联条件
    # 注意：这些条件可能导致非常稀疏的解空间
    condition_3 = np.all(j[1:, :] + np.arange(m) == j[:-1, :]) # a_ik + k = a_{i-1, k}
    condition_4 = np.all(j[:, 1:] + np.arange(n) == j[:, :-1]) # a_ik + i = a_{i, k-1} (这里 i 是行索引，k 是列索引，但np.arange(n)是列索引)
                                                              # 实际上是 a_ki + k = a_{k, i-1}
    condition_5 = np.all(j[0, :] + np.arange(n) == j[:, 0])    # a_0k + k = a_k0
    associativity_condition = np.all(j[1:, 1:] == j[:-1, :-1]) # a_ik = a_{i-1, k-1} for i,k > 0

    # 所有条件都满足时，添加矩阵到结果列表
    if condition_1 and condition_2 and condition_3 and condition_4 and condition_5 and associativity_condition:
        filtered_matrices.append(j)

print(f"满足所有条件的矩阵数量: {len(filtered_matrices)}")
print("满足条件的矩阵列表:")
for mat in filtered_matrices:
    print(mat)
    print("-" * 10)

from itertools import product
import numpy as np

def generate_and_filter_matrices():
    """
    生成所有可能的 3x3 矩阵，元素来自 {0,1,2}，
    并筛选出满足特定首行、首列固定值及复杂内部关联条件的矩阵。
    """
    m = 3  # 矩阵的行数
    n = 3  # 矩阵的列数

    # 1. 生成所有可能的 3x3 矩阵
    # itertools.product("012", repeat=m*n) 生成所有 3^(m*n) 种组合
    all_flat_matrices_iter = product("012", repeat=m*n)

    filtered_matrices = []

    for p_tuple in all_flat_matrices_iter:
        # 将元组连接成字符串，然后切片转换为 3x3 列表
        s = "".join(p_tuple)
        matrix_rows_str = [list(s[x:x+m]) for x in range(0, len(s), m)]

        # 转换为整数类型的 NumPy 数组
        j = np.array(matrix_rows_str, dtype=int)

        # 2. 应用筛选条件
        # 条件1: 首行必须是 [0, 1, 2]
        condition_1 = np.all(j[0, :] == np.arange(m))

        # 条件2: 首列必须是 [0, 1, 2]
        condition_2 = np.all(j[:, 0] == np.arange(n))

        # 条件3: 行间关系 a_ik + k = a_{i-1, k} (对于 i > 0)
        # j[1:, :] 对应第二行及以下，j[:-1, :] 对应第一行及以上
        # np.arange(m) 对应列索引 [0, 1, 2]
        condition_3 = np.all(j[1:, :] + np.arange(m) == j[:-1, :])

        # 条件4: 列间关系 a_ik + i = a_{i, k-1} (对于 k > 0)
        # j[:, 1:] 对应第二列及右侧，j[:, :-1] 对应第一列及左侧
        # np.arange(n) 对应行索引 [0, 1, 2]
        condition_4 = np.all(j[:, 1:] + np.arange(n) == j[:, :-1])

        # 条件5: 首行与首列的关联 a_0k + k = a_k0
        condition_5 = np.all(j[0, :] + np.arange(n) == j[:, 0])

        # 关联性条件: a_ik = a_{i-1, k-1} (对于 i,k > 0)
        # j[1:, 1:] 对应右下角的 2x2 子矩阵，j[:-1, :-1] 对应左上角的 2x2 子矩阵
        associativity_condition = np.all(j[1:, 1:] == j[:-1, :-1])

        # 所有条件都满足时，将矩阵添加到结果列表
        if (condition_1 and condition_2 and condition_3 and 
            condition_4 and condition_5 and associativity_condition):
            filtered_matrices.append(j)

    return filtered_matrices

if __name__ == "__main__":
    result_matrices = generate_and_filter_matrices()
    print(f"满足所有条件的矩阵数量: {len(result_matrices)}")
    print("满足条件的矩阵列表:")
    for mat in result_matrices:
        print(mat)
        print("-" * 10)