Upload
duongphuc
View
265
Download
0
Embed Size (px)
Citation preview
KONSTRUKSI KODE LINEAR BINER OPTIMAL KUAT
BERJARAK MINIMUM 13 DAN 15
HENDRAWAN
SEKOLAH PASCASARJANA INSTITUT PERTANIAN BOGOR
BOGOR 2012
PERNYATAAN MENGENAI TESIS DAN SUMBER INFORMASI
Dengan ini saya menyatakan bahwa tesis berjudul Konstruksi Kode Linear Biner Optimal Kuat Berjarak Minimum 13 dan 15 adalah karya saya dengan arahan dari komisi pembimbing dan belum diajukan dalam bentuk apapun kepada perguruan tinggi mana pun. Sumber informasi yang berasal atau dikutip dari karya yang diterbitkan maupun yang tidak diterbitkan dari penulis lain telah disebutkan dalam teks dan dicantumkan dalam Daftar Pustaka di bagian akhir tesis ini.
Bogor, Januari 2012
Hendrawan NRP G551090301
ABSTRACT
HENDRAWAN. The Construction of Strongly Optimal Linear Binary Codes with Minimum Distance of 13 and 15. Supervised by SUGI GURITMAN and NUR ALIATININGTYAS A linear binary code of length n over is defined as subspace of . A code has three parameters that attached to it, namely length, dimension, and minimum distance. A code with length n, dimension k and minimum distance d is often called [n, k, d]-code. The main problem in algebra coding theory is optimizing one of parameters n, k and d. Given two that others were known. Based on Gilbert-Varshamov bound, if a [n, k, d]-code is exist and the code can not be expanded, we call it strongly optimal code. In this thesis, we construct strongly optimal code with minimum distance of 13 and 15. In constructing the code, we created a theorem and algorithm based on Gilbert-Varshamov bound, then we implement the algorithm to MAPLE programming language. Because of computational limitations, the program can only construct up to k = 9 for d = 13 and d = 15. Keyword: binary linear codes, Gilbert-Varshamov bound, strongly optimal codes.
RINGKASAN
HENDRAWAN. Konstruksi Kode Linear Biner Optimal Kuat Berjarak Minimum 13 dan 15. Dibimbing oleh SUGI GURITMAN dan NUR ALIATININGTYAS. Kode linear biner dengan panjang n atas didefinisikan sebagai subruang dari ruang vektor . Suatu kode mempunyai tiga parameter penting yaitu panjang kode, dimensi kode dan jarak minimum kode. Jika suatu kode dengan panjang n, berdimensi k dan jarak minimum d, maka kode tersebut dinyatakan sebagai kode [n, k, d]. Selanjutnya suatu kode dikatakan baik jika n-kecil, k-besar dan d-besar. Makna fisiknya
Media informasi, seperti sistem komunikasi dan media penyimpanan untuk data, tidak sepenuhnya reliabel. Hal ini dikarenakan bahwa pada praktiknya ada gangguan (noise) atau interferensi lainnya sehingga pesan yang dikirim berubah (terdapat galat pada pesan). Salah satu masalah dalam teori koding (coding theory) adalah untuk mendeteksi atau bahkan mengoreksi galat tersebut. Suatu kode (code) diciptakan untuk mendeteksi atau mengoreksi galat (error) akibat saluran terganggu.
, n harus kecil terkait dengan kecepatan proses enkoding dan dekoding, dan juga terkait dengan besarnya memori yang digunakan dalam proses itu, k harus besar terkait dengan banyaknya pesan yang dapat diubah menjadi katakode, d harus besar terkait dengan banyaknya galat yang dapat dikoreksi.
Dari masalah tersebut, akan dikonstruksi kode-kode optimal kuat, yaitu kode dengan parameter [n, k, d] dengan syarat tidak ada kode-kode dengan parameter [n+1, k+1, d]. Untuk mencapai hal tersebut, perlu dilakukan beberapa hal sebagai berikut, yang selanjutnya menjadi tujuan dari penelitian ini.
1. Mengkaji teorema yang terkait dengan konstruksi kode linear, terutama Gilbert-Varshamov bound.
2. Mengonstruksi kode linear biner optimal kuat dengan jarak minimum 13 dan 15.
Setelah dipelajari secara mendalam teorema Gilbert-Varshamov, diturunkan teorema konstruksi sebagai berikut. Jika matriks B berukuran k r dikonstruksi berdasarkan sifat sebagai berikut.
1. Semua vektor baris dari B berbeda, dan 2. Jumlah setiap i vektor baris dari B berbobot paling sedikit (d – i) untuk
i = 2,3,….s, dimana s = min {d – 1, k}, dan (d – 1) r, maka dan secara berturut-turut merupakan matriks cek paritas dan matriks generator untuk kode linear C dengan parameter [k + r, k, d]. Untuk mengonstruksi kode optimal kuat dengan jarak minimum 13 dan 15 digunakan paket program konstruksi yang mengacu pada tesis yang ditulis oleh Putranto HU (2011). Program-program yang digunakan: Program Aritmetik Aljabar Matriks Biner dan Program Pelacakan Kode Optimal Kuat.
( )|TrH B I= ( )|kG I B=
Dalam tesis ini, kode linear biner yang berhasil dikonstruksi hanya sampai k = 9, r = 25 untuk d = 13 dan sampai k = 9, r = 28 untuk d = 15, sedangkan hasil utama, yaitu untuk memperbaiki batas bawah tabel Brower gagal dicapai. Hal ini disebabkan antara lain oleh:
1. Pemilihan kode dasar (matriks awal) yang kurang baik. 2. Program konstruksi yang masih belum sempurna.
Dalam tesis ini, masih banyak kekurangan yang ada di dalamnya, diantaranya adalah:
1. Tidak semua kode linear optimal kuat dapat di konstruksi, walaupun kode tersebut ada (telah dikonstruksi oleh orang lain).
2. Algoritme konstruksi, walaupun untuk representasi himpunan sudah cukup baik, masih dapat diperbaiki dalam hal kecepatan pelacakan kode-kode linear biner, terutama untuk dimensi yang cukup besar.
Untuk ke depannya, dapat diperbaiki algoritme konstruksi sehingga dapat mencari/melacak kode dengan lebih cepat dan dapat mencakup kode linear yang memiliki dimensi yang besar. Selain itu, dapat pula dikembangkan program untuk mengoleksi kode-kode atas , untuk .
Kata Kunci : kode linear biner, Gilbert-Vashamov Bound, kode optimal kuat.
B
2q >
© Hak Cipta milik IPB, tahun 2012
Hak Cipta dilindungi Undang-undang
Dilarang mengutip sebagian atau seluruh karya tulis ini tanpa mencantumkan atau menyebutkan sumbernya. Pengutipan hanya untuk kepentingan pendidikan, penelitian, penulisan karya ilmiah, penyusunan laporan, penulisan kritik, atau tinjauan suatu masalah; dan pengutipan tersebut tidak merugikan kepentingan yang wajar IPB Dilarang mengumumkan dan memperbanyak sebagian atau seluruh karya tulis dalam bentuk apa pun tanpa izin IPB
KONSTRUKSI KODE LINEAR BINER OPTIMAL KUAT BERJARAK MINIMUM 13 DAN 15
HENDRAWAN
Tesis sebagai salah satu syarat untuk memperoleh gelar
Magister Sains pada Program Studi Matematika Terapan
SEKOLAH PASCASARJANA INSTITUT PERTANIAN BOGOR
BOGOR 2012
Penguji Luar Komisi pada Ujian Tesis: Dr. Ir. Sri Nurdiati, M.Sc.
Judul Tesis : Konstruksi Kode Linear Biner Optimal Kuat Berjarak Minimum 13 Dan 15
Nama : Hendrawan NRP : G551090301
Disetujui
Komisi Pembimbing
Ketua Dr. Sugi Guritman
Anggota Dra. Nur Aliatiningtyas, M.Si.
Diketahui
Ketua Program Studi Matematika Terapan
Dekan Sekolah Pascasarjana
Dr. Ir. Endar H. Nugrahani, M.S.
Dr. Ir. Dahrul Syah, M.Sc.Agr.
Tanggal Ujian: 13 Januari 2012 Tanggal Lulus: …………………
(tgl. Pelaksanaan ujian tesis) (tgl. Penandatanganan tesis oleh Dekan Sekolah Pascasarjana)
Ku persembahkan karya tulis ini untuk: Kedua orang tuaku
Istriku tercinta Sutiani S.Ag Buah hatiku Aang Naufal Fakhriawan
PRAKATA
Puji dan syukur penulis panjatkan kepada Allah SWT atas segala karunia dan kasih sayang-Nya sehingga karya ilmiah ini berhasil diselesaikan. Tema yang dipilih dalam penelitian yang dilaksanakan sejak bulan Januari 2011 ini adalah Konstruksi Kode Linear Biner Optimal Kuat Berjarak Minimum 13 dan 15.
Ungkapan terima kasih yang setulusnya penulis sampaikan kepada Kementerian Departemen Agama Republik Indonesia, selaku sponsor bea siswa yang telah membantu semua biaya pendidikan S2 kepada penulis, Bapak Dr. Sugi Guritman dan Ibu Dra. Nur Aliatiningtyas, M.Si. selaku pembimbing, Ibu Dr. Ir. Sri Nurdiati, M.Sc. selaku penguji luar komisi, Ibu Dr. Ir. Endar H. Nugrahani, M.S. selaku ketua program studi matematika terapan, Kepala MTs Al-Khairiyah Kamasan, yang telah memberikan izin tugas belajar. Ungkapan terima kasih juga disampaikan kepada ayah, ibu, istriku, anakku dan seluruh keluarga besarku, rekan-rekan mahasiswa Matematika Terapan angkatan tahun 2009, rekan-rekan guru MTs. Al Khairiyah Kamasan dan Staf, atas segala bantuan, motivasi, doa, serta kasih sayangnya. Tidak lupa ucapan terima kasih penulis sampaikan juga kepada semua pihak yang telah turut membantu dalam penulisan tesis ini.
Penulis menyadari bahwa dalam tulisan ini masih jauh dari sempurna, oleh sebab itu mohon masukan dan kritikan yang membangun demi kesempurnaan dimasa mendatang. Akhirnya, semoga karya ilmiah ini bermanfaat.
Bogor, Januari 2012
Hendrawan
RIWAYAT HIDUP
Penulis dilahirkan di Musirawas pada tanggal 10 Juli 1969 dari ayah Sa’ari dan ibu Djumrak. Penulis merupakan putra ketiga dari enam bersaudara.
Tahun 1988 penulis lulus dari SMA Negeri Tugumulyo Program IPA dan melanjutkan ke Fakultas Tarbiyah Jurusan Tadris Matematika IAIN Raden Fatah Palembang dan lulus pada tahun 1993.
Pada tahun 1997 penulis diterima sebagai pegawai negeri sipil (PNS) di lingkungan Departemen Agama dan ditugaskan mengajar matematika di MTs Negeri Anyer Kabupaten Serang sampai tahun 2006 kemudian dimutasikan ke MTs Al-Khairiyah Kamasan sampai sekarang.
Pada tahun 2009 penulis mengikuti seleksi beasiswa S-2 dari Kementerian Agama RI, dan Alhamdulillah penulis berkesempatan mendapatkan beasiswa tersebut. Bulan Juli 2009, penulis mulai mengikuti perkuliahan S-2 pada Program Studi Matematika Terapan di Sekolah Pasca Sarjana IPB dan berhasil menyelesaikan studi pada bulan Januari 2012.
DAFTAR ISI
Halaman
DAFTAR TABEL ........................................................................................ xiv
DAFTAR GAMBAR .................................................................................. xvi
DAFTAR LAMPIRAN ................................................................................ xvii
BAB. I PENDAHULUAN ....................................................................... 1 Latar Belakang Masalah ........................................................................ 1
Tujuan Penelitian ................................................................................... 3 BAB. II LANDASAN TEORI ................................................................. 4
Definisi Sistem Persamaan Linear (SPL) ............................................... 4 Definisi Matriks .................................................................................... 4 Definisi Field ......................................................................................... 5 Definisi Ruang Vektor ........................................................................... 6 Definisi Subruang (subspace) ................................................................. 6 Definisi Kombinasi Linear ..................................................................... 7 Definisi Bebas Linear dan Terpaut Linear ............................................. 7 Definisi Perentang / Span ....................................................................... 7 Definisi Basis ........................................................................................ 8 Definisi Dimensi ................................................................................... 8
Definisi Ruang Baris dan Ruang Kolom ................................................ 8 Definisi Rank ......................................................................................... 8
Definisi Produk dalam standar (.) pada .............................................. 8 Definisi Komplemen Ortogonal ............................................................. 9 Definisi Kode Linear .............................................................................. 9 Definisi Kode Dual ................................................................................ 10 Definisi Jarak Haming (Hamming distance) .......................................... 10
Definisi Jarak Minimum suatu kode ....................................................... 10 Parameter Kode Linear .......................................................................... 10
Definisi Bobot Hamming ....................................................................... 11 Definisi Bobot Minimum Hamming ....................................................... 11 Definisi Matriks Generator dan Matriks Cek Paritas ............................... 11 Bentuk standar dari Matriks Cek Paritas H dan Matriks Generator G ..... 12
Definisi Ekivalensi Kode Linear ………………………………………... 12 Model Aljabar Kode Linear Biner ……………………………………… 13 Pengertian Matriks Cek Paritas .............................................................. 15 Dasar-dasar Konstruksi Kode ................................................................ 17
BAB. III METODE ..................................................................................... 18
Formulasi Masalah ................................................................................. 18 Metodologi ........................................................................................... 19 Langkah-langkah Penelitian .................................................................. 20
BAB. IV HASIL DAN PEMBAHASAN .................................................... 21 Kajian Teori ........................................................................................... 21 Membahas Aritmetik Aljabar Matriks .................................................... 24 Program-program Aritmetik Aljabar Matriks Biner ................................ 25 Program-program Pelacakan Kode Optimal Kuat ................................... 27 Algoritme Konstruksi Kode Optimal Kuat ............................................. 29 Konstruksi Kode Optimal Kuat dengan Jarak Minimum 13 dan 15 ......... 33 1. Konstruksi Kode [20, 2, 13] ............................................................. 33 2. Konstruksi Kode [24, 3, 13] ............................................................. 33 3. Konstruksi Kode [27, 5, 13] ............................................................. 34 4. Konstruksi Kode [29, 6, 13]............................................................. 35 5. Konstruksi Kode [32, 8, 13]............................................................. 35 6. Konstruksi Kode [34, 9, 13] ............................................................. 36 7. Konstruksi Kode [23, 2, 15] ............................................................. 37 8. Konstruksi Kode [27, 3, 15] ............................................................. 38 9. Konstruksi Kode [31, 6, 15] ............................................................. 38 10. Konstruksi Kode [35, 8, 15]............................................................. 39 11. Konstruksi Kode [37, 9, 15]............................................................. 40
BAB. V KESIMPULAN DAN SARAN ...................................................... 42
Kesimpulan ......................................................................................... 42 Saran ................................................................................................... 43
DAFTAR PUSTAKA .................................................................................. 44
LAMPIRAN ................................................................................................ 45
DAFTAR TABEL
Halaman
1. Contoh pendefinisian pesan menjadi katakode .......................................... 14
2. Program dan Prosedur untuk Meningkatkan Dimensi dari Matriks dasar ... 32
3. Hasil Eksplorasi Kode Optimal Kuat dengan Jarak Minimum d = 13 ....... 33
4. Hasil Eksplorasi Kode Optimal Kuat dengan Jarak Minimum d = 15 ....... 37
DAFTAR GAMBAR
Halaman
1. Contoh proses enkoding dan dekoding dari suatu pesan............................. 2
DAFTAR LAMPIRAN
Halaman
A.Tabel Brouwer Yang Berkaitan dengan d = 13 dan d = 15 ........................ 45
B. Program Aritmetik Aljabar Matriks Biner ................................................ 46
C. Program Pelacakan kode Optimal Kuat..................................................... 51
D. Konstruksi kode Optimal Kuat ................................................................. 68
LAMPIRAN
BAB I
PENDAHULUAN
Latar Belakang Masalah
Media informasi, seperti sistem komunikasi dan media penyimpanan untuk
data, tidak sepenuhnya reliabel. Hal ini dikarenakan bahwa pada praktiknya ada
gangguan (noise) atau interferensi lainnya sehingga pesan yang dikirim berubah
(terdapat galat pada pesan). Salah satu masalah dalam teori koding (coding
theory) adalah bagaimana cara untuk mendeteksi atau bahkan mengoreksi galat
tersebut.
Pada tahun 1948 C.E. Shannon dalam artikelnya yang berjudul
A Mathematical Theory of Communication, menggambarkan tentang problem
dalam teori informasi adalah sebagai berikut. Apabila suatu pesan (informasi)
dikirim melalui saluran terganggu (noisy channel), sering kali terjadi bahwa pesan
yang diterima tidak sama dengan yang dikirim. Sebagai contoh pesan yang berupa
suara atau gambar menjadi tidak jelas. Problem dalam teori informasi inilah yang
menjadi dasar berkembangnya teori koding.
Dalam ilmu komunikasi pesan direpresentasikan dalam bentuk dijital
sebagai barisan simbol dan kebanyakan menggunakan simbol biner yang dikenal
dengan bitstring. Saluran biasanya berupa jaringan telepon, jaringan radio
berfrekuensi tinggi atau jaringan komunikasi satelit. Saluran yang terganggu
menyebabkan berubahnya beberapa simbol yang dikirim, sehingga mengurangi
kualitas informasi yang diterima. Untuk mendeteksi atau mengoreksi terjadinya
galat (error) akibat saluran yang terganggu maka sangat diperlukan suatu kode.
Karena tujuan diciptakan kode adalah untuk melindungi pesan agar apabila terjadi
galat (error) akibat saluran yang terganggu maka galat itu dapat dipulihkan lagi.
Dalam hal ini sebelum dikirim, semua pesan akan diubah menjadi katakode
(codeword) dengan cara menambahkan beberapa simbol ekstra pada simbol
pesan. Proses pengubahan pesan menjadi katakode disebut enkoding. Perangkat
yang mengubah pesan menjadi katakode disebut enkoder. Kode merupakan
himpunan yang anggotanya semua katakode. Pendefinisian kode ini dilakukan
sedemikian sehingga apabila terjadi perubahan beberapa simbol pada katakode,
2 maka galat itu bisa dipulihkan lagi oleh dekoder. Dekoder merupakan perangkat
yang mengubah barisan simbol yang diterima menjadi katakode yang selanjutnya
dipulihkan menjadi pesan yang asli. Untuk menciptakan sistem komunikasi yang
bebas error sangat diperlukan sekali teori koding. Proses koding dari suatu pesan
dapat digambarkan sebagai berikut.
pesan 100100 pesan
katakode 100101
100101 gangguan 110101katakode galat 1 bitkirim kirim
dekodingenkoding
Gambar 1. Contoh proses enkoding dan dekoding dari suatu pesan
Ilustrasi praktek dari Gambar 1 diberikan sebagai berikut. Suatu pesan
dengan simbol 100 akan dikirim, maka terlebih dahulu pesan tersebut oleh
enkoder diubah menjadi katakode yaitu dengan cara menambahkan simbol ekstra
101 pada simbol pesan. Ini berarti 100 menjadi input dari enkoder, selanjutnya
diubah menjadi katakode 100101. Katakode inilah yang kemudian dikirim melalui
saluran yang di asumsikan mengalami gangguan sehingga terjadi galat sebanyak 1
bit dan pesan yang diterima menjadi 110101. Dekoder akan mendeteksi galat dan
mengoreksi menjadi katakode yang mendefinisikan pesan aslinya.
Secara umum, tujuan dari teori koding adalah untuk mengonstruksi suatu
kode (enkoder dan dekoder) sehingga
1. Dapat meng-enkode suatu pesan dengan cepat.
2. Dapat mentransmisi pesan yang sudah di-enkode dengan mudah.
3. Dapat men-dekode suatu pesan yang diterima dengan cepat.
4. Dapat memaksimumkan informasi yang ditransfer per satuan waktu.
5. Dapat secara maksimal dalam mendeteksi dan mengoreksi
kesalahan.
3
Tujuan Penelitian
Berdasarkan latar belakang yang dipaparkan di atas, maka tujuan dari
penelitian ini adalah:
1. Mengkaji teorema yang terkait dengan kontruksi kode linear, terutama
Gilbert-Vashamov bound.
2. Mengonstruksi kode linear biner optimal kuat dengan jarak minimum 13
dan 15.
Dari tujuan-tujuan tersebut, penelitian ini diharapkan dapat memberikan
suatu hal yang baru dalam teori koding, yaitu memperbaiki batas bawah dari tabel
Brouwer.
BAB II
LANDASAN TEORI
Sebagai acuan penulisan penelitian ini diperlukan beberapa pengertian dan
teori yang berkaitan dengan pembahasan. Dalam sub bab ini akan diberikan
beberapa landasan teori berupa pengertian, definisi, proposisi dan teorema yang
berkaitan dengan pembahasan.
Definisi Sistem Persamaan Linear (SPL)
Sistem Persamaan Linear (SPL) m n adalah m persamaan linear dengan n
variabel (peubah). Bentuk umumnya adalah sebagai berikut:
+ + + =
+ + + =
+ + + =
dengan dan berupa konstanta, i = 1, 2, , m; j = 1, 2, , n,
sedangkan merupakan variabel yang ingin ditentukan nilainya. Nilai
disebut koefisien pada persamaan ke-i.
Suatu sistem persamaan linear dengan bentuk = = = = 0
disebut SPL homogen. Bentuk umum dari SPL homogen adalah sebagai berikut:
+ + + = 0
+ + + = 0
+ + + = 0
(Gunawan Santosa R. 2009)
Definisi Matriks
Matriks adalah susunan segi empat yang unsur-unsurnya berupa bilangan-
bilangan. Matriks X dengan ordo m n adalah matriks dengan ukuran m baris
dan n kolom, simbolnya adalah sebagai berikut.
5
X =
Unsur matriks yang disimbolkan dengan dimana i = 1, 2, , m dan
j = 1, 2, , n, dibaca sebagai unsur matriks X pada baris ke-i dan kolom ke-j.
(Gunawan Santosa R. 2009)
Definisi Field
Suatu himpunan yang padanya didefinisikan operasi jumlah (+) dan
operasi kali (.) disebut field, notasi , jika memenuhi sifat-sifat berikut,
1. merupakan grup komutatif terhadap +, yaitu memenuhi sifat-sifat:
a. Asosiatif: ( , , ) ( + ) + = + ( + ),
b. mempunyai unsur identitas: ( 0 ) ( ) 0 + = + 0 = ,
c. Setiap unsur dari mempunyai invers: ( ) ( ) + =
+ = 0, dalam hal ini = ( ), dan
d. komutatif: ( ) .
2. , dimana = , merupakan grup komutatif terhadap .,
bersifat:
a. asosiatif: ( ) ( ) ,
b. mempunyai unsur identitas: ( ) ( ) 1. .1 = ,
c. setiap unsur dari mempunyai invers: ( ) ( )
, dalam hal ini dinotasikan ), dan
d. komutatif: ( ) .
3. Berlaku sifat distributif . terhadap + : ( )
atau ( )
(Sugi Guritman 2005)
Contoh field takhingga diantaranya adalah: himpunan bilangan real,
himpunan bilangan kompleks, sedangkan contoh dari field berhingga diantaranya
adalah = {0,1, 2,…, ( – 1)} dengan operasi jumlah dan kali modulo , dimana
bilangan prima. Jadi adalah contoh field berhingga dengan anggotanya
adalah {0,1}.
6 Definisi Ruang Vektor
Diberikan sembarang himpunan dan sembarang field . Pada
didefinisikan aturan jumlah dan aturan perkalian dengan skalar. Himpunan
disebut ruang vektor atas jika terhadap aturan-aturan tersebut memenuhi 10
aksioma-aksioma berikut.
1. ( u, v )( w ) u + v = w.
2. ( u, v, w ) (u + v) + w = u + (v + w).
3. ( 0 )( u ) 0 + u = u + 0 = u.
4. ( u ) ( v ) u + v = v + u = 0, dalam hal ini v = u.
5. ( u, v ) u + v = v + u.
6. ( k , u )( v ) ku = v.
7. ( k , u, v ) k(u + v) = ku + kv.
8. ( k, l , u ) (k + l) u = ku + lu.
9. ( k, l , u ) (kl)u = k(lu).
10. ( u ) 1u = u dimana 1 adalah unsur identitas dari terhadap operasi
kali.
(Sugi Guritman 2005)
Unsur-unsur dari dalam hal ini merupakan skalar, sedangkan unsur-unsur
dari disebut dengan vektor.
Sebagai contoh: misalkan merupakan himpunan dari pasangan terurut
dengan panjang n yang unsur-unsurnya merupakan elemen dari , yaitu =
{( , ,…, ) }. Misalkan pula v = , w =
, dan . Operasi Penjumlahan di didefinisikan
sebagai v + w = . Sedangkan perkalian
dengan skalar didefinisikan sebagai .v = . Maka
merupakan ruang vektor.
Definisi Subruang (Subspace)
Misalkan adalah ruang vektor atas skalar dan . Himpunan
disebut subruang dari jika juga merupakan ruang vektor atas terhadap
operasi yang sama dengan .
7 Teorema 1
Misalkan adalah ruang vektor atas skalar dan , maka tiga
proposisi berikut ini ekivalen.
(i) subruang dari .
(ii) Berlaku dua sifat berikut ini:
(a) ( , ) + , dan
(b) ( k , w ) kw .
(iii) ( k, l , , ) k + l .
(Sugi Guritman 2005)
Definisi Kombinasi Linear
Misalkan adalah ruang vektor atas skalar . Diberikan himpunan
= { , ,…, } terdiri atas n vektor dalam . Suatu vektor v disebut
kombinasi linear dari jika ( , , …, ) sehingga v = .
(Sugi Guritman 2005)
Definisi Bebas Linear dan Terpaut linear
Misalkan adalah ruang vektor atas skalar , dan misalkan =
adalah himpunan yang terdiri atas n vektor dalam . disebut
bebas linear jika memenuhi persamaan berikut
( i I = {1,2,…,n} = 0).
Ingkarannya, disebut terpaut linear jika
( j I = {1,2,…, n} 0).
(Sugi Guritman 2005)
Definisi Perentang / Span
Jika S = adalah vektor-vektor di dalam ruang vektor dan
jika tiap-tiap vektor di dalam dapat dinyatakan sebagai kombinasi linear dari S,
maka dikatakan bahwa vektor-vektor S merentang (spanning) .
Jika = , maka S disebut himpunan perentang . Dan dikatakan
direntang oleh S.
(Gunawan Santosa R. 2009)
8 Definisi Basis
Jika adalah sembarang ruang vektor dan S = { } adalah
sebuah himpunan berhingga dari vektor-vektor di dalam , maka S dinamakan
sebuah basis untuk jika:
1. S bebas linear.
2. S merentang .
(Gunawan Santosa R. 2009)
Definisi Dimensi
Dimensi dari sebuah ruang vektor didefinisikan sebagai banyaknya
vektor-vektor dari basis di .
(Gunawan Santosa R. 2009)
Definisi Ruang Baris dan Ruang Kolom
Jika diketahui matriks A berukuran m n, maka subruang yang
direntang oleh vektor-vektor baris dinamakan ruang baris (row space) dari A.
Sedangkan subruang yang direntang oleh vektor-vektor kolom dinamakan
ruang kolom (column space) dari A.
(Gunawan Santosa R. 2009)
Definisi Rank
Dimensi ruang baris atau ruang kolom dari matriks A dinamakan rank dari
matriks A.
(Gunawan Santosa R. 2009)
Definisi Produk dalam
Misalkan adalah ruang vektor atas skalar , misalkan x, y
sembarang. Operasi biner dari x dan y bernilai dalam , dinotasikan , disebut
produk dalam (inner product) jika memenuhi sifat-sifat berikut. Untuk setiap
x, y, z dan k, l berlaku:
1. Simetrik: =
2. Linearitas: = k + l , dan
9
3. Positifitas: 0 dan = 0 jhj x = 0.
(Sugi Guritman 2005)
Sebagai contoh: misalkan x = { } dan y = { }
. Produk dalam baku dari x dan y didefinisikan sebagai berikut
= x.y = .
Definisi Ortogonal
Dua vektor x dan y di dalam ruang vektor dikatakan ortogonal,
dinotasikan x y, jika = 0.
(Sugi Guritman 2005)
Definisi Komplemen Ortogonal
Misalkan adalah ruang vektor dan S . Komplemen ortogonal (disebut
juga dual) dari S, notasi , didefinisikan sebagai
= .
(Sugi Guritman 2005)
Sebagai contoh: misalkan v = , w = ; v, w .
i. Vektor v & w dikatakan saling tegak lurus (orthogonal) jika
v.w = 0
ii. Misalkan S merupakan himpunan bagian dari . Komplemen
orthogonal dari S, notasi didefinisikan sebagai
= . Jika S = , maka = .
Jika S merupakan subruang dari ruang vektor , maka merupakan subruang
dari ruang vektor dan = .
(Ling & Xing, 2004)
Definisi Kode Linear
Misalkan diberikan field berhingga qF . Misalkan pula nqF merupakan
himpunan dari vektor-vektor atas qF dengan panjang n . Kode linear C
didefinisikan sebagai subruang dari ruang vektor nqF .
(Ling & Xing, 2004)
10 Definisi Kode Dual
Misalkan C merupakan kode linear atas , maka Kode dual (dual code)
dari C, notasi , adalah komplemen orthogonal dari C.
Teorema 2
Misal C adalah kode linear atas dengan panjang n dan dimensi k, maka :
i. = dim ( C ) =
ii. juga merupakan suatu kode linear dan dim (C ) + dim = n
iii. = C
Dengan demikian jika C berdimensi k, maka berdimensi r = n – k .
(Ling & Xing, 2004)
Definisi Jarak Hamming (Hamming distance)
Diberikan ruang vektor atas lapangan . Misalkan pula x dan y adalah
anggota dari (x, y ). Jarak Hamming antara x dan y yang dinotasikan
dengan ( ),d x y , didefinisikan sebagai berikut.
( ) ( ) ( ) ( )1 1 2 2, , , ... ,n nd x y d x y d x y d x y= + + , dengan
( )1
,0
i ii i
i i
x yd x y
x y≠
= =.
(Ling & Xing, 2004)
Definisi Jarak Minimum suatu kode (Minimum distance of a code)
Misalkan C adalah kode linear yang memiliki kata kode lebih dari satu.
Jarak minimum untuk C , yang dinotasikan ( )d C , didefinisikan sebagai
( ) ( ){ }min , | , ,d C d x y x y C x y= ∈ ≠ .
(Ling & Xing, 2004)
Parameter Kode Linear
Kode linear C dengan panjang n dan berdimensi k disebut dengan kode
linear dengan parameter [n, k]. Jika jarak minimum d dari C diketahui, maka C
disebut kode linear dengan parameter [n, k, d]. Atau disebut kode linear-[n, k, d].
11 Untuk selanjutnya, jika parameter dari suatu kode tidak ditekankan, cukup
disebutkan bahwa C adalah suatu kode linear. Anggota dari C disebut dengan kata
kode.
(Ling & Xing, 2004)
Definisi Bobot Hamming (Hamming weight)
Diberikan ruang vektor . Misalkan pula x . Bobot Hamming
(Hamming Distance), yang dinotasikan wt(x) didefinisikan sebagai jumlah
koordinat/unsur yang tak nol:
Wt(x) = d(x, 0) dengan 0 adalah vektor nol
atau dapat pula didefnisikan sebagai berikut.
1 jika 0( ) ( ,0)
0 jika 0x
wt x d xx≠
= = =.
Lema 1.
Diberikan ruang vektor . Misalkan x, y , maka d(x, y) = wt(x y).
(Ling & Xing, 2004)
Definisi Bobot Minimum Hamming
Diberikan kode linear C . Minimum Hamming weight (Bobot minimal
Hamming) dari C , dinotasikan ( )wt C , didefinisikan sebagai bobot terkecil dari
kata kode tak nol dari C .
Teorema 3
Misalkan C adalah suatu kode linear, maka ( ) ( )d C wt C= .
(Ling & Xing, 2004)
Definisi Matriks Generator dan Matriks Cek Paritas
i. G dikatakan matriks generator bagi kode C jika baris-barisnya
merupakan basis untuk C.
ii. H dikatakan matriks cek paritas dari kode C jika H merupakan
matriks generator bagi kode dual .
(Ling & Xing, 2004)
12 Bentuk Standar dari Matriks Cek Paritas H dan Matriks Generator G
Diberikan kode linear C . Misalkan H dan G , secara berturut-turut adalah
matrik cek paritas dan matrik generator untuk kode linear C .
i. Bentuk standar untuk matriks generator G adalah ( )|kI X , dengan
Matriks identitas berukuran kI k k= × .
ii. Bentuk standar untuk matriks cek paritas H adalah ( )| n kY I − ,
dengan ( ) ( ) Matriks identitas berukuran n kI n k n k− = − × − .
(Ling & Xing, 2004)
Teorema 4
Misalkan H adalah suatu matriks cek paritas bagi kode linear C, maka
i. C memiliki jarak minimum ≥ d jika dan hanya jika d – 1 kolom
dari H saling bebas linear.
ii. C memiliki jarak minimum ≤ d jika dan hanya jika d kolom dari H
saling tidak bebas linear.
(Ling & Xing, 2004)
Teorema 5
Jika G = adalah bentuk standar dari matriks generator untuk suatu
kode C dengan parameter [n, k], maka matriks cek paritas untuk kode C adalah
H = .
(Ling & Xing, 2004)
Definisi Ekivalensi dari Kode Linear
Misalkan diberikan sembarang kode linear 1C dan 2C . 1C dan 2C dikatakan
ekivalen jika salah satunya dapat diperoleh dari kode yang lain dengan cara
mengkombinasikan operasi-operasi sebagai berikut.
i. Mempermutasikan digit-digit yang ada di kata kode tersebut.
ii. Mengalikan posisi tertentu dengan skalar.
(Ling & Xing, 2004)
13 Model Aljabar Kode Linear Biner.
Jika menotasikan ruang vektor standar berdimensi n atas dasar field
biner = {0,1}. Maka definisi Bobot (Hamming weight) dari suatu vektor
x adalah banyaknya simbol tak nol dalam x dan dinotasikan “ t (x) “ .
Definisi Jarak (Hamming distance) antara dua vektor x,y adalah banyaknya
posisi digit dari x dan y dimana simbol mereka berbeda dan dinotasikan “ d(x,y) “,
jelas bahwa d(x,y) = t(x + y). Sebagai contoh, di dalam ruang vektor , jika
x = 110001 dan y = 101010, maka:
d(x,y) = t(110001 + 101010) = t (011011) = 4
Dalam praktek, pengertian tersebut terkait dengan makna fisik sebagai
berikut. Jika pesan x akan dikirim dan berubah menjadi y saat diterima, maka
d(x,y) merepresentasikan banyaknya galat yang terjadi. d(x,y) = 0 berarti tidak
terjadi kesalahan saat pengiriman.
Dari definisi kode di atas dapat disimpulkan bahwa suatu kode linear biner
dengan panjang n merupakan subruang C dari ruang vektor . Anggota suatu
kode disebut dengan katakode (codeword). Mengonstruksi suatu kode bukan suatu
hal yang sederhana karena harus mempertimbangkan makna praktek yang
dijelaskan sebagai berikut.
Kode merupakan representasi dari himpunan semua pesan. Artinya satu
katakode mewakili satu pesan. Kode diciptakan untuk melindungi (koreksi atau
deteksi) pesan dari kesalahan saat pengiriman. Dengan demikian di dalam setiap
bitstring katakode harus mengandung dua makna, yaitu simbol pesan dan simbol
cek. Simbol pesan telah diketahui (diberikan) sebagai bentuk biner dari pesan,
sedangkan simbol cek merupakan simbol ekstra yang ditempelkan pada pesan.
Biasanya nilai simbol cek bergantung pada simbol pesan. Berikut ini diberikan
ilustrasi bagaimana mengonstruksi suatu kode berdasarkan persamaan aljabar.
Contoh 1: Definisikan suatu kode C dengan panjang 6 di dalam ruang dengan
syarat : x = C jika dan hanya jika simbol pesan dan
simbol cek yang memenuhi persamaan :
= +
= + +
= +
14 Karena simbol pesan berukuran 3 bit, maka himpunan semua simbol pesan
adalah
= {000, 001, 010, 011, 100, 101, 110, 111}
Jika = 011 , berarti = 0, = 1 dan = 1, maka = 1 + 0 = 1,
= 0 + 1 + 1 = 0, dan = 1 + 1 = 0, sehingga 011100 C.
Secara lengkap pendefinisian C diberikan dalam tabel berikut :
Tabel 1 Contoh pendefinisian pesan menjadi katakode
Simbol Pesan Katakode
000
001
010
011
100
101
110
111
000000
001111
010011
011100
100110
101001
110101
111010
Jadi C = {000000, 001111, 010011, 011100, 100110, 101001, 110101, 111010} .
Ilustrasi praktek dari contoh di atas diberikan sebagai berikut. Suatu pesan
110 akan dikirim, maka pesan itu terlebih dahulu harus diubah (dienkoding)
menjadi kata kode. Ini berarti 110 menjadi input dari enkoder. Dan enkoder
melakukan perhitungan dengan menggunakan algoritma sebagaimana dirumuskan
pada contoh tersebut untuk mengubahnya menjadi katakode. Output dari enkoder
adalah berupa kata kode x = 110101. Katakode inilah yang kemudian dikirim
melalui saluran yang diasumsikan terganggu (noisy). Apabila pada saat
pengiriman terjadi gangguan dan x berubah menjadi y = 010101, maka dekoder
harus mampu paling tidak mendeteksi dan akan lebih baik kalau bisa mengoreksi.
15 Pengertian Matriks Cek Paritas
Suatu matriks H berukuran r x n yang semua barisnya merupakan suatu
basis untuk disebut matriks cek paritas (parity check matrix) dari C.
Pengertian matriks paritas ini berimplikasi pada pendefinisian kode linear yang
berkaitan dengan cara konstruksi seperti pada contoh 1 diatas, yaitu :
C = {x H = 0}
Dengan kata lain, C adalah himpunan solusi dari SPL H = 0 (disebut dengan
kernel H). Mengkonstruksi (membuat) kode linear dengan panjang n dan
berdimensi k sama artinya dengan mendefinisikan matriks cek paritas seperti yang
dimaksud di atas. Disamping itu matriks cek paritas berfungsi mengubah pesan
menjadi katakode, dengan kata lain ia merupakan parameter didalam enkoding.
Enkoding kode linear dengan menggunakan matriks paritas H di ilustrasikan
sebagai berikut.
Diberikan blok simbol pesan dengan panjang k, misalnya u = …. ,
akan dienkode menjadi kata kode x = ……. dimana n k dengan
menggunakan matriks cek paritas H yang telah didefinisikan sebelumnya. Maka
pertama kali didefinisikan :
= , = , …….., = ,
dan diikuti dengan pendefinisian r = (n – k) simbol cek , …. yang
nilainya bergantung pada nilai simbol pesan. Ketergantungan ini ditentukan oleh
H dengan menyelesaikan SPL homogen berikut.
H = 0 H = (1)
Demi kemudahan penyelesaian, matriks H biasanya diberikan dalam bentuk
standar, yaitu
H = ( A C ) (2)
dengan A adalah matriks biner berukuran r x k, dan adalah matriks idetitas
berukuran r x r. Jika H belum berbentuk standar, maka dengan operasi
baris/kolom elementer dapat dicari matriks ekuivalen standarnya. Untuk semua
16 perhitungan menggunakan aritmetik operasi modulo
Berikut ini adalah ilustrasi proses kalkulasi enkoding dengan menggunakan
matriks H.
2 yang telah didefinisikan
pada .
Contoh 2: Didefinisikankan matriks cek paritas
H =
Dari ukuran H diperoleh n = 6; n – k = 3, sehingga k = 3. Terlihat bahwa matriks
H mempunyai bentuk standar sama dengan
A =
Pesan u = akan dienkode menjadi x = . Hal ini dimulai
dari
= ; = ; = ;
kemudian dipilih sehingga memenuhi H = 0, sehingga diperoleh Sistem
Persamaan Linear (SPL)
+ + = 0;
+ + = 0;
+ + = 0:
dan disebut SPL cek paritas. Misalnya pesan u = 110, maka = 1, = 1, = 0,
dan dari SPL diperoleh
= -1 = 1
= -1 = 1
= -1 – 1 = 1 + 1 = 0
Ini berarti H mengubah pesan u = 110 menjadi katakode x = 110110. Secara
keseluruhan, karena k = 3, maka ada = 8 pesan berbeda yang bertindak sebagai
input dalam enkoding, sehingga H mendefinisikan kode C dengan anggota
8 katakode.
C = {000000, 001110, 010101, 011011, 100011, 101101, 110110, 111000}
Selain menggunakan matriks cek paritas H, untuk mengkonstruksi C juga bisa
menggunakan matriks generator dari C, biasanya dinotasikan dengan G. Dengan
demikian, semua baris dari G merupakan basis untuk C. Akibatnya, G berukuran
17 k x n dan setiap katakode merupakan kombinasi linear dari semua vektor baris
dari G, dengan kata lain
C = Merentang ({ , , …. })
dimana { , , …. } adalah himpunan semua baris dari G.
Dasar-dasar Konstruksi Kode
Apabila suatu kode telah berhasil dikonstruksi, maka kode dengan parameter
yang berbeda dapat pula dikonstruksi, berikut adalah beberapa cara untuk
mendapatkan kode lain tersebut.
1. Penambahan pada matriks cek paritas
Misalkan C adalah suatu kode linear biner dengan parameter [ ], ,n k d
dengan beberapa kata kode nya berbobot ganjil. Dari kode tersebut akan dibentuk
kode baru C dengan menambahkan bit "0" di akhir kata kode yang berbobot
genap, dan bit "1" di akhir kata kode yang berbobot ganjil.
Dengan penambahan ini, jarak tiap pasang kata kode menjadi genap. Jika jarak
minimum kode C ganjil, maka kode yang baru memiliki jarak minimum 1d + ,
Sehingga C memiliki parameter [ ]1, , 1n k d+ + . Secara umum, proses
penambahan simbol pada matriks cek paritas disebut sebagai exending a code
(memperluas suatu kode) .
(MacWilliams & Sloane,1981)
2. Penghapusan dengan cara menghilangkan beberapa kata kode
Misalkan kode linear biner C memiliki parameter [ ], ,n k d dan memiliki
kata kode dengan bobot ganjil dan genap. Kata kode dengan bobot ganjil dapat
dihapus untuk mendapatkan kode baru dengan parameter [ ], 1, 'n k d− . Pada
umumnya 'd d> .
(MacWilliams & Sloane,1981)
BAB III
METODE Formulasi Masalah
Jika C adalah kode linear biner yang mempunyai panjang n, berdimensi k,
dan berjarak minimum d, maka C diberi nama kode-[n,k,d]. Selanjutnya C
dikatakan baik jika n-kecil, k-besar dan d-besar. Makna fisiknya
Pada penelitian ini yang dimaksud dengan kode optimal kuat (strongly
optimal codes) adalah jika kode dengan parameter [n, k, d] telah berhasil
dikonstruksi dan telah berhasil pula dibuktikan bahwa kode dengan parameter
[n+1, k+1, d] tidak ada. Konstruksi kode yang dilakukan berlandaskan pada
teorema berikut ini.
, n harus kecil
terkait dengan kecepatan proses enkoding dan dekoding, dan juga terkait dengan
besarnya memori yang digunakan dalam proses itu, k harus besar terkait dengan
banyaknya pesan yang dapat diubah menjadi katakode, d harus besar terkait
dengan banyaknya galat yang dapat dikoreksi.
Teorema 6 (The Gilbert-Varshamov bound)
Jika telah diketahui ada kode [n, k, d] yang memenuhi ketaksamaan
1 + + + + <
maka ada (dapat dikonstruksi) kode dengan parameter [ n+1, k+1, d ].
Kajian tentang teorema Gilbert-Varshamov bound cukup menarik. Bentuk
umum perbaikan teorema tersebut terakhir dilakukan oleh A. Barg dkk.. Namun
penerapan per kasus kode (kode dengan nilai parameter tertentu) baik yang batas
atas maupun batas bawah belum banyak dilakukan. Untuk itu pada penelitian ini
dicoba penerapan teorema Gilbert-Varshamov bound untuk mengonstruksi kode
optimal kuat. Konstruksi kode dalam penelitian ini dibatasi per kasus atas dasar
jarak minimum d, yaitu dimulai untuk d = 13 dan d = 15. Pemilihan kasus cukup
untuk d ganjil, hal ini didasarkan pada salah satu sifat kode linear yang dinyatakan
sebagai berikut. Jika kode dengan parameter [n, k, d] ada untuk d ganjil, maka
dapat dikonstruksi kode dengan parameter [n + 1, k, d + 1] dan setiap
anggotanya berbobot genap.
19 Metodologi
Mengonstruksi suatu kode berarti mendefinisikan matriks cek paritas H
atau matriks generator G. Selain teorema Gilbert-Vashamov Bound, berikut ini
diberikan beberapa teorema yang paling berperan untuk melandasi konstruksi H.
Teorema 7 Jika H adalah matriks cek paritas dari suatu kode dengan panjang n,
maka kode tersebut mempunyai dimensi (n – r) jika dan hanya jika ada r kolom
dari H yang bebas linear tetapi tidak ada r + 1 kolom dari H yang bebas linear
(r adalah rank dari H).
Teorema 8 Jika H adalah matriks cek paritas dari suatu kode dengan panjang n
maka kode tersebut mempunyai jarak minimum d jika dan hanya jika setiap d – 1
kolom dari H yang bebas linear dan ada d kolom dari H yang tidak bebas linear.
Teorema 9 (The Singleton bound) Jika C adalah kode dengan parameter [n, k, d]
maka (n – k) (d – 1).
Berdasarkan teorema-teorema tersebut, cukup dikonstruksi bentuk standar
dari matriks H yaitu H = . Untuk mempertimbangkan efisiensi komputasi
maka kita cukup mengonstruksi matriks B berukuran k x r yang memenuhi
sifst-sifat:
a. Vektor-vektor dari B berbobot paling sedikit (d - 1).
b. Jumlah setiap i-vektor baris dari B berbobot paling sedikit (d - i) untuk
i = 2, 3, …..s, dimana s = min {d - 1, k}.
Pada penelitian ini dibuktikan bahwa konstruksi H dengan strategi di atas
memenuhi ketiga teorema yang bersangkutan, sehingga H akan mendefinisikan
kode dengan parameter [n, k, d].
Setelah kode [n, k, d] dikonstruksi langkah berikutnya adalah
mendefinisikan himpunan yang beranggotakan semua vektor baris dari B dan
semua vektor sebagai hasil jumlah i-vektor baris dari B untuk i = 2,3….s, dimana
s = min {d - 1, k}. Maka jelas bahwa ⊆ . Jika , maka ada vektor
x dan x yang ditambahkan ke baris matriks B untuk mendefinisikan
matriks berukuran (k + 1) x r dan matriks cek paritas = akan
mendefinisikan kode dengan parameter [n +1, k +1, d].
Proses ekstensi kode dari [n, k, d] ke [n + 1, k + 1, d] dilakukan tahap demi
tahap sampai diperoleh suatu kode C dengan parameter [ , , d] yang sudah
20 tidak bisa diperluas lagi. Ketika diperoleh informasi bahwa telah dibuktikan
bahwa kode dengan parameter [ + 1, + 1, d] tidak ada, maka C merupakan
kode optimal kuat yang telah berhasil dikonstruksi. Akan tetapi, ketika diperoleh
informasi bahwa ada kode dengan parameter [ + 1, + 1, d], berarti kita telah
gagal mengkonstruksi kode optimal kuat. Dalam hal ini, kita harus melakukan
rekonstruksi dengan strategi memilih kode dasar [n, k, d] yang lain yang
berpeluang besar dapat diperluas menjadi kode optimal kuat C. Pemilihan kode
dasar yang baik perlu adanya eksplorasi baik yang bersifat teoritik maupun
komputatif. Selanjutnya, keberhasilan konstruksi kode optimal kuat C dapat
digunakan sebagai kode dasar untuk diperluas menjadi kode optimal kuat
berikutnya dengan strategi yang sama.
Langkah-langkah Penelitian
Dalam penelitian ini dikontruksi kode optimal kuat dengan langkah-langkah
sebagai berikut:
1. Mengkaji teori yang digunakan dalam penelitian.
2. Membahas Aritmetik Aljabar Matriks dengan cara :
a. Mendefinisikan ruang vektor sebagai himpunan kuasa pada
himpunan A = {0, 1, 2, ……., n – 1}n.
b. Mendefinisikan matriks sebagai daftar dari sejumlah anggota .
3. Mengkaji Algoritme prosedur untuk pelacakan kode optimal kuat.
4. Mengonstruksi kode optimal kuat dengan jarak minimum d = 13 dan
d = 15.
BAB IV
HASIL DAN PEMBAHASAN
Pada BAB IV ini dibahas tentang permasalahan sebagai berikut: Kajian
Teori yang digunakan dalam penelitian, Membahas Aritmetik Aljabar Matriks,
Program-program Aritmetik Aljabar Matriks Biner, Program-program Pelacakan
Kode Optimal Kuat, Algoritme Konstruksi kode optimal kuat, dan Konstruksi
Kode Optimal Kuat Dengan Jarak Minimum 13 dan 15.
Kajian Teori
Diberikan kode linear C dengan parameter [n, k, d]. Misalkan H merupakan
matriks cek paritas untuk C. Dari definisi matriks cekparitas
C = , atau dengan kata lain C adalah himpunan solusi dari SPL
H = 0 ( C disebut dengan kernel H) . Hal ini karena baris-baris dari matriks H
merupakan basis untuk , komplemen orthogonal bagi C.
Karena kode linear C merupakan kernel dari matriks cek paritasnya, maka
mengkonstruksi suatu kode linear C sama dengan mengkonstruksi matriks cek
paritasnya. Berikut ini adalah teorema yang berkaitan dengan konstruksi kode
linear biner optimal kuat.
Teorema 6 (The Gilbert-Varshamov bound)
Diberikan kode linear C dengan parameter [n, k, d]. Jika ketaksamaan
1 + + + + < berlaku maka dapat dikonstruksi kode
dengan parameter [n+1, k+1, d].
Bukti :
Misal diberikan kode linear yang memiliki parameter [n, k, d]. Berdasarkan
Teorema 7, ada matriks cek paritas berordo (n – k) n, yaitu H =
yang setiap d – 1 vektor dari adalah bebas linear dalam ruang
vektor . Jika ada vektor x yang bukan i kombinasi linear dari
vektor-vektor kolom H, untuk i = 1,2,…,d – 2 , maka = adalah
matriks cek paritas untuk kode linear yang memiliki parameter [n + 1, k + 1, d].
22 Hal ini karena berordo (n – k ) ( k + 1) dan setiap d – 1 vektor dari
adalah bebas linear dalam ruang vektor .
Jika banyaknya kombinasi linear yang mungkin dari kolom-kolom
sehingga tidak ada d – 1 kolom yang bergantung linear lebih besar atau sama
dengan jumlah vektor tak nol dalam , maka bukan matriks cek paritas
untuk kode linear dengan parameter [n + 1, k + 1, d]. Banyaknya vektor-vektor tan
nol dalam yang mungkin dipilih untuk x adalah . Sedangkan
banyaknya kombinasi linear yang mungkin dari kolom-kolom adalah
+ + … + , sehingga jika ada kode linear C dengan parameter
[n, k, d], dan persamaan 1 + + + … + < berlaku, maka
dapat dikonstruksi kode baru dengan parameter [n + 1, k + 1, d] berdasarkan kode
linear C tersebut.
Teorema 7
Diberikan kode linear C dengan panjang n. Jika H adalah matriks cek paritas
dari suatu kode dengan panjang n, maka kode tersebut mempunyai dimensi
(n – r) jika dan hanya jika ada r kolom dari H yang bebas linear tetapi tidak ada
r + 1 kolom dari H yang bebas linear (r adalah rank dari H).
Bukti:
Diberikan kode linear C dengan panjang n. Misalkan H adalah matriks cek
paritas bagi kode linear C. Misalkan pula G adalah matriks generator bagi kode
linear C. Kode linear C memiliki pangkat (n – r) jika dan hanya jika rank
(G) = (n – k). [karena G adalah basis, dan banyaknya baris di G menunjukkan
dimensi suatu kode]. Karena G dan H saling orthogonal, maka rank (G) = (n – r)
jika dan hanya jika rank (H) = r.
Teorema 8
Diberikan kode linear C dengan panjang n. Jika H adalah matriks cek paritas
dari suatu kode dengan panjang n maka kode tersebut mempunyai jarak minimum
d jika dan hanya jika setiap d – 1 kolom dari H yang bebas linear dan ada d kolom
dari H yang tidak bebas linear.
23 Bukti :
Diberikan kode linear C dengan panjang n. Misalkan H adalah matriks cek
paritas bagi kode linear C. Kode linear C berbobot minimum d jika dan hanya jika
kedua sarat berikut terpenuhi
i. Ada vektor v ϵ dengan wt (v) = d sehingga =
ii. untuk setiap w ϵ dengan wt (w) < d. (jika =
maka w ϵ C. Kontradiksi dengan fakta bahwa wt (w) < d).
Disisi lain, kedua sarat di atas (i dan ii) dapat terjadi jika dan hanya jika ada d
kolom dari H yang tidak bebas linear dan setiap d – 1 kolom dari H yang bebas
linear.
Teorema 9 (The Singleton bound)
Diberikan kode linear C. Jika C adalah kode dengan parameter [n, k, d]
maka (n – k) (d – 1).
Bukti :
Misal diberikan kode kode linear C dengan parameter [n, k, d], maka kode
linear C memiliki matriks cek paritas H berukuran (n – k) x n, sehingga
rank (H) ≤ (n – k). Dari teorema 7, matriks H memiliki d – 1 kolom yang bebas
linear. Sehingga rank (H) = (d – 1), dengan kata lain (d – 1) ≤ (d – k).
Mengonstruksi suatu kode, sama artinya dengan mengonstruksi matriks cek
paritas H. Berdasarkan teorema-teorema yang telah disebutkan di landasan teori,
maka cukup dikonstruksi bentuk standar dari H, yaitu H = . Dan atas
pertimbangan efisiensi komputasi, cukup dikonstruksi matriks B berukuran k r.
Dari teorema Gilbert-Vashamov diturunkan suatu teorema baru yaitu Teorema 10.
Dalam tulisan ini konstruksi kode linear biner optimal kuat dilakukan atas
dasar Teorema 10 berikut ini.
Teorema 10
Jika matriks B berukuran k r dikonstruksi berdasarkan sifat-sifat sebagai
berikut :
1. Semua vektor baris dari B berbeda, dan
2. Jumlah setiap i vektor baris dari B berbobot paling sedikit (d – i) untuk
i = 2, 3, …, s dimana s = min {d – 1 , k}, dan (d – 1) ≤ r,
24 maka H = dan G = secara berturut-turut merupakan matriks
cek paritas dan matriks generator untuk kode linear C dengan parameter
[k + r , k, ≥ d].
Bukti :
Misalkan telah dikonstruksi matriks B berukuran k r sebagaimana
disyaratkan teorema. Akan ditunjukan bahwa H = merupakan
matriks cek paritas untuk kode linear C dengan parameter [k + r , k, ≥ d].
Karena H berukuran r (k + r), maka C memiliki panjang k + r. Karena
jumlah baris matriks B sama dengan k, maka kode linear C berdimensi k.
Selanjutnya akan ditunjukan bahwa kode linear C memiliki jarak
minimum ≥ d. Andaikan ada v C dengan wt < d dan ditulis
v = dimana merupakan vektor pesan dengan wt = i dan
adalah vektor cek dengan wt = j , maka berlaku
i + j < d d – i wt < d – i ( 1.1 )
dan
H = = + = = ( 1.2 )
Karena wt = i , dan berdasarkan sifat 2 dari Teorema 10, maka
wt ≥ d – i ( 1.3 )
Dari persamaan 1.2 diperoleh bahwa = , sehingga persamaan 1.3
ekivalen dengan wt ≥ d – i. Hal ini kontradiksi dengan persamaan 1.1.
Sehingga dapat disimpulkan bahwa kode linear C memiliki jarak
minimum ≥ d.
Dari Teorema 10 , mengonstruksi kode linear C [k + r , k, ≥ d] sama artinya
dengan mengonstruksi matriks B yang berukuran k r yang semua baris dari B
berbeda dan jumlah setiap i vektor baris dari B berbobot paling sedikit (d – i),
untuk i = 2, 3, …, s dengan s = min { d – 1 , k }, dan (d – 1) < r.
Membahas Aritmetik Aljabar Matriks
Untuk kepentingan efisiensi komputasi maka data pada penelitian ini
disajikan dalam representasi himpunan. Sebelum melakukan eksplorasi untuk
mengonstruksi kode optimal kuat maka kita perlu melakukan pendefinisian data
25 yang kita gunakan dalam representasi himpunan. Adapun langkah-langkah yang
dilakukan dalam membangun aritmetik aljabar matriks mengacu pada tesis
Putranto HU (2011).
Langkah-langkah untuk membangun aritmetik aljabar matriks adalah sebagai
berikut:
a. Mendefinisikan Ruang Vektor Biner sebagai himpunan Kuasa
(power set) dari = {0, 1, 2, …., n – 1}.
Dalam penelitian ini sembarang vektor biner dengan panjang n secara
komputasi merupakan subhimpunan dari , sedangkan operasi jumlah
dari dua vektor diartikan sebagai selisih simetrik dari dua himpunan, dan
produk dalam dari dua vektor dipandang sebagai irisan dari dua
himpunan. Pada penelitian ini matriks biner A berordo n p kita pandang
sebagai list dari sebanyak p subhimpunan dari .
b. Mendefinisikan matriks sebagai list (daftar) dari sejumlah anggota .
Sebagai contoh :
* Jika A =
Ini artinya bahwa =
* B =
Artinya =
Program-program Aritmetik Aljabar Matriks Biner
Sebelum melakukan pelacakan kode optimal kuat terlebih dahulu kita
membangun aritmetik aljabar matriks dengan menggunakan program-program
yang mengacu pada tesis Putranto HU (2011). Rincian program-program ada di
Lampiran B.
Berikut ini adalah program-program yang digunakan :
26
a. AcakSet yaitu suatu program yang digunakan untuk membangkitkan
vektor dalam ruang berdimensi n secara acak.
b. Addv yaitu suatu program yang digunaakan untuk menjumlahkan dua
vektor.
c. MtxSetC yaitu program untuk mendefinisikan matriks kolom biner
berordo m n secara acak, dimana m adalah ukuran vektor baris dan n
adalah banyaknya vektor kolom dalam matriks.
d. MtxSetC1 yaitu program yang mendefinisikan matriks kolom biner
berordo m n secara acak, tidak vektor kolom yang nol. Dalam hal ini
m adalah panjang vektor dan n adalah banyaknya vektor kolom dalam
matriks.
e. UbahMtxCR yaitu program yang mengubah tampilan matriks kolom
ke matriks baris berukuran n m.
f. TrpsC yaitu suatu program yang digunakan untuk menentukan
transpose matriks kolom berordo m n menghasilkan matriks kolom
berordo n m.
g. TukarR yaitu suatu program yang digunakan untuk menukar baris ke-
i dan ke-j dalam matriks kolom berordo m n, dimana 0 ≤ i,
j ≤ m – 1.
h. GantiB yaitu suatu program yang digunakan untuk mengganti baris
ke-j dengan bris ke-i ditambah baris ke-j dalam matriks kolom berordo
m x n, dimana 0 ≤ i, j ≤ m – 1.
i. KanonC yaitu suatu program yang digunakan untuk menentukan
bentuk kanonik matriks kolom berordo m n , dimana m ≤ n.
j. AddMtx yaitu program yang digunakan untuk menjumlahkan dua
matriks.
k. DotV yaitu program untuk menentukan produk titik dari dua vektor.
l. MultMtx yaitu program untuk mengalikan matriks kolom m n
dengan matriks kolom n p.
m. InkodG yaitu program yang digunakan untuk mengkoding vektor
pesan P menjadi vektor katakode C menggunakan matriks generator
umum G berordo k n.
27
n. ParG yaitu program untuk menentukan vektor paritas X dari vektor
pesan P menggunakan matriks generator bentuk standar G = ,
dalam hal ini P dan B menjadi input, dan X adalah output. Vektor
C = adalah katakode dari pesan P.
o. InkodS yaitu program yang digunakan untuk mengkoding vektor
pesan P menjadi vektor katakode C menggunakan matriks generator
bentuk standar G = , dalam hal ini P dan B menjadi input.
p. HmDist yaitu suatu program untuk menentukan jarak hamming dari
dua vektor.
q. NonZeroWt yaitu suatu program untuk menentukanbobot tak- nol
dari suatu kode yang direpresentasikan oleh matriks generator G.
Program-program Pelacakan Kode Optimal Kuat
Untuk mengonstruksi kode optimal kuat digunakan program-program
pelacakan kode optimal kuat yang mengacu pada tesis Putranto HU (2011),
sedangkan rincian lengkap dari program-program ada di Lampiran C.
Program-program yang digunakan adalah sebagai berikut :
1. Diberikan matriks generator dalam bentuk standar G = .
2. Misalkan M adalah matriks representasi vektor baris dari B.
3. Menentukan list semua kombinasi j vektor dari vektor-vektor M
(representasi baris) untuk suatu nilai j=1,2,3,…..,k (dengan program
KombinM)
4. Menambah satu baris vektor v ke matriks M (representasi baris) di posisi
terahir (dengan program AddVekM).
5. Menghapus baris ke-i pada matriks M (representasi kolom) dengan
program DelVekM.
6. Menentukan list dari semua list kombinasi M untuk semua j=1,2,3,…..,t
dengan t = min{k,d-1}dengan program ListKombM.
7. Menguji apakah vektor x bisa ditambahkan ke M menggunakan output
ListKombM dengan program UjiAdd1VekM.
28
8. Melacak satu vektor baris x dalam yang bisa ditambahkan ke M
berlandaskan teorema Gilbert-Vashamov dengan program
Lacak1VekM. Prosedur ini menggunakan program UjiAdd1VekM.
9. Menentukan himpunan semua vektor baris x dalam yang bisa
ditambahkan ke M berdasarkan teorema Gilbert-Vashamov dengan
program Kolek1VekM. Prosedur ini menggunakan UjiAdd1VekM.
10. Membuang anggota output dari Kolek1VekM dan menyisakan vektor-
vektor yang menghasilkan matriks-matriks yang tidak saling ekivalen
jika ditambahkan ke M dengan program ReduEkil.
11. Misalkan himpunan H adalah output Kolek1VekM, maka setiap pasang
vektor (x, y) anggota H akan menghasilkan vektor z = x + y. Agar dua
vektor x dan y dapat ditambahkan langsung ke matriks M, maka z diuji
dengan prosedur UjiAdd2VekM berdasarkan output ListKombM.
12. Menentukan himpunan semua pasang (x, y) dalam yang bisa
ditambahkan ke M berdasarkan teorema Gilbert-Vashamov dengan
program Kolek2VekM. Prosedur ini menggunakan UjiAdd2VekM.
13. Menentukan himpunan semua pasang (x, y) menggunakan data hasil
sebelumnya dengan program Kolek2VekMDt.
14. Membuang anggota output Kolek2VekM dan menyisakan vektor-vektor
yang menghasilkan matriks-matriks yang tidak saling ekivalen jika
ditambahkan ke M dengan program ReduEkiX.
15. Misalkan himpunan H adalah output Kolek2VekM, maka setiap 3
vektor (x, y, z) anggota H akan menghasilkan vektor w = x + y + z,
agar tiga vektor x, y dan z dapat ditambahkan langsung ke matriks M,
maka W diuji dengan prosedur UjiAdd3VekM berdasarkan output
ListKombM.
16. Menentukan himpunan semua pasang (x, y, z) dalam yang dapat
ditambahkan ke M berdasarkan teorema Gilbert-Vashamov
menggunakan program Kolek3VekM. Prosedur ini menggunakan
program UjiAdd3VekM.
17. Menentukan himpunan semua pasang (x, y, z) menggunakan data hasil
sebelumnya dengan program Kolek3VekMDt.
29
18. Misalkan himpunan H adalah output Kolek3VekM, maka setiap 4
vektor (x, y, z, w) anggota H akan menghasilkan vektor v = w + x +
y + z, agar empat vektor x, y, z dan w dapat ditambahkan langsung ke
matriks M, maka v diuji dengan prosedur UjiAdd4VekM berdasarkan
output ListKombM.
19. Menentukan himpunan semua pasang (x, y, z, w) dalam yang dapat
ditambahkan ke M berdasarkan teorema Gilbert-Vashamov dengan
program Kolek4VekM. Prosedur ini menggunakan UjiAdd4VekM.
20. Menentukan himpunan semua pasang (x, y, z, w) menggunakan data
hasil sebelumnya dengan program Kolek4VekMDt.
21. Misalkan himpunan H adalah output Kolek4VekM, maka setiap lima
vektor (x, y, z, v, w) anggota H akan menghasilkan vektor u = w + v +
x + y + z, agar lima vektor x, y, z, v dan w dapat ditambahkan langsung
ke matriks M, maka u diuji dengan prosedur UjiAdd5VekM
berdasarkan output ListKombM.
22. Menentukan himpunan semua pasang (x, y, z, v, w) dalam yang dapat
ditambahkan ke M berdasarkan teorema Gilbert-Vashamov dengan
program Kolek5VekM. Prosedur ini menggunakan UjiAdd5VekM.
23. Menentukan himpunan semua pasang (x, y, z, v, w) menggunakan hasil
data sebelumnya dengan program Kolek5VekMDt.
24. Misalkan himpunan H adalah output dari Kolek(X-1)VekM, maka
setiap x vektor anggota H akan menghasilkan jumlah. Agar x vektor ini
dapat ditambahkan langsung ke matriks M, maka diuji dengan prosedur
UjiAddXVekM berdasarkan output ListKombM.
25. Menentukan himpunan semua x vektor yang dapat ditambahkan ke M
berdasarkan teorema Gilbert-Vashamov dengan program KolekXVekM.
Prosedur ini menggunakan UjiAddXVekM.
26. Menentukan himpunan semua pasang x vektor menggunakan data hasil
sebelumnya dengan program KolekXVekMDt.
30 Algoritme Konstruksi Kode Optimal Kuat
Dalam mengonstruksi kode optimal kuat digunakan algoritme-algoritme
yang mengacu pada tesis Putranto HU (2011), sedangkan rincian program
konstruksi ada di Lampiran D.
Berikut ini adalah algoritme-algoritme yang digunakan:
Algoritme 1 untuk mengkonstruksi kode optimal kuat adalah sebagai
berikut:
1. Masukan bentuk standar dari matriks H yaitu H =
Untuk mempertimbangkan efisiensi komputasi maka kita cukup
memasukan matriks B berukuran k r yang memenuhi sifst-sifat:
a. Vektor-vektor dari B berbobot paling sedikit ( d-1 ).
b. Jumlah setiap i-vektor baris dari B berbobot paling sedikit ( d-1 )
untuk i = 2, 3, …..s, dimana s = min { d-1, k }.
2. Eksplorasi matriks B dengan cara:
a. Menambahkan beberapa matriks kolom nol pada B sesuai dengan
yang diinginkan.
b. Menentukan list dari semua list kombinasi j vektor dari vektor-
vektor M (representasi baris) untuk semua j = 1, 2, 3,…, t dengan
t = min{k, d - 1}
c. Mengkoleksi semua vektor baris X dalam yang bisa ditambahkan ke
M berdasarkan teorema Gilbert-Vashamov.
3. Print salah satu kode optimal kuat hasil eksplorasi.
Dalam melakukan eksplorasi terhadap matriks B ini dilakukan secara
bertahap. Pada langkah 2a matriks kolom yang ditambahkan pada B adalah
matriks kolom nol dan penambahannya bisa satu kolom, dua kolom, tiga kolom,
dan seterusnya tergantung dengan kebutuhan. Pada langkah 2b menentukan semua
list dari peningkatan dimensi yang dapat dilakukan maksimal sama dengan
dimensi dari matriks yang akan diubah. Sebagai contoh jika matriks B yang akan
ditingkatkan dimensinya berukuran k r, maka matriks B ini hanya dapat
ditingkatkan maksimal sebanyak k dimensi. Pada langkah 2c mengoleksi vektor
baris x dalam yang dapat ditambahkan pada M berdasarkan teorema Gilbert-
Vashamov. Maksudnya adalah untuk meningkatkan dimensi dari matriks dasar.
31 Dimulai dengan meningkatkan satu dimensi, dua dimensi, tiga dimensi, empat
dimensi, lima dimensi dan seterusnya. Adapun algoritma yang digunakan adalah
sebagai berikut :
Algoritme 2 : mencari satu vektor x dalam yang dapat ditambahkan ke B
berdasarkan teorema Gilbert-Vashamov
1. Input vektor x ϵ
2. Bobot vektor x + sedemikian sehingga wt (X + ) ≥ d – 1 – i,
dengan adalah anggota dari semua kombinasi i-vektor baris di B
untuk i = 1,2,3,…t, dan t = min {d – 1, k}.
3. Jika x lulus uji lanjutkan langkah 4.
4. Print satu vektor yang dapat ditambahkan ke dalam matriks B.
Algoritme 3 : mencari dua vektor x dan y yang dapat ditambahkan ke dalam
matriks B berdasarkan teorema Gilbert-Vashamov.
1. Input adalah koleksi dari himpunan satu vektor yang dapat ditambahkan
ke matriks B, misalkan .
2. Jika wt ( z) > d – 2, dimana z = x + y untuk setiap x, y ϵ , maka
lanjutkan langkah 3.
3. Uji bobot vektor sedemikian sehingga wt ≥ d – 2 – i,
dengan adalah anggota dari semua kombinasi i-vektor baris di B
untuk i = 1,2,3,…t, dan t = min {d – 1, k}.
4. Jika x dan y lolos uji maka lanjutkan langkah 5.
5. Print dua vektor x dan y yang dapat ditambahkan ke dalam matriks B.
Algoritme 4 : menguji apakah m + 1 vektor bisa ditambahkan ke matriks B.
1. Input adalah koleksi dari himpunan m vektor anggota yang dapat
ditambahkan ke matriks B, misalkan .
2. Misal , ϵ . Jika dan digabung memiliki m + 1 vektor yang
berbeda maka selanjutnya dilakukan pengujian sebagai berikut.
a. Diuji apakah kedua vektor anggota ( ) – ( ) dapat
ditambahkan ke matriks B.
32
b. Diuji apakah kedua vektor anggota ( ) – ( ) yang jika
ditambahkan dengan setiap i vektor dalam ( ), i = 1, 2, …, m-1
bisa ditambahkan ke matriks B.
3. Untuk menguji j vektor yang bisa ditambahkan ke matriks B, yaitu dengan
menjumlahkan j vektor tersebut, misalkan hasil penjumlahannya adalah
vektor y. Jika wt (j) > (d – j) lanjutkan langkah 4.
4. Uji bobot vektor ( y + ) sedemikian sehingga wt ( y + ) ≥ d – j – i,
dengan adalah anggota dari semua kombinasi i vektor baris di B untuk
i = 1, 2, …, s, dan s = min {d – 1, k}.
5. Jika vektor y lolos uji, maka lanjutkan langkah 6.
6. Print m + 1 vektor yang dapat ditambahkan ke matriks B.
Berikut ini adalah program-program yang digunakan untuk meningkatkan
dimensi pada matriks dasar.
Tabel 2 Program dan Prosedur untuk meningkatkan dimensi dari matriks Dasar
Untuk meningkatkan Program Prosedur
1
2
3
4
5
6
Satu dimensi
Dua dimensi
Tiga dimensi
Empat dimensi
Lima dimensi
x dimensi
Kolek1VekM
Kolek2VekM
Kolek3VekM
Kolek4VekM
Kolek5VekM
KolekXVekM
UjiAdd1VekM
UjiAdd2VekM
UjiAdd3VekM
UjiAdd4VekM
UjiAdd5VekM
UjiAddXVekM
33 Konstruksi Kode Optimal Kuat Dengan Jarak Minimum 13 dan 15
Tabel 3 Hasil Eksplorasi Kode Optimal dengan jarak minimum d = 13
Panjang (n) Dimensi (k) Jarak Minimum (d) Kode [n, k, d]
20 2 13 [20, 2, 13]
24 3 13 [24, 3, 13]
27 5 13 [27, 5, 13]
29 6 13 [29, 6, 13]
32 8 13 [32, 8, 13]
34 9 13 [34, 9, 13]
1. Konstruksi kode [20, 2, 13]
Konstruksi dimulai dari kode [20, 2, 13], yaitu dengan mendefinisikan
matriks B yang berukuran 2 18 sebagai berikut
B =
Dengan menggunakan program UbahMtxCR mengubah tampilan matriks kolom
ke matriks baris M. Berikutnya untuk memastikan bahwa jarak minimum d = 13
maka di uji dengan program NonZeroWt.
2. Konstruksi kode [24, 3, 13]
Selanjutnya matriks B berordo 2 18 ini digunakan sebagai matriks dasar
untuk diperluas menjadi matriks yang berordo 3 21 dengan cara: pertama-
tama kita menambahkan tiga vektor kolom nol pada matriks dasar sehingga
matriks B berordo 2 21. Berikutnya kita mengubah tampilan matriks kolom ke
matriks baris M dengan program UbahMtxCR. Untuk memastikan bahwa
matriks dasar memiliki jarak minimum d = 13 maka kita uji dengan program
NonZeroWt. Karena matriks dasar berdimensi dua maka kita dapat
meningkatkanya sampai maksimum dua dimensi. Selanjutnya dengan program
ListKombM mencari semua kemungkinan vektor baris X dalam yang dapat
ditambahkan ke matriks M. Dengan program Kolek1VekM kita meningkatkan
dimensi dari matriks dasar menjadi tiga, sehingga dimensinya menjadi tiga. Tanpa
34 memperhatikan relasi ekivalensi, hasil eksplorasi menunjukan minimal ada
42.875 macam yang berordo 3 21 yang mendefinisikan kode dengan
parameter [24, 3. 13]. Dan dengan program ReduEki1 dihilangkan matriks-
matriks yang saling ekivalen ternyata diperoleh 8 macam yang tidak saling
ekivalen, salah satunya
=
3. Konstruksi kode [27, 5, 13]
Matriks berordo 3 21 ini dijadikan matriks dasar untuk diperluas
menjadi matriks yang berordo 5 22. Caranya adalah; Pertama-tama
matriks ini ditambah satu vektor kolom nol sehingga menjadi matriks dasar
yang berordo 3 22. Kemudian matriks diubah, dari tampilan matriks kolom
menjadi matriks baris M dengan menggunakan program UbahMtxCR. Untuk
memastikan bahwa matriks dasar memiliki jarak minimum d = 13 maka kita uji
dengan program NonZeroWt. Karena M berdimensi 3 maka kita dapat
meningkatkan matriks dasar ini maksimal 3 dimensi. Dengan program
ListKombM mencari semua kemungkinan vektor baris X dalam yang dapat
ditambahkan ke M. Dengan program Kolek1VekM kita tingkatkan dimensi dari
matriks dasar satu tingkat sehingga dimensinya menjadi empat, dan hasilnya
terdapat minimal ada 17.496 kode dengan parameter [26, 4, 13]. Selanjutnya
ditingkatkan lagi dimensinya menjadi menjadi lima dengan cara menambahkan
satu lagi vektor baris X dalam ke M dengan program Kolek2VekMDt. Dari hasil
eksplorasi tanpa melihat relasi ekivalensi ternyata minimal ada 39.432 macam
matriks berordo 5 22 yang mendefinisikan kode dengan parameter
[27, 5, 13]. Dengan program ReduEkiX dihilangkan matriks-matriks yang saling
ekivalen. Hasilnya hanya minimal ada 4 macam matriks yang tidak saling
ekivalen. Salah satunya adalah
35
=
4. Konstruksi kode [29, 6, 13]
Matriks berordo 5 22 ini dijadikan matriks dasar untuk diperluas lagi
menjadi matrik yang berordo 6 23. Dengan cara ; Pertama-tama matriks
dasar ini ditambahkan satu vektor kolom nol sehingga menjadi matriks dasar yang
berordo 5 23. Dengan program UbahMtxCR diubah tampilan matriks, dari
matriks kolom menjadi matriks baris M. Untuk memastikan bahwa matriks dasar
kita mempunyai jarak minimum d = 13, maka kita uji dengan menggunakan
program NonZeroWt. Karena dimensi dari matriks dasar kita adalah lima, maka
kita dapat meningkatkan dimensi dari matriks dasar tersebut maksimal lima
dimensi. Dengan program ListKombM mencari semua kemungkinan vektor
baris X dalam yang dapat ditambahkan ke M. Dengan program Kolek1VekM
kita tingkatkan dimensi dari matriks dasar satu tingkat menjadi enam. Dari hasil
eksplorasi paling tidak ada satu macam matriks berukuran 6 23 yang
mendefinisikan kode dengan parameter [29, 6, 13]. Matriks tersebut adalah
=
5. Konstruksi kode [32, 8, 13]
Matriks berordo 6 23 ini dijadikan matriks dasar untuk diperluas lagi
menjadi matriks berordo 8 24 yang mendefinisikan kode dengan parameter
[32, 8, 13]. Dengan cara; Pertama-tama ditambahkan satu vektor kolom nol dan
menghapus baris ke-1 pada matriks representasi kolom dengan program
DelVekM sehingga didapat matriks dasar yang berordo 5 24. Kemudian
dengan program UbahMtxCR diubah tampilan matriks, dari matriks kolom
menjadi matriks baris M. Karena matriks dasar kita berdimensi lima maka, kita
dapat meningkatkan maksimal sampai lima dimensi. Dengan program
ListKombM mencari semua kemungkinan vektor baris X dalam yang dapat
36 ditambahkan ke M. Dengan program Kolek1VekM kita meningkatkan dimensi
dari matriks dasar satu tingkat sehingga dimensinya menjadi enam. Setelah
ditingkatkan satu dimensi ternyata diperoleh setidaknya ada 14.692 kode dengan
parameter [30, 6 13]. Berikutnya dengan program Kolek2VekMDt dimensinya
ditingkatkan satu tingkat lagi menjadi tujuh, dan didapat paling sedikit ada 1.000
kode dengan parameter [31, 7, 13]. Selanjutnya dengan program
Kolek3VekMDtx, dimensinya ditingkatkan satu tingkat lagi menjadi delapan,
dan diperoleh paling sedikit ada 192 matriks berordo 8 24 yang
mendefinisikan kode dengan parameter [32, 8, 13]. dan setelah dihilangkan
matriks-matriks yang saling ekivalen dengan program ReduEkiX ternyata
semuanya tidak saling ekuivalen, Sehingga didapat paling tidak ada 192 matriks
berukuran 8 24 yang mendefinisikan kode dengan parameter [32, 8, 13].
Salah satunya adalah
=
6. Konstruksi kode [34, 9, 13]
Matriks berordo 8 24 dijadikan matriks dasar untuk diperluas lagi
menjadi matriks berordo 9 25 untuk mendefinisikan kode dengan parameter
[34, 9, 13]. Dengan cara; Pertama-tama ditambahkan satu vektor kolom nol, dan
menghapus baris ke-1 pada matriks representasi kolom dengan program
DelVekM sehingga didapat matriks dasar yang berukuran 7 25. Kemudian
dengan program UbahMtxCR diubah tampilan matriks, dari matriks kolom
menjadi matriks baris M. Karena matriks dasar ini berdimensi tujuh maka kita
dapat meningkatkan matriks dasar ini maksimal sampai tujuh dimensi. Dengan
program ListKombM mencari semua kemungkinan vektor baris X dalam yang
dapat ditambahkan ke M. Dengan program Kolek1VekM kita tingkatkan satu
dimensi sehingga ukuran matriks menjadi 8 25, ternyata didapat paling sedikit
ada 2.107 kode dengan parameter [33, 8, 13]. Selanjutnya dengan program
Kolek2VekMDt dimensinya ditingkatkan lagi satu tingkat sehingga ukuran
37 matriks menjadi 9 25, ternyata didapat paling sedikit ada dua matriks
berukuran 9 25 yang mendefinisikan kode dengan parmeter [34, 9, 13]. Matriks
yang didapat sebagai berikut:
[1] =
Dan
[2] =
Untuk selanjutnya ini gagal untuk diperluas lagi. Seandainya matriks
tersebut dapat diperluas menjadi matriks berukuran 10 25 maka telah berhasil
diperbaiki batas bawah untuk kode yang berjarak minimum d = 13, yaitu kode
dengan parameter [35, 10, 13]. Atau dengan kata lain telah berhasil dikonstruksi
kode baru yaitu kode [35, 10, 13].
Tabel 4 Hasil Eksplorasi Kode Optimal dengan jarak minimum d = 15
Panjang (n) Dimensi (k) Jarak Minimum (d) Kode [ n, k, d ]
23 2 15 [23, 2, 15]
27 3 15 [27, 3, 15]
31 6 15 [31, 6, 15]
35 8 15 [35, 8, 15]
37 9 15 [37, 9, 15]
38
7. Konstruksi kode [23, 2, 15]
Untuk kode [ 23, 2, 15 ] dapat dikonstruksi dengan mudah menggunakan
matriks B berukuran 2 21 sebagai berikut
B =
Tetapi matriks B ini tidak berhasil diperluas untuk mendapatkan kode optimal
berikutnya.
8. Konstruksi kode [27, 3, 15]
Karena matriks B tidak dapat diperluas untuk mendapatkan kode optimal
berikutnya, maka selanjutnya dikonstruksi matriks dasar berukuran 3 24
untuk mendefinisikan kode dengan parameter [ 27, 3, 15 ]. Matriks yang
digunakan adalah sebagai berikut
=
9. Konstruksi kode [31, 6, 15]
Matriks berordo 3 24 ini dijadikan sebagai matriks dasar untuk
diperluas menjadi matriks yang berordo 6 25 untuk mendefinisikan kode
dengan parameter [31, 6, 15]. Dengan cara; pertama menambahkan satu vektor
kolom nol pada matriks dasar sehingga matriks dasar ordonya menjadi 3 25,
dilanjutkan dengan mengubah tampilan matriks, dari matriks kolom menjadi
matriks baris M dengan program UbahMtxCR. Selanjutnya untuk memastikan
bahwa jarak minimum distenya 15 maka digunakan program NonZeroWt.
Karena matriks yang dijadikan matriks dasar mempunyai dimensi tiga, maka
dimensinya dapat ditingkatkan maksimal tiga dimensi. Dengan program
ListKombM mencari semua kemungkinan vektor baris X dalam yang dapat
ditambahkan ke M. Dengan program Kolek1VekM ditingkatkan satu dimensi
sehingga dimensinya menjadi empat dan didapat paling sedikit 34.992 kode
dengan para meter [29, 4, 15]. Berikutnya dengan program Kolek2VekMDt
dimensinya ditingkatkan satu tingkat lagi menjadi lima, tanpa memperhatikan
relasi ekuivalensi didapat paling sedikit ada 199.904 kode dengan parameter
39 [30, 5, 15]. Dengan program Kolek3VekMDt dimensinya ditingkatkan satu
tingkat lagi menjadi enam, dan tanpa memperhatikan relasi ekuivalensi didapat
paling sedikit ada 9.309 matriks berordo 6 25 yang mendefinisikan kode
dengan parameter [31, 6, 15]. Salah satunya adalah
=
10. Konstruksi kode [35, 8, 15]
Matriks berordo 6 25 ini dijadikan matriks dasar untuk diperluas lagi
menjadi matriks yang berordo 8 27, yaitu untuk mendefinisikan kode
dengan parameter [ 35, 8, 15 ]. Cara mengonstruksi matriks adalah sebagai
berikut ; Yang pertama menambahkan dua vektor kolom nol pada matriks dasar
dan dengan program DelVekM untuk i = 1, menghapus baris ke-1 pada matriks
dasar sehingga didapat matriks dasar yang berordo 5 27. Untuk memastikan
bahwa matriks dasar mempunyai jarak minimum d = 15 maka di uji dengan
program NonZeroWt. Sebelum melakukan eksplorasi lebih lanjut, terlebih dulu
kita mengubah tampilan matriks, dari matriks kolom menjadi matriks baris M
dengan program UbahMtxCR. Karena matriks dasar berdimensi lima maka kita
dapat meningkatkanya sampai maksimal lima dimensi. Selanjutnya Dengan
program ListKombM mencari semua kemungkinan vektor baris X dalam yang
dapat ditambahkan ke M. Dengan program Kolek1VekM kita tingkatkan satu
dimensi sehingga dimensinya menjadi enam, hasilnya minimal ada 3.971 matriks
dasar beerordo 6 27 yang medefinisikan kode dengan parameter [33, 6, 15].
Langkah selanjutnya dengan program Kolek2VekM matriks dasar ini
dimensinya kita tingkatkan satu tingkat lagi menjadi tujuh, hasilnya minimal ada
19930 matriks dasar yang berordo 7 27 yang mendefinisikan kode dengan
parameter [34, 7, 15]. Berikutnya matriks dasar ini kita tingkatkan satu tingkat
lagi dengan program Kolek3VekM sehingga dimensinya menjadi delapan,
hasilnya tanpa memperhatikan relasi ekuivalensi minimal ada 1.699 matriks
berordo 8 27 yang mendefinisikan kode dengan parameter [35, 8, 15]. Dan
setelah dihilangkan matriks-matriks yang saling ekuivalen dengan program
40 ReduEkiX didapat minimal ada 689 kode optimal kuat dengan parameter
[35,8,15]. Salah satunya adalah
=
11. Konstruksi kode [37, 9, 15]
Matriks berordo 8 27 ini dijadikan matriks dasar untuk diperluas lagi
menjadi matriks yang berordo 9 28 untuk mendefinisikan kode dengan
parameter [ 37, 9, 15 ]. Cara mengonstruksi matriks adalah sebagai berikut ;
Yang pertama menambahkan satu vektor kolom nol pada matriks dasar dan
dengan program DelVekM untuk i = 8, menghapus baris ke-8 pada matriks dasar
sehingga didapat matriks dasar yang berordo 7 28. Untuk memastikan bahwa
matriks dasar mempunyai jarak minimum d = 15 maka di uji dengan program
NonZeroWt. Sebelum melakukan eksplorasi lebih lanjut, terlebih dulu kita
mengubah tampilan matriks, dari matriks kolom menjadi matriks baris M dengan
program UbahMtxCR. Karena matriks dasar berdimensi tujuh maka kita dapat
meningkatkanya sampai maksimal tujuh dimensi. Selanjutnya Dengan program
ListKombM mencari semua kemungkinan vektor baris X dalam yang dapat
ditambahkan ke M. Dengan program Kolek1VekM kita tingkatkan satu dimensi
sehingga dimensinya menjadi delapan, hasilnya minimal ada 2.472 matriks dasar
beerordo 8 28 yang medefinisikan kode dengan parameter [36, 8, 15].
Selanjutnya dengan program Kolek2VekM matriks dasar ini dimensinya kita
tingkatkan satu tingkat lagi menjadi sembilan, hasilnya tanpa melihat relasi
ekuivalensi minimal ada 542 matriks dasar yang berordo 9 28 yang
mendefinisikan kode optimal kuat dengan parameter [37, 9, 15]. Dan setelah
dihilangkan matriks-matriks yang saling ekuivalen dengan program ReduEkiX
didapat minimal ada 281 kode optimal kuat dengan parameter [37, 9, 15]. Salah
satunya adalah
41
=
Selanjutnya untuk menjadikan matriks menjadi matriks dasar dan
ditingkatkan ke order yang lebih tinggi mengalami kegagalan. Kegagalan ini
dapat disebabkan oleh beberapa kemungkinan, diantaranya:
1. Pemilihan kode dasar ( matriks B awal ) yang kurang baik.
2. Algoritme konstruksi yang masih belum sempurna.
BAB V
KESIMPULAN DAN SARAN
Kesimpulan
Dalam penelitian ini, telah dibahas teorema-teorema dasar yang cukup
penting dalam konstruksi kode linear biner, terutama teorema Gilbert-Varshamov.
Dari teorema Gilbert-Varshamov, diturunkan suatu teorema yang berkaitan
langsung dengan konstruksi kode linear biner. Dari teorema baru ini, dikonstruksi
algoritme-algoritme untuk mengontruksi kode linear biner.
Selanjutnya, algoritme-algoritme tersebut diimplementasikan dalam program
MAPLE (dalam representasi himpunan) Program ini diujicobakan untuk
mengonstruksi kode linear biner dengan jarak minimum 13 dan 15.
Dalam penelitian ini, kode linear biner yang berhasil dikonstruksi untuk
d = 13 adalah sebagai berikut: [20, 2,13], [24, 3, 13], [27,5,13], [29, 6, 13],
[32, 8, 13], [34, 9, 13]. Hasil konstruksi untuk d = 13 tersebut telah sama dengan
rekor dunia dalam mengonstruksi kode optimal kuat. Artinya semua kode optimal
kuat untuk d = 13 yang pernah dikonstruksi orang (yang tercatat dalam tabel
Brouwer) telah berhasil dikonstruksi semuanya, sedangkan untuk kode
[35, 10, 13] yang merupakan problem terbuka dalam teori koding telah gagal
untuk dikonstruksi.
Untuk kode optimal kuat dengan d = 15 yang berhasil dikonstruksi sebagai
berikut: [23, 2, 15], [27, 3, 15], [31, 6, 15], [35, 8, 15], [37, 9, 15]. Sedangkan
untuk kode dengan k > 9 dalam hal ini telah gagal untuk dikonstruksi. Sebagai
perbandingan hasil konstruksi untuk d = 15 yang telah dicatat dalam tabel
Brouwer telah mencapai k = 14 yaitu sampai dengan kode [44, 14, 15].
Kegagalan yang terjadi dalam memperbaiki batas bawah tabel Brouwer
untuk kode optimal kuat dengan d = 13 dan hasil konstruksi untuk d = 15 yang
hanya mencapai k = 9 dan n = 37, hal ini disebabkan antara lain oleh:
1. Pemilihan kode dasar (matrik B awal) yang kurang baik.
2. Algoritme konstruksi yang masih belum sempurna.
43
Saran
Dalam penelitian ini, masih banyak kekurangan yang ada di dalamnya, di
antaranya adalah:
1. Tidak semua kode linear optimal kuat dapat dikonstruksi, walaupun
kode tersebut ada (telah dikonstruksi oleh orang lain).
2. Algoritme konstruksi, walaupun sudah cukup baik, masih dapat
diperbaiki dalam hal kecepatan pelacakan kode-kode linear biner,
terutama untuk dimensi yang cukup besar.
Untuk ke depannya, dapat diperbaiki algoritme konstruksi sehingga dapat
mencari/melacak kode dengan lebih cepat dan dapat mencakup kode linear yang
memiliki dimensi yang besar. Selain itu, dapat pula dikembangkan program untuk
mengoleksi kode-kode atas , untuk q > 2.
44
44
DAFTAR PUSTAKA
Brower A. E. 1997. “Bounds on the size of linear codes” in Handbook of Coding theory. Elvisier. Gunawan Santosa R. 2009. Aljabar Linear Dasar. Yogyakarta: Penerbit ANDI. MacWilliams FJ, Sloane NJA. 1981. The Theory of Error-Correcting Codes. North-HollandPublishing Company. Amsterdam. Markus Grassl. Code Tables: Bounds on the parameters of various types of codes. http://codetables.de/ [15 Juni 2011]. Ling & Xing, 2004. Coding Theory – A First Course. New York: Cambrige.
Putranto HU. 2011. Konstruksi Kode Linear Biner Optimal Kuat dengan Jarak Minimum 9 dan 11 [Tesis]. Bogor: Program Pascasarjana, Institut Pertanian Bogor. Sugi Guritman 2005. Aljabar Linear Lanjut. Bogor: Departemen Matematika Fakultas MIPA Institut Pertanian Bogor.
46
B. Program Aritmetik Aljabar Matriks Biner Dengan Representasi Himpunan. 1. AcakSet membangkitkan vektor dalam ruang dimensi n secara acak.
> AcakSet:=proc(m::posint) local AcIn::procedure, p::integer: AcIn:=rand(2^m): p:=AcIn(): UbahDesKeSet(p); end proc:
2. AddV menjumlahkan dua vektor > AddV:=proc(S::set,T::set) return({op(S minus T),op(T minus S)}); end proc:
3. MtxSetC mendefinisikan matriks kolom biner berordo mxn secara acak. Dalam ini, m adalah ukuran vektor baris, dan n adalah banyaknya vektor kolom dalam matriks.
> MtxSetC:=proc(m::integer,n::integer) local M::list, S::set, i,j::integer: M:=[]: for i from 1 to n do S:=AcakSet(m): M:=[op(M),S]: end do: return([m,M]); end proc:
4. MtxSetC1 mendefinisikan matriks kolom biner berordo mxn secara acak. Dalam ini m adalah panjang vektor dan n adalah banyaknya vektor kolom dalam matriks. Tidak vektor kolom yang nol.
> MtxSetC1:=proc(m::integer,n::integer) local M::list, S::set, i,j::integer: M:=[]: for i from 1 to n do S:=AcakSet(m): for j while S={} do S:=AcakSet(m): end do: M:=[op(M),S]: end do: return([m,M]); end proc:
5. UbahMtxCR mengubah tampilan matriks kolom ke matriks baris berordo n x m.
> UbahMtxCR:=proc(A::list) local M,N::list, S::set, i,j,m,n::integer: M:=op(2,A): n:=nops(M): m:=op(1,A): N:=[]: for i from 0 to m-1 do S:={}:
47
for j from 1 to n do if i in M[j] then S:={op(S),j-1}: end if: end do: N:=[op(N),S] end do: return([N,n]); end proc: UbahMtxRC:=proc(A::list) local B,N::list: B:=[op(2,A),op(1,A)]: N:=UbahMtxCR(B); return([N[2],N[1]]); end proc:
6. TrpsC menentukan transpose matriks kolom berordo mxn menghasilkan matriks kolom berordo n x m.
> TrpsC:=proc(A::list) local M,N::list, m::integer: M:=UbahMtxCR(A); m:=op(2,M): N:=op(1,M): return([m,N]); end proc:
7. TukarR menukar baris ke-i dan ke-j dalam matriks kolom berordo m x n, dimana 0 <= i, j <= m - 1.
> TukarR:=proc(i::integer,j::integer,A::list) local M::list, S,T::set, k,n::integer: M:=op(2,A): n:=nops(M): for k from 1 to n do S:=M[k] intersect {i,j}: if nops(S)=1 then T:=AddV(M[k],{i,j}): M:=subsop(k=T,M): end if: end do: return([op(1,A),M]); end proc:
8. GantiB mengganti baris ke-j dengan baris ke-i ditambah baris ke-j dalam matriks kolom berordo mxn, dimana 0 <= i, j <= m - 1.
> GantiB:=proc(i::integer,j::integer,A::list) local M::list, S::set, k,n::integer: M:=A: n:=nops(M): for k from 1 to n do if i in M[k] then S:=AddV(M[k],{j}): M:=subsop(k=S,M): end if: end do:
48
return(M); end proc:
9. KanonC menentukan bentuk kanonik matriks kolom berordo m x n, dimana "m<= n."
> KanonC:=proc(A::list) local M,N::list, S,T::set, i,j,m,n,u,v,w,k::integer: M:=op(2,A): n:=nops(M): m:=op(1,A): w:=m: v:=n: N:=[]: for i from 0 while i<m do k:=i+1: if i in M[k] then S:=M[i+1] minus {i}: for j in S do M:=GantiB(i,j,M); end do: else T:={}: for j while T={} and k<n do T:=M[k+1] intersect {i}: k:=k+1: end do: if k>(i+1) and k<n then M:=subsop(i+1=M[k],k=M[i+1],M): S:=M[i+1] minus {i}: for j in S do M:=GantiB(i,j,M); end do: elif k=n and T<>{} then M:=subsop(i+1=M[k],k=M[i+1],M): S:=M[i+1] minus {i}: for j in S do M:=GantiB(i,j,M); end do: elif k=n and T={} then u:=max(op(M[i+1])): if u>i then N:=TukarR(i,u,[w,M]); M:=op(2,N): S:=M[i+1] minus {i}: for j in S do M:=GantiB(i,j,M); end do: else N:=TukarR(i,m,[w,M]); M:=op(2,N): m:=m-1: M:=subsop(i+1=M[v],v=M[i+1],M): v:=v-1: k:=i+1:
49
if i in M[i+1] then S:=M[i+1] minus {i}: for j in S do M:=GantiB(i,j,M); end do: else T:={}: for j while T={} and k<n do T:=M[k+1] intersect {i}: k:=k+1: end do: if k>(i+1) and k<n then M:=subsop(i+1=M[k],k=M[i+1],M): S:=M[i+1] minus {i}: for j in S do M:=GantiB(i,j,M); end do: elif k=n and T<>{} then M:=subsop(i+1=M[k],k=M[i+1],M): S:=M[i+1] minus {i}: for j in S do M:=GantiB(i,j,M); end do: elif k=n and T={} then u:=max(op(M[i+1])): if u>i then N:=TukarR(i,u,[w,M]); M:=op(2,N): S:=M[i+1] minus {i}: for j in S do M:=GantiB(i,j,M); end do: else N:=TukarR(i,m,[w,M]); M:=op(2,N): m:=m-1: M:=subsop(i+1=M[v],v=M[i+1],M): v:=v-1: end if: end if: end if: end if: end if: end if: end do: return([w,M]); end proc:
10. AddMtx menjumlahkan dua matriks. > AddMtx:=proc(M::list,N::list) local A,B,H::list, m,n::integer:
50
A:=op(2,M): B:=op(2,N): m:=op(1,M): n:=nops(B): if m<>op(1,N) or nops(A)<>n then return(false) end if: H:=[seq(AddV(A[i],B[i]),i=1..n)]: return([m,H]); end proc:
11. DotV menentukan produk titik dua vektor > DotV:=proc(S::set,T::set) local C::integer: C:=nops(S intersect T) mod 2; return(C); end proc:
12. MultMtx mengalikan matriks kolom m x n dengan matriks kolom "n x p."
> MultMtx:=proc(M::list,N::list) local TA,A,B,H::list, S::set, m,n,i,j,k,p::integer: A:=op(2,M): B:=op(2,N): m:=op(1,M): n:=op(1,N): p:=nops(B): if n<>nops(A) then return(false) end if: TA:=(op(2,TrpsC(M))): H:=[]: for i from 1 to p do S:={}: for j from 1 to m do k:=DotV(TA[j],B[i]): if k=1 then S:={op(S),j-1}: end if: end do: H:=[op(H),S] end do: return([m,H]); end proc:
13. InkodG mengkoding vektor pesan P menjadi vektor katakode C menggunakan matriks generator umum G berordo k x n.
> InkodG:=proc(P::set,G::list) local A,B,C::list, H::set, k,p::integer: k:=op(1,G): A:=TrpsC([k,[P]]): B:=MultMtx(A,G): C:=TrpsC(B): H:=op(C[2]): return(H); end proc:
14. ParG menentukan vektor paritas X dari vektor pesan P menggunakan matriks generator bentuk standar " G=[ |B]," dalam hal ini P dan B menjadi input, dan X adalah output. Vektor C = (P|X) adalah katakode dari pesan P.
> ParG:=proc(P::set,B::list) local S::set, r,i,s::integer: r:= nops(B): S:={}:
51
for i from 1 to r do s:=DotV(P,B[i]): if s=1 then S:={op(S),i-1}: end if: end do: return(S); end proc:
15. InkodS mengkoding vektor pesan P menjadi vektor katakode C menggunakan matriks generator bentuk standar " G=[ |B]," dalam hal ini P dan B menjadi input InkodS:=proc(P::set,B::list,k::posint)
> local S::set, r,i,s::integer: r:= nops(B): S:=P: for i from 1 to r do s:=DotV(P,B[i]): if s=1 then S:={op(S),k+i-1}: end if: end do: return(S); end proc:
16. HmDist menentukan jarak Hamming dua vektor > HmDist:=proc(S::set,T::set) local C::set: C:=AddV(S,T); return(nops(C)); end proc:
17. NonZeroWt menentukan bobot tak-nol dari suatu kode yang direpresentasikan oleh matriks generator G.
> NonZeroWt:=proc(B::list) local Wt,C,P::set, i,r,m,k::integer: k:=B[1]: m:=2^k-1: Wt:={}: for i from 1 to m do P:=UbahDesKeSet(i); C:=InkodS(P,B[2],k); r:=nops(C): Wt:={op(Wt),r}: end do: return(Wt); end proc:
C. Program Pelacakan Kode Optimal Kuat. 18. KombinM menentukan list semua kombinasi j vektor dari vektor-vektor M (representasi baris) untuk suatu nilai "j=1,2,...,k."
> KombinM:=proc(j::posint,M::list) local S,C,L,K,N::set, W::list, i,k::integer: K:= M[1]: k:=nops(K):
52
L:={seq(i,i=1..k)}: N:=combinat[choose](L,j): W:=[]: for S in N do C:={}: for i in S do C:=AddV(C,K[i]): end do: W:=[op(W),C]: end do: return(W); end proc:
19. AddVekM menambah satu baris vektor V ke matriks M (representasi baris) di posisi terakhir.
> AddVekM:=proc(V::set,M::list) local S::list, r::integer: S:=[op(M[1]),V]: r:=max(max(V),M[2]); return([S,r]); end proc: > AddVekMX:=proc(H::set,M::list) local S::list, V::set: S:=M: for V in H do S:=AddVekM(V,S): end do: return(S); end proc:
20. DelVekM menghapus baris ke-i pada matriks M (representasi kolom). > DelVekM:=proc(i::posint,A::list) local M,T,N,B::list, m,n::integer: M:=op(2,A): n:=nops(M): m:=op(1,A): T:=TrpsC(A): N:=subsop(i=NULL,T[2]): B:=TrpsC([n,N]): return(B); end proc:
21. ListKombM menentukan list dari semua list KombinM untuk semua j = 1, 2, 3,. .. , t dengan t = min {k, d - 1}
> ListKombM:=proc(M::list,t::posint) local L,T::list, j::integer: L:=[]: for j from 1 to t do T:=KombinM(j,M); L:=[op(L),T]: end do: return(L); end proc:
53
22. UjiAdd1VekM menguji apakah vektor X bisa ditambahkan ke M menggunakan output ListKombM.
> UjiAdd1VekM:=proc(d::posint,X::set,L::list) local K,T,H::list, i,j,b,n,h,k::integer: T:=subsop(1=NULL,L[1]): H:=subsop(1=T,L): h:=nops(H): for i from 1 to h do K:=H[i]: k:=nops(K): b:=d-1-i: for j from 1 to k do n:=HmDist(X,K[j]): if n<b then return(false); end if: end do: end do: return(true); end proc:
23. Lacak1VekM melacak satu vektor baris X dalam yang bisa ditambahkan ke M berdasarkan teorema Gilbert-Vashamov. Prosedur ini menggunakan UjiAdd1VekM.
> Lacak1VekM:=proc(d::posint,t::posint,r::posint,L::list) local S,R,X,Y,Z,V,W::set, B::list, i,j,k,v,x::integer, T::symbol: B:=L[1]: V:=B[1]: v:=nops(V): W:={seq(i,i=0..r-1)} minus V: for j from d-2 to t do for i from 0 to v do if (v+j-2*i)>=(d-1) then S:=combinat[choose](V,v-i): R:=combinat[choose](W,j-i): for Y in S do for Z in R do X:={op(Y),op(Z)}: T:=UjiAdd1VekM(d,X,L); if T=true then return(X); end if: end do: end do: end if: end do: end do: return(0); end proc: >Kolek1VekM menentukan himpunan semua vektor baris X dalam yang bisa ditambahkan ke M berdasarkan teorema Gilbert-Vashamov. Prosedur ini menggunakan UjiAdd1VekM. Kolek1VekM:=proc(d::posint,t::posint,r::posint,L::list)
54
local S,R,C,X,Y,Z,V,W::set, B::list, i,j,k,v,x::integer, T::symbol: B:=L[1]: V:=B[1]: v:=nops(V): C:=[]: W:={seq(i,i=0..r-1)} minus V: for j from d-2 to t do for i from 0 to v do if (v+j-2*i)>=(d-1) then S:=combinat[choose](V,v-i): R:=combinat[choose](W,j-i): for Y in S do for Z in R do X:={op(Y),op(Z)}: T:=UjiAdd1VekM(d,X,L); if T=true then C:=[op(C),X]: end if: end do: end do: end if: end do: end do: return(C); end proc:
24. ReduEki1 membuang anggota output Kolek1VekM dan menyisakan vektor-vektor yang menghasilkan matriks-matriks tidak saling ekivalen jika ditambahkan ke M,
>ReduEki1:=proc(H::list,M::list) local i,h::integer, A,L,G,K,R::list, Q,S::set: h:=nops(H): A:=H[1]: G:=AddVekM(A,M): K:=UbahMtxRC(G): L:=sort(map(S->UbahSetKeDes(S),K[2])): R:=[A]: Q:={L}: for i from 2 to h do A:=H[i]: G:=AddVekM(A,M): K:=UbahMtxRC(G): L:=sort(map(S->UbahSetKeDes(S),K[2])): S:={L} intersect Q: if S={} then Q:={op(Q),L}: R:=[op(R),A]: end if: end do: return(R): end proc:
25. Misalkan himpunan H adalah output Kolek1VekM, setiap pasangan vektor (X,Y) anggota H akan mehasilkan vektor Z = X + Y. Agar dua vektor X dan Y
55
bisa ditambahkan langsung ke matriks M, maka Z diuji dengan prosedur UjiAdd2VekM berdasarkan output ListKombM.
> UjiAdd2VekM:=proc(d::posint,Z::set,L::list) local H,G::list, i,j,g,b,k,n,t::integer: if nops(Z)<(d-2) then return(false) end if; H:=L: k:=nops(L[1]): n:=min(d-3,k): for i from 1 to n do G:=H[i]: g:=nops(G): b:=d-2-i: for j from 1 to g do t:=HmDist(Z,G[j]): if t<b then return(false); end if: end do: end do: return(true); end proc:
26. Kolek2VekM menentukan himpunan semua pasang (X,Y) dalam yang bisa ditambahkan ke M berdasarkan teorema Gilbert-Vashamov. Prosedur ini menggunakan UjiAdd2VekM.
> Kolek2VekM:=proc(d::posint,H::list,L::list,c::posint) local X,Y,Z::set, C::list, h,i,j::integer, T::symbol: h:=nops(H): C:=[]: for i from 1 to (h-1) do X:=H[i]: for j from (i+1) to h do Y:=H[j]: Z:=AddV(X,Y): T:=UjiAdd2VekM(d,Z,L): if T=true then C:=[op(C),{X,Y}]: if nops(C)=c then C:=[op({op(C)})]: return(C); end if: end if: end do: end do: C:=[op({op(C)})]: return(C): end proc:
27. Kolek2VekMDt menentukan himpunan semua pasang (X,Y) menggunakan data hasil sebelumnya.
> Kolek2VekMDt:=proc(d::posint,H::list,L::list,c::posint,Dat::list) local X,Y,Z::set, h,i,j,k::integer, F,C::list, T::symbol: C:=Dat[2]: k:=Dat[1]: h:=nops(H):
56
for i from k to (h-1) do X:=H[i]: for j from (i+1) to h do Y:=H[j]: Z:=AddV(X,Y): T:=UjiAdd2VekM(d,Z,L): if T=true then C:=[op(C),{X,Y}]: if nops(C)=c then C:=[op({op(C)})]: F:=[i,C]: save F, "D:\\Explor Files\\Coding Theory\\DataOutD13\\DatTemp2.m"; return(C); end if: end if: end do: end do: F:=[op({op(C)})]: save F, "D:\\Explor Files\\Coding Theory\\DataOutD13\\DatTemp2.m"; return(F): end proc:
28. ReduEkiX membuang anggota output Kolek2VekM dan menyisakan vektor-vektor yang menghasilkan matriks-matriks tidak saling ekivalen jika ditambahkan ke M,
> ReduEkiX:=proc(H::list,M::list) local i,h::integer, A,L,G,K,R::list, Q,S::set: h:=nops(H): A:=H[1]: G:=AddVekMX(A,M): K:=UbahMtxRC(G): L:=sort(map(S->UbahSetKeDes(S),K[2])): R:=[A]: Q:={L}: for i from 2 to h do A:=H[i]: G:=AddVekMX(A,M): K:=UbahMtxRC(G): L:=sort(map(S->UbahSetKeDes(S),K[2])): S:={L} intersect Q: if S={} then Q:={op(Q),L}: R:=[op(R),A]: end if: end do: return(R): end proc: ReduEkiXc:=proc(H::list,M::list) local r,k,t::integer, A,L,G,K,R,Q,J::list: r:=M[2]: k:=nops(M[1]): t:=nops(H[1]): G:=map(X->AddVekMX(X,M),H):
57
K:=map(X->UbahMtxRC(X),G): J:=map(X->map(S->UbahSetKeDes(S),X[2]),K): L:=map(X->sort(X),J): R:=[op({op(L)})]: Q:=map(X->[k+t,map(n->UbahDesKeSet(n),X)],R): return(Q): end proc:
29. Misalkan himpunan H adalah output Kolek2VekM, setiap pasangan vektor (X,Y,Z) anggota H akan mehasilkan vektor W = X + Y + Z. Agar dua vektor X, Y dan Z bisa ditambahkan langsung ke matriks M, maka U diuji dengan prosedur UjiAdd3VekM berdasarkan output ListKombM.
> UjiAdd3VekM:=proc(d::posint,U::set,L::list) local H,G::list, i,j,g,b,k,n,t::integer: if nops(U)<(d-3) then return(false) end if; H:=L: k:=nops(L[1]): n:=min(d-4,k): for i from 1 to n do G:=H[i]: g:=nops(G): b:=d-3-i: for j from 1 to g do t:=HmDist(U,G[j]): if t<b then return(false); end if: end do: end do: return(true); end proc:
30. Kolek3VekM menentukan himpunan semua pasang (X,Y,Z) dalam yang bisa ditambahkan ke M berdasarkan teorema Gilbert-Vashamov. Prosedur ini menggunakan UjiAdd3VekM.
> Kolek3VekM:=proc(d::posint,H::list,L::list,c::posint) local X,Y,Z,U,V,W,S,R::set, h,i,j::integer, T::symbol, C::list: h:=nops(H): C:=[]: for i from 1 to (h-1) do X:=H[i]: for j from (i+1) to h do Y:=H[j]: Z:=X union Y: if nops(Z)=3 then S:=X intersect Y: V:=Z minus S: U:=AddV(op(1,V),op(2,V)): T:=UjiAdd2VekM(d,U,L): if T=true then R:=op(S): W:=AddV(U,R): T:=UjiAdd3VekM(d,W,L): if T=true then
58
C:=[op(C),{op(V),R}]: if nops(C)=c then C:=[op({op(C)})]: return(C); end if: end if: end if: end if: end do: end do: C:=[op({op(C)})]: return(C): end proc:
31. Kolek3VekMDt menentukan himpunan semua pasang (X,Y,Z) menggunakan data hasil sebelumnya.
> Kolek3VekMDt:=proc(d::posint,H::list,L::list,c::posint,Dat::list) local X,Y,Z,U,V,W,S,R::set, h,i,j,k::integer, T::symbol, C,F::list: C:=Dat[2]: k:=Dat[1]: h:=nops(H): for i from k to (h-1) do X:=H[i]: for j from (i+1) to h do Y:=H[j]: Z:=X union Y: if nops(Z)=3 then S:=X intersect Y: V:=Z minus S: U:=AddV(op(1,V),op(2,V)): T:=UjiAdd2VekM(d,U,L): if T=true then R:=op(S): W:=AddV(U,R): T:=UjiAdd3VekM(d,W,L): if T=true then C:=[op(C),{op(V),R}]: if nops(C)=c then C:=[op({op(C)})]: F:=[i,C]: save F, "D:\\Explor Files\\Coding Theory\\DataOutD13\\DatTemp3.m"; return(C); end if: end if: end if: end if: end do: end do: F:=[op({op(C)})]: save F, "D:\\Explor Files\\Coding Theory\\DataOutD13\\DatTemp3.m"; return(F):
59
end proc: Kolek3VekMDtX:=proc(d::posint,H::list,L::list,c::posint,Dat::list) local X,Y,Z,U,V,W,S,R,C,K::set, h,i,j,k::integer, T::symbol, F::list: C:={op(Dat[2])}: k:=Dat[1]: h:=nops(H): for i from k to (h-1) do X:=H[i]: for j from (i+1) to h do Y:=H[j]: Z:=X union Y: if nops(Z)=3 then K:={Z} intersect C: if K={} then S:=X intersect Y: V:=Z minus S: U:=AddV(op(1,V),op(2,V)): T:=UjiAdd2VekM(d,U,L): if T=true then R:=op(S): W:=AddV(U,R): T:=UjiAdd3VekM(d,W,L): if T=true then C:=C union {Z}: if nops(C)=c then F:=[i,[op(C)]]: save F, "D:\\Explor Files\\Coding Theory\\DataOutD13\\DatTemp3.m"; return([op(C)]); end if: end if: end if: end if: end if: end do: end do: F:=[op(C)]: save F, "D:\\Explor Files\\Coding Theory\\DataOutD13\\DatTemp3.m"; return(F): end proc:
32. Misalkan himpunan H adalah output Kolek3VekM, setiap 4 vektor (X,Y,Z,W) anggota H akan mehasilkan vektor U = W + X + Y + Z. Agar dua vektor X, Y,Z dan W bisa ditambahkan langsung ke matriks M, maka U diuji dengan prosedur UjiAdd4VekM berdasarkan output ListKombM.
> UjiAdd4VekM:=proc(d::posint,U::set,L::list) local H,G::list, i,j,g,b,k,n,t::integer: if nops(U)<(d-4) then return(false) end if; H:=L: k:=nops(L[1]): n:=min(d-5,k): for i from 1 to n do G:=H[i]: g:=nops(G):
60
b:=d-4-i: for j from 1 to g do t:=HmDist(U,G[j]): if t<b then return(false); end if: end do: end do: return(true); end proc:
33. Kolek4VekM menentukan himpunan semua pasang (X,Y,Z,W) dalam yang bisa ditambahkan ke M berdasarkan teorema Gilbert-Vashamov. Prosedur ini menggunakan UjiAdd4VekM.
> Kolek4VekM:=proc(d::posint,H::list,L::list,c::posint) local X,Y,Z,U,U1,U2,V,W,S,A::set, h,i,j::integer, T,T1,T2::symbol, C::list: h:=nops(H): C:=[]: for i from 1 to (h-1) do X:=H[i]: for j from (i+1) to h do Y:=H[j]: Z:=X union Y: if nops(Z)=4 then S:=X intersect Y: V:=Z minus S: A:=AddV(op(1,V),op(2,V)): T:=UjiAdd2VekM(d,A,L): if T=true then U1:=AddV(op(1,S),A): U2:=AddV(op(2,S),A): T1:=UjiAdd3VekM(d,U1,L): T2:=UjiAdd3VekM(d,U2,L): if T1=true and T2=true then W:=AddV(op(2,S),U1): T:=UjiAdd4VekM(d,W,L): if T=true then C:=[op(C),{op(Z)}]: if nops(C)=c then C:=[op({op(C)})]: return(C): end if: end if: end if: end if: end if: end do: end do: C:=[op({op(C)})]: return(C):
61
end proc: 34. Kolek4VekMDt menentukan himpunan semua pasang (X,Y,Z,U) menggunakan data hasil sebelumnya.
> Kolek4VekMDt:=proc(d::posint,H::list,L::list,c::posint,Dat::list) local X,Y,Z,U,U1,U2,V,W,S,A::set, h,i,j,k::integer, T,T1,T2::symbol, C,F::list: C:=Dat[2]: k:=Dat[1]: h:=nops(H): for i from k to (h-1) do X:=H[i]: for j from (i+1) to h do Y:=H[j]: Z:=X union Y: if nops(Z)=4 then S:=X intersect Y: V:=Z minus S: A:=AddV(op(1,V),op(2,V)): T:=UjiAdd2VekM(d,A,L): if T=true then U1:=AddV(op(1,S),A): U2:=AddV(op(2,S),A): T1:=UjiAdd3VekM(d,U1,L): T2:=UjiAdd3VekM(d,U2,L): if T1=true and T2=true then W:=AddV(op(2,S),U1): T:=UjiAdd4VekM(d,W,L): if T=true then C:=[op(C),{op(Z)}]: if nops(C)=c then C:=[op({op(C)})]: F:=[i,C]: save F, "D:\\Explor Files\\Coding Theory\\DataOutD13\\DatTemp4.m"; return(C); end if: end if: end if: end if: end if: end do: end do: F:=[op({op(C)})]: save F, "D:\\Explor Files\\Coding Theory\\DataOutD13\\DatTemp4.m"; return(F): end proc: > Kolek4VekMDtX:=proc(d::posint,H::list,L::list,c::posint,Dat::list) local X,Y,Z,U,U1,U2,V,W,S,A,C,K::set, h,i,j,k::integer, T,T1,T2::symbol, F::list: C:={op(Dat[2])}: k:=Dat[1]: h:=nops(H): for i from k to (h-1) do X:=H[i]:
62
for j from (i+1) to h do Y:=H[j]: Z:=X union Y: if nops(Z)=4 then K:={Z} intersect C: if K={} then S:=X intersect Y: V:=Z minus S: A:=AddV(op(1,V),op(2,V)): T:=UjiAdd2VekM(d,A,L): if T=true then U1:=AddV(op(1,S),A): U2:=AddV(op(2,S),A): T1:=UjiAdd3VekM(d,U1,L): T2:=UjiAdd3VekM(d,U2,L): if T1=true and T2=true then W:=AddV(op(2,S),U1): T:=UjiAdd4VekM(d,W,L): if T=true then C:=C union {Z}: if nops(C)=c then F:=[i,[op(C)]]: save F, "D:\\Explor Files\\Coding Theory\\DataOutD13\\DatTemp4.m"; return([op(C)]); end if: end if: end if: end if: end if: end if: end do: end do: F:=[op(C)]: save F, "D:\\Explor Files\\Coding Theory\\DataOutD13\\DatTemp4.m"; return(F): end proc:
35. Misalkan himpunan H adalah output Kolek4VekM, setiap 5 vektor (X,Y,Z,V,W) anggota H akan mehasilkan vektor U = W+V + X + Y + Z. Agar dua vektor X, Y,Z,V dan W bisa ditambahkan langsung ke matriks M, maka U diuji dengan prosedur UjiAdd5VekM berdasarkan output ListKombM.
> UjiAdd5VekM:=proc(d::posint,U::set,L::list) local H,G::list, i,j,g,b,k,n,t::integer: if nops(U)<(d-5) then return(false) end if; H:=L: k:=nops(L[1]): n:=min(d-6,k): for i from 1 to n do G:=H[i]: g:=nops(G): b:=d-5-i: for j from 1 to g do
63
t:=HmDist(U,G[j]): if t<b then return(false); end if: end do: end do: return(true); end proc:
36. Kolek5VekM menentukan himpunan semua pasang (X,Y,Z,V,W) dalam yang bisa ditambahkan ke M berdasarkan teorema Gilbert-Vashamov. Prosedur ini menggunakan UjiAdd5VekM.
> Kolek5VekM:=proc(d::posint,H::list,L::list,c::posint) local X,Y,Z,U,U1,U2,U3,V,W1,W2,W3,R,S,A::set, h,i,j::integer, T,T1,T2,T3::symbol, C::list: h:=nops(H): C:=[]: for i from 1 to (h-1) do X:=H[i]: for j from (i+1) to h do Y:=H[j]: Z:=X union Y: if nops(Z)=5 then S:=X intersect Y: V:=Z minus S: A:=AddV(op(1,V),op(2,V)): T:=UjiAdd2VekM(d,A,L): if T=true then U1:=AddV(op(1,S),A): U2:=AddV(op(2,S),A): U3:=AddV(op(3,S),A): T1:=UjiAdd3VekM(d,U1,L): T2:=UjiAdd3VekM(d,U2,L): T3:=UjiAdd3VekM(d,U3,L): if T1=true and T2=true and T3=true then W1:=AddV(op(2,S),U1): W2:=AddV(op(3,S),U1): W3:=AddV(op(3,S),U2): T1:=UjiAdd4VekM(d,W1,L): T2:=UjiAdd4VekM(d,W2,L): T3:=UjiAdd4VekM(d,W3,L): if T1=true and T2=true and T3=true then R:=AddV(op(3,S),W1): T:=UjiAdd5VekM(d,R,L): if T=true then C:=[op(C),{op(Z)}]: if nops(C)=c then C:=[op({op(C)})]: return(C): end if: end if:
64
end if: end if: end if: end if: end do: end do: C:=[op({op(C)})]: return(C): end proc:
37. Kolek5VekMDt menentukan himpunan semua pasang (X,Y,Z,U,W) menggunakan data hasil sebelumnya.
> Kolek5VekMDt:=proc(d::posint,H::list,L::list,c::posint,Dat::list) local X,Y,Z,U,U1,U2,U3,V,W1,W2,W3,R,S,A::set, h,i,j,k::integer, T,T1,T2,T3::symbol, C,F::list: C:=Dat[2]: k:=Dat[1]: h:=nops(H): for i from k to (h-1) do X:=H[i]: for j from (i+1) to h do Y:=H[j]: Z:=X union Y: if nops(Z)=5 then S:=X intersect Y: V:=Z minus S: A:=AddV(op(1,V),op(2,V)): T:=UjiAdd2VekM(d,A,L): if T=true then U1:=AddV(op(1,S),A): U2:=AddV(op(2,S),A): U3:=AddV(op(3,S),A): T1:=UjiAdd3VekM(d,U1,L): T2:=UjiAdd3VekM(d,U2,L): T3:=UjiAdd3VekM(d,U3,L): if T1=true and T2=true and T3=true then W1:=AddV(op(2,S),U1): W2:=AddV(op(3,S),U1): W3:=AddV(op(3,S),U2): T1:=UjiAdd4VekM(d,W1,L): T2:=UjiAdd4VekM(d,W2,L): T3:=UjiAdd4VekM(d,W3,L): if T1=true and T2=true and T3=true then R:=AddV(op(3,S),W1): T:=UjiAdd5VekM(d,R,L): if T=true then C:=[op(C),{op(Z)}]: if nops(C)=c then C:=[op({op(C)})]: F:=[i,C]: save F, "D:\\Explor Files\\Coding Theory\\DataOutD13\\DatTemp5.m";
65
return(C); end if: end if: end if: end if: end if: end if: end do: end do: F:=[op({op(C)})]: save F, "D:\\Explor Files\\Coding Theory\\DataOutD13\\DatTemp5.m"; return(F): end proc: > Kolek5VekMDtX:=proc(d::posint,H::list,L::list,c::posint,Dat::list) local X,Y,Z,U,U1,U2,U3,V,W1,W2,W3,R,S,A,C,K::set, h,i,j,k::integer, T,T1,T2,T3::symbol, F::list: C:={op(Dat[2])}: k:=Dat[1]: h:=nops(H): for i from k to (h-1) do X:=H[i]: for j from (i+1) to h do Y:=H[j]: Z:=X union Y: if nops(Z)=5 then K:={Z} intersect C: if K={} then S:=X intersect Y: V:=Z minus S: A:=AddV(op(1,V),op(2,V)): T:=UjiAdd2VekM(d,A,L): if T=true then U1:=AddV(op(1,S),A): U2:=AddV(op(2,S),A): U3:=AddV(op(3,S),A): T1:=UjiAdd3VekM(d,U1,L): T2:=UjiAdd3VekM(d,U2,L): T3:=UjiAdd3VekM(d,U3,L): if T1=true and T2=true and T3=true then W1:=AddV(op(2,S),U1): W2:=AddV(op(3,S),U1): W3:=AddV(op(3,S),U2): T1:=UjiAdd4VekM(d,W1,L): T2:=UjiAdd4VekM(d,W2,L): T3:=UjiAdd4VekM(d,W3,L): if T1=true and T2=true and T3=true then R:=AddV(op(3,S),W1): T:=UjiAdd5VekM(d,R,L): if T=true then C:=C union {Z}: if nops(C)=c then
66
F:=[i,[op(C)]]: save F, "D:\\Explor Files\\Coding Theory\\DataOutD13\\DatTemp5.m"; return([op(C)]); end if: end if: end if: end if: end if: end if: end if: end do: end do: F:=[op(C)]: save F, "D:\\Explor Files\\Coding Theory\\DataOutD13\\DatTemp5.m"; return(F): end proc:
38. Misalkan himpunan H adalah output Kolek(X-1)VekM, setiap X vektor anggota H akan mehasilkan jumlah. Agar X vektor ini bisa ditambahkan langsung ke matriks M, maka diuji dengan prosedur UjiAddXVekM berdasarkan output ListKombM.
> UjiAddXVekM:=proc(x::posint,d::posint,U::set,L::list) local H,G::list, i,j,g,b,k,n,t::integer: if nops(U)<(d-x) then return(false) end if; H:=L: k:=nops(L[1]): n:=min(d-x-1,k): for i from 1 to n do G:=H[i]: g:=nops(G): b:=d-x-i: for j from 1 to g do t:=HmDist(U,G[j]): if t<b then return(false); end if: end do: end do: return(true); end proc:
39. KolekXVekM menentukan himpunan semua X vektor yang bisa ditambahkan ke M berdasarkan teorema Gilbert-Vashamov. Prosedur ini menggunakan UjiAddXVekM.
> KolekXVekM:=proc(x::posint,d::posint,H::list,L::list,c::posint) local X,Y,Z,U,V,S,A,B,R,N,K,W,Q::set, h,i,j,k,l::integer, T,T1::symbol, C::list: h:=nops(H): C:=[]: for i from 1 to (h-1) do X:=H[i]: for j from (i+1) to h do Y:=H[j]: Z:=X union Y: if nops(Z)=x then
67
S:=X intersect Y: V:=Z minus S: A:=AddV(op(1,V),op(2,V)): T:=UjiAdd2VekM(d,A,L): if T=true then for k from 1 to (x-3) do N:=combinat[choose](S,k); T1:=true: for R in N while T1=true do B:=A: for K in R do B:=AddV(B,K): end do: T1:=UjiAddXVekM(2+k,d,B,L): end do: if T1=false then break; end if: end do: if T1=true then W:=op(S minus R): Q:=AddV(B,W): T:=UjiAddXVekM(x,d,Q,L): if T=true then C:=[op(C),{op(Z)}]: if nops(C)=c then C:=[op({op(C)})]: return(C): end if: end if: end if: end if: end if: end do: end do: C:=[op({op(C)})]: return(C): end proc:
40. KolekXVekMDt menentukan himpunan semua pasang (X,Y,Z,U,W) menggunakan data hasil sebelumnya.
> KolekXVekMDt:=proc(x::posint,d::posint,H::list,L::list,c::posint,Dat::list) local X,Y,Z,U,V,S,A,B,R,N,K,W,Q::set, h,i,j,k,l,t::integer, T,T1::symbol, C,F::list: C:=Dat[2]: t:=Dat[1]: h:=nops(H): for i from t to (h-1) do X:=H[i]: for j from (i+1) to h do Y:=H[j]: Z:=X union Y:
68
if nops(Z)=x then S:=X intersect Y: V:=Z minus S: A:=AddV(op(1,V),op(2,V)): T:=UjiAdd2VekM(d,A,L): if T=true then for k from 1 to (x-3) do N:=combinat[choose](S,k); T1:=true: for R in N while T1=true do B:=A: for K in R do B:=AddV(B,K): end do: T1:=UjiAddXVekM(2+k,d,B,L): end do: if T1=false then break; end if: end do: if T1=true then W:=op(S minus R): Q:=AddV(B,W): T:=UjiAddXVekM(x,d,Q,L): if T=true then C:=[op(C),{op(Z)}]: if nops(C)=c then C:=[op({op(C)})]: F:=[i,C]: save F, "D:\\Explor Files\\Coding Theory\\DataOutD13\\DatTemp6.m"; return(C): end if: end if: end if: end if: end if: end do: end do: F:=[op({op(C)})]: save F, "D:\\Explor Files\\Coding Theory\\DataOutD13\\DatTemp6.m"; return(F): end proc:
D. Konstruksi Kode Optimal Kuat. 41. Konstruksi Kode Optimal Kuat [20,2,13], dengan menggunakan satu kali basis matriks sebagai berikut:
> B:=[2,[{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0},{0},{0},{0},{0},{0},{1},{1},{1}, {1},{1},{1}]];
69
> M:=UbahMtxCR(B); > r:=M[2]; d:=13: k:=B[1]; > W:=NonZeroWt(B); > Code13218:=B; > #save Code13218, "D:\\Explor Files\\Coding Theory\\DataOutD13\\CdD13k2r18.m";
42. Konstruksi Kode Optimal Kuat [24,3,13], dengan menggunakan kode [20, 2,13] sebagai dasar adalah sebagai berikut:
> B:=[2,[{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0}, {0},{0},{0},{0},{0},{1},{1},{1},{1},{1},{1}, {},{},{}]]; > M:=UbahMtxCR(B); > r:=M[2]; d:=13: k:=B[1]; > W:=NonZeroWt(B); > t:=min(d-1,k); > L:=ListKombM(M,t): > H:=Kolek1VekM(d,r,r,L): > nops(H); > Q:=ReduEki1(H,M): > nops(Q);
Akhirnya, diperoleh 8 kode Optimal kuat [24,3,13] tidak saling ekivalen. > T:=map(X->AddVekM(X,M),Q): > Code13321:=map(X->UbahMtxRC(X),T): > C3PX:=Code13321[3]; > NonZeroWt(C3PX); > #save Code13321, "D:\\Explor Files\\Coding Theory\\DataOutD13\\CdD13k3r21.m";
43. Konstruksi Kode Optimal Kuat [27,5,13], dengan menggunakan kode [24, 3, 13] sebagai matriks dasar adalah sebagai berikut:
> read "D:\\Explor Files\\Coding Theory\\DataOutD13\\CdD13k3r21.m"; > C3PX:=Code13321[3]; > B:=[C3PX[1],[op(C3PX[2]),{}]]; > M:=UbahMtxCR(B); > r:=M[2]; d:=13: k:=B[1]; > W:=NonZeroWt(B); > t:=min(d-1,k); > L:=ListKombM(M,t): > H:=Kolek1VekM(d,r,r,L): > nops(H); > G:=[1,[]]: > H2:=Kolek2VekMDt(d,H,L,40000,G): > nops(H2); > read "D:\\Explor Files\\Coding Theory\\DataOutD13\\DatTemp2.m"; > G:=F: G[1]; nops(G[2]); > Q:=ReduEkiX(H2,M): > nops(Q);
Akhirnya, paling tidak ada 4 kode Optimal kuat [27,5,13] tidak saling ekivalen. > T:=map(X->AddVekMX(X,M),Q): > Code13522:=map(X->UbahMtxRC(X),T):
70
> C5PX:=Code13522[1]; > NonZeroWt(C5PX); > #save Code13522, "D:\\Explor Files\\Coding Theory\\DataOutD13\\CdD13k5r22.m";
44. Konstruksi Kode Optimal Kuat [29,6,13], dengan menggunakan kode [27, 5, 13] sebagai matriks dasar adalah sebagai berikut:
> read "D:\\Explor Files\\Coding Theory\\DataOutD13\\CdD13k5r22.m"; > C5PX:=Code13522[1]; > B:=[C5PX[1],[op(C5PX[2]),{}]]; > M:=UbahMtxCR(B); > r:=M[2]; d:=13: k:=B[1]; > W:=NonZeroWt(B); > t:=min(d-1,k); > L:=ListKombM(M,t): > H:=Kolek1VekM(d,r,r,L): > nops(H);
Akhirnya, paling tidak ada 1 kode optimal kuat [29,6,13] tidak saling ekivalen. > T:=map(X->AddVekM(X,M),H): > Code13623:=map(X->UbahMtxRC(X),T): > C6PX:=Code13623[1]; > NonZeroWt(C6PX); > #save Code13623, "D:\\Explor Files\\Coding Theory\\DataOutD13\\CdD13k6r23.m";
45. Konstruksi Kode Optimal Kuat [32,8,13], dengan menggunakan kode [29, 6, 13] sebagai matriks dasar adalah sebagai berikut:
> read "D:\\Explor Files\\Coding Theory\\DataOutD13\\CdD13k6r23.m"; > C6PX:=Code13623[1]: > B1:=[C6PX[1],[op(C6PX[2]),{}]]; > i:=1: > B:=DelVekM(i,B1); > M:=UbahMtxCR(B); > r:=M[2]; d:=13: k:=B[1]; > t:=min(d-1,k); > L:=ListKombM(M,t): > H:=Kolek1VekM(d,d,r,L): > nops(H); > DtR24H:=H: > #save DtR24H, "D:\\Explor Files\\Coding Theory\\DataOutD11\\DtR24H.m"; > read "D:\\Explor Files\\Coding Theory\\DataOutD11\\DtR24H.m"; > H:=DtR24H: > G:=[1,[]]: > H2:=Kolek2VekMDt(d,H,L,1000,G): > nops(H2); > read "D:\\Explor Files\\Coding Theory\\DataOutD13\\DatTemp2.m"; > G:=F: G[1]; nops(G[2]); > G:=[1,[]]: > H3:=Kolek3VekMDtX(d,H2,L,1000,G): > nops(H3); > read "D:\\Explor Files\\Coding Theory\\DataOutD13\\DatTemp3.m";
71
> G:=F: G[1]; nops(G[2]); > Q:=ReduEkiX(H3,M): > nops(Q);
Akhirnya, paling tidak ada 192 kode optimal kuat [32,8,13] yang tidak saling ekivalen.
> T:=map(X->AddVekMX(X,M),Q): > Code13824:=map(X->UbahMtxRC(X),T): > C8PX:=Code13824[1]; > NonZeroWt(C8PX); > #save Code13824, "D:\\Explor Files\\Coding Theory\\DataOutD13\\CdD13k8r24.m";
46. Dilanjutkan, Mengkonstruksi kode {34, 9, 13] dengan menggunakan kode [32, 8, 13] sebagai matriks dasar.
> read "D:\\Explor Files\\Coding Theory\\DataOutD13\\CdD13k8r24.m"; > C8PX:=Code13824[1]; > B1:=[C8PX[1],[op(C8PX[2]),{}]]; > NonZeroWt(B1); > i:=1: > B:=DelVekM(i,B1); > M:=UbahMtxCR(B); > r:=M[2]; d:=13: k:=B[1]; > t:=min(d-1,k); > L:=ListKombM(M,t): > H:=Kolek1VekM(d,d,r,L): > nops(H); > G:=[1,[]]: > H2:=Kolek2VekMDt(d,H,L,1000,G): > nops(H2); > read "D:\\Explor Files\\Coding Theory\\DataOutD13\\DatTemp2.m"; > G:=F: G[1]; nops(G[2]);
Akhirnya, diperoleh 2 kode optimal [34,9,13] > T:=map(X->AddVekMX(X,M),H2): > Code13925:=map(X->UbahMtxRC(X),T): > C9PX:=Code13925[1]; > NonZeroWt(C9PX); > #save Code13925, "D:\\Explor Files\\Coding Theory\\DataOutD13\\CdD13k9r25.m";
47. Konstruksi Kode Optimal Kuat [23,2,15], dengan menggunakan satu kali basis matriks sebagai berikut:
> B:=[2,[{0,1},{0,1},{0,1},{0,1},{0,1},{0,1}, {0,1},{0},{0},{0},{0},{0},{0},{0},{1},{1}, {1}, {1},{1}, {1},{1}]]; > M:=UbahMtxCR(B); > r:=M[2]; d:=15: k:=B[1]; > W:=NonZeroWt(B); > Code15221:=B; > #save Code15221, "D:\\Explor Files\\Coding Theory\\DataOutD15\\CdD15k2r21.m";
72
48. Konstruksi Kode Optimal Kuat [27,3,15], dengan menggunakan kode [23, 2, 15] sebagai matriks dasar gagal. Sehingga dikonstruksi matriks B dasar yang baru sebagai berikut:
> B:=[3,[{0,1},{0,2},{1,2},{0,1},{0,2},{1,2}, {0,1},{0,2},{1,2},{0,1},{0,2},{1,2},{0,1,2}, {0},{1},{2},{0,1,2},{0},{1},{2},{0,1,2}, {0},{1},{2}]]; > M:=UbahMtxCR(B); > r:=M[2]; d:=15: k:=B[1]; > W:=NonZeroWt(B); > Code15324:=B; > #save Code15324, "D:\\Explor Files\\Coding Theory\\DataOutD15\\CdD15k3r24.m";
49. Konstruksi Kode Optimal Kuat [31,6,15], dengan menggunakan kode [27, 3, 15] sebagai matriks dasar adalah sebagai berikut:
> read "D:\\Explor Files\\Coding Theory\\DataOutD15\\CdD15k3r24.m"; > C3PX:=Code15324; > B:=[C3PX[1],[op(C3PX[2]),{}]]; > M:=UbahMtxCR(B); > r:=M[2]; d:=15: k:=B[1]; > W:=NonZeroWt(B); > t:=min(d-1,k); > L:=ListKombM(M,t): > G:=[0,[]]: > H:=Kolek1VekMDt(d,r,L,50000,G): > nops(H); > read "D:\\Explor Files\\Coding Theory\\DataOutD15\\DatTemp1.m"; > G:=F: G[1]; nops(G[2]); > H:=F: nops(H); > H:=[op(30000..34992,H)]: > G:=[1,[]]: > H2:=Kolek2VekMDt(d,H,L,200000,G): > nops(H2); > read "D:\\Explor Files\\Coding Theory\\DataOutD15\\DatTemp2.m"; > G:=F: G[1]; nops(G[2]); > Q:=ReduEkiX(H2,M): > nops(Q); > H2:=G[2]: nops(H2); > G:=[1,[]]: > H3:=Kolek3VekMDt(d,H2,L,100,G): > nops(H3); > read "D:\\Explor Files\\Coding Theory\\DataOutD15\\DatTemp3.m"; > G:=F: G[1]; nops(G[2]); > R:=[op(1..10,H3)]: > Q:=ReduEki1(R,M): > nops(Q);
Akhirnya, diperoleh 1 kode Optimal kuat [30,5,15]. > T:=map(X->AddVekMX(X,M),Q): > Code15525:=map(X->UbahMtxRC(X),T): > C6P1:=Code15525[1]; > NonZeroWt(C6P1);
73
> #save Code15525, "D:\\Explor Files\\Coding Theory\\DataOutD15\\CdD15k5r25.m";
50. Konstruksi Kode Optimal Kuat [31,6,15], dengan menggunakan kode [30, 5, 15] sebagai matriks dasar adalah sebagai berikut:
> read "d:\\Bapak's Files\\Coding Theory\\DataOutD15\\CdD15k5r25.m"; > C5P1:=Code15525[1]; > B:=[C5P1[1],[op(C5P1[2]),{},{}]]; > NonZeroWt(B); > M:=UbahMtxCR(B); > r:=M[2]; d:=15: k:=B[1]; > t:=min(d-1,k); > L:=ListKombM(M,t): > G:=[0,[]]: > H:=Kolek1VekMDt(d,r,L,10000,G): > nops(H); > read "D:\\Explor Files\\Coding Theory\\DataOutD15\\DatTemp1.m"; > G:=F: G[1]; nops(G[2]); > H:=F[2]: nops(H); > H:=[op(1..10,H)]:
Diperoleh 9309 kode Optimal optimal [31,6,15]. > T:=map(X->AddVekM(X,M),H): > Code15625:=map(X->UbahMtxRC(X),T): > C6P1:=Code15625[1]; > NonZeroWt(C6P1); > #save Code15625, "D:\\Explor Files\\Coding Theory\\DataOutD15\\CdD15k6r25.m";
51. Konstruksi Kode Optimal Kuat [35,8,15], dengan menggunakan kode [31, 6, 15] sebagai matriks dasar adalah sebagai berikut:
> read "D:\\Explor Files\\Coding Theory\\DataOutD15\\CdD15k6r25.m"; > C6P1:=Code15625[1]; > i:=1: > B:=DelVekM(i,C6P1): > NonZeroWt(B); > M:=UbahMtxCR(B); > r:=M[2]; d:=15: k:=B[1]; > t:=min(d-1,k); > L:=ListKombM(M,t): > G:=[0,[]]: > H:=Kolek1VekMDt(d,r,L,10000,G): > nops(H); > read "D:\\Explor Files\\Coding Theory\\DataOutD15\\DatTemp1.m"; > G:=F: G[1]; nops(G[2]); > H:=F: nops(H); > G:=[1,[]]: > H2:=Kolek2VekMDt(d,H,L,20000,G): > nops(H2); > read "D:\\Explor Files\\Coding Theory\\DataOutD15\\DatTemp2.m"; > G:=F: G[1]; nops(G[2]); > G:=[1,[]]: > H3:=Kolek3VekMDt(d,H2,L,2000,G):
74
> nops(H3); > read "D:\\Explor Files\\Coding Theory\\DataOutD15\\DatTemp3.m"; > G:=F: G[1]; nops(G[2]);
> Q:=ReduEkiX(F[2],M): > nops(Q);
Akhirnya, diperoleh paling sedikitr 689 kode Optimal kuat [35,8,15]. > T:=map(X->AddVekMX(X,M),Q): > Code15827:=map(X->UbahMtxRC(X),T): > C6P1:=Code15827[1]; > NonZeroWt(C6P1); > #save Code15827, "D:\\Explor Files\\Coding Theory\\DataOutD15\\CdD15k8r27.m";
52. Konstruksi Kode Optimal Kuat [37, 9, 15], dengan menggunakan kode [35, 8, 15] sebagai matriks dasar adalah sebagai berikut:
> read "D:\\Explor Files\\Coding Theory\\DataOutD15\\CdD15k8r27.m"; > C8PX:=Code15827[1]; > B1:=[C8PX[1],[op(C8PX[2]),{}]]; > i:=8: > B:=DelVekM(i,B1): > NonZeroWt(B); > M:=UbahMtxCR(B); > r:=M[2]; d:=15: k:=B[1]; > t:=min(d-1,k); > L:=ListKombM(M,t): > G:=[0,[]]: > H:=Kolek1VekMDt(d,r,L,2500,G): > nops(H); > read "D:\\Explor Files\\Coding Theory\\DataOutD15\\DatTemp1.m"; > G:=F: G[1]; nops(G[2]); > H:=F[2]: nops(H); > G:=[1,[]]: > H2:=Kolek2VekMDt(d,H,L,1000,G): > nops(H2); > read "D:\\Explor Files\\Coding Theory\\DataOutD15\\DatTemp2.m"; > G:=F: G[1]; nops(G[2]); > G:=[1,[]]: > H3:=Kolek3VekMDt(d,H2,L,1,G): > nops(H3); > Q:=ReduEkiX(H2,M): > nops(Q);
Diperoleh paling sedikitr 281 kode Optimal kuat [37,9,15]. > T:=map(X->AddVekMX(X,M),Q): > Code15928:=map(X->UbahMtxRC(X),T): > C9PX:=Code15928[1]; > NonZeroWt(C9PX); > #heory\\DataOutD15\\CdD15k9r28.m";
45
Lampiran A. Cuplikan tabel Brouwer yang berkaitan dengan kode untuk d = 13 dan d = 15
n/k 1 2 3 4 5 6 7 8 9 10 11 12 13 14
19 19 12 10 9 8 8 8 7 6 5 4 4 4 3
20 20 13 11 10 9 8 8 8 7 6 5 4 4 4
21 21 14 12 10 10 8 8 8 8 7 6 5 4 4
22 22 14 12 11 10 9 8 8 8 8 7 6 5 4
23 23 15 12 12 11 10 9 8 8 8 8 7 6 5
24 24 16 13 12 12 10 10 8 8 8 8 8 6 6
25 25 16 14 12 12 11 10 9 8 8 8 8 6 6
26 26 17 14 13 12 12 11 10 9 8 8 8 7 6
27 27 18 15 14 13 12 12 10 10 9 8 8 8 7
28 28 18 16 14 14 12 12 11 10 10 8 8 8 8
29 29 19 16 15 14 13 12 12 11 10 9 8 8 8
30 30 20 16 16 15 14 12 12 12 11 10 9 8 8
n/k 1 2 3 4 5 6 7 8 9 10 11 12 13 14
31 31 20 17 16 16 15 13 12 12 12 11 10 9 8
32 32 21 18 16 16 16 14 13 12 12 12 10 10 8-9
33 33 22 18 16 16 16 14 14 12 12 12 11 10 9-10
34 34 22 19 17 16 16 15 14 13 12 12 12 10 10
35 35 23 20 18 16 16 16 15 14 12-13 12 12 11 10
36 36 24 20 18 17 16 16 16 14 13-14 12-13 12 12 11
37 37 24 20 19 18 17 16 16 15 14 13-14 12-13 12 12
38 38 25 21 20 18 18 16 16 16 14 14 13-14 12 12
39 39 26 22 20 19 18 17 16 16 15 14 14 12-13 12
40 40 26 22 20 20 18 18 16 16 16 15 14 13-14 12-13
41 41 27 23 21 20 19 18 17 16 16 16 14-15 14 12-14
42 42 28 24 22 20 20 19 18 17 16 16 15-16 14 13-14
43 43 28 24 22 21 20 20 18 18 16-17 16 16 15 14
44 44 29 24 23 22 21 20 19 18 17-18 16-17 16 16 15