konstruksi kode linear biner optimal kuat berjarak minimum 13 … · kode linear biner, terutama...

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.


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.


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 .


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 = .


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).


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.


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 .


Definisi Dimensi

Dimensi dari sebuah ruang vektor didefinisikan sebagai banyaknya

vektor-vektor dari basis di .


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.


Definisi Rank

Dimensi ruang baris atau ruang kolom dari matriks A dinamakan rank dari

matriks A.


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.


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.


Definisi Komplemen Ortogonal

Misalkan adalah ruang vektor dan S . Komplemen ortogonal (disebut

juga dual) dari S, notasi , didefinisikan sebagai

= .


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



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



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



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.


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

=


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


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

=


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

=



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


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

=


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


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.


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

=


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


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

=



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

=



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


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

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.

http://codetables.de/�

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";


> 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";


> 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";


> 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";


> 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";


> 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

konstruksi kode linear biner optimal kuat berjarak minimum 13 … · kode linear biner, terutama...

Documents