Menggunakan Python untuk menyelesaikan masalah pelbagai penyelesaian untuk sistem persamaan binari

Artikel ini akan memperkenalkan cara menyelesaikan pelbagai penyelesaian untuk sistem persamaan binari dengan nilai berubah 0 atau 1 menggunakan python. Idea utama untuk menyelesaikan masalah ini adalah menggunakan pengetahuan aljabar linear untuk mengubah masalah ke dalam menyelesaikan sistem persamaan linear. Langkah -langkah khusus termasuk: mencari penyelesaian khas, menyelesaikan penyelesaian umum persamaan homogen, dan kemudian menggabungkan penyelesaian khas dengan penyelesaian umum untuk mendapatkan semua penyelesaian yang mungkin.

Cari idea

1. Menukar sistem persamaan ke bentuk matriks : Menukar sistem persamaan asal ke dalam bentuk matriks pekali dan vektor malar.
2. Kaedah Penghapusan Gaussian : Gunakan kaedah penghapusan Gaussian untuk memudahkan matriks pekali ke dalam bentuk tangga baris.
3. Mencari Penyelesaian Khas : Cari penyelesaian khas yang memenuhi sistem persamaan asal.
4. Menyelesaikan penyelesaian umum persamaan homogen : menyelesaikan penyelesaian umum sistem persamaan homogen yang sepadan.
5. Menggabungkan penyelesaian khas dan penyelesaian umum : Menggabungkan penyelesaian khas dengan penyelesaian umum untuk mendapatkan semua penyelesaian yang mungkin.

Contoh kod

Kod berikut menunjukkan cara menggunakan perpustakaan iTerTools untuk menghasilkan semua kombinasi pembolehubah yang mungkin dan mengesahkan bahawa mereka memenuhi sistem persamaan. Walaupun kaedah ini tidak cekap, mudah difahami.

 dari produk import itertools

# Tentukan sistem persamaan def check_solution (x, y, z, v, w):
    Kembali (
        (x ^ z == 1) dan
        (x ^ y ^ z ^ v ^ w == 1) dan
        (v ^ w == 1) dan
        (y == 1)
    )

# melintasi semua kemungkinan kombinasi pembolehubah untuk x, y, z, v, w dalam produk ([0, 1], ulangi = 5):
    Jika check_solution (x, y, z, v, w):
        Cetak (x, y, z, v, w)

Kod di atas semata -mata dan kira -kira melintasi semua penyelesaian yang mungkin dan mengesahkannya. Kod berikut menunjukkan proses penyelesaian menggunakan kaedah penghapusan Gaussian:

 dari produk import itertools

XP, YP, ZP, VP, WP = (0, 1, 1, 0, 1)

yh = 0
Untuk XH, VH dalam produk (julat (2), ulangi = 2):
    ZH, WH = XH, VH
    x, y, z, v, w = (xp ^ xh, yp ^ yh, zp ^ zh, vp ^ vh, wp ^ wh)

    menegaskan x ^ z == 1
    menegaskan x ^ y ^ z ^ v ^ w == 1
    menegaskan v ^ w == 1
    menegaskan y == 1
    Cetak (x, y, z, v, w)

Gunakan perpustakaan galois dan sympy

Untuk penyelesaian yang lebih cekap, perpustakaan Galois dan Sympy boleh digunakan. Pertama, anda perlu memasang dua perpustakaan ini:

 PIP Pasang Galois Numpy Sympy

Kemudian, anda boleh menggunakan kod berikut:

 dari Galois Import GF2
Dari HSTACK Import Numpy, Zeros
dari Numpy.Linalg Import Solve, Linalgerror
dari kombinasi import itertools

dari matriks import sympy, simbol
dari import sympy solve_linear_system

A = gf2 ((
    (1, 0, 1, 0, 0,),
    (1, 1, 1, 1, 1),
    (0, 0, 0, 1, 1),
    (0, 1, 0, 0, 0),
)))
b = gf2 (((1, 1, 1, 1))).
AB = hstack ((a, b))

# Gaussian penghapusan ab_reduced = ab.row_space ()
A_reduced = ab_reduced [:,: -1]
b_reduced = ab_reduced [:, -1:]

# Cari penyelesaian khas n_eqs, n_vars = a_reduced.shape

untuk IDX dalam kombinasi (julat (n_vars), r = n_eqs):
    Cuba:
        sol = menyelesaikan (a_reduced [:, idx], b_reduced)
        rehat
    Kecuali Linalgerror:
        lulus

khususnya_solution = n_vars * [0]
Untuk J, saya di Enumerate (IDX):
    khususnya_solution [i] = int (b_reduced [j])
khususnya_solution = gf2 (khususnya_solution)

# Menyelesaikan penyelesaian umum persamaan homogen sifar_col = gf2 ((sifar (n_eqs, dtype = int),)).
x, y, z, v, w = simbol ("xyzvw")
A_homogenous = hstack ((a_reduced, sifar_col))
solve_linear_system (matriks (a_homogenous), x, y, z, v, w)

Perkara yang perlu diperhatikan

• Perpustakaan Sympy tidak dapat mengenali sepenuhnya domain GF (2), jadi hasilnya mungkin memerlukan pelarasan manual.
• Dalam aplikasi praktikal, adalah perlu untuk memilih kaedah penyelesaian yang sesuai berdasarkan ciri -ciri sistem persamaan.
• Untuk sistem persamaan berskala besar, adalah disyorkan untuk menggunakan perpustakaan algebra linear yang lebih cekap.

Meringkaskan

Artikel ini memperkenalkan dua kaedah untuk menyelesaikan masalah pelbagai penyelesaian sistem persamaan binari menggunakan Python: Kaedah Penghitungan Kekuatan Brute dan kaedah berasaskan algebra linear. Kaedah berasaskan algebra linear menggunakan kaedah penghapusan Gaussian untuk memudahkan sistem persamaan, dan menggabungkan perpustakaan Galois dan sympy untuk menyelesaikan masalah dengan lebih cekap. Dalam aplikasi praktikal, adalah perlu untuk memilih penyelesaian yang sesuai berdasarkan skala dan ciri -ciri masalah.

Atas ialah kandungan terperinci Menggunakan Python untuk menyelesaikan masalah pelbagai penyelesaian untuk sistem persamaan binari. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!