``

Caesar şifresi: Alfabeyi biraz kaydıralım

Adını Roma lideri Julius Caesar’dan alan bu yöntemin askerî yazışmalarda kullanıldığı anlatılır. Her harf, alfabede sabit miktarda ileri kaydırılır. Harfleri $0$ ile $25$ arasında numaralandırırsak şifreleme işlemi şöyle gösterilir:

Şifreyi çözmek için kaydırma geri alınır:

Örneğin $k=3$ olduğunda ABC, DEF olur. Fikir zarif olsa da yalnızca 26 olası anahtar vardır. Saldırgan bütün kaydırmaları deneyerek anlamlı sonucu birkaç saniyede bulabilir. Buna kaba kuvvet saldırısı denir. Uzun metinlerde en sık görülen harfi dildeki yaygın harflerle karşılaştıran frekans analizi de kullanılabilir.

def caesar(metin, kaydirma):
    sonuc = ""
    for karakter in metin.upper():
        if "A" <= karakter <= "Z":
            kod = (ord(karakter) - ord("A") + kaydirma) % 26
            sonuc += chr(kod + ord("A"))
        else:
            sonuc += karakter
    return sonuc

print(caesar("KRIPTOGRAFI", 3))

Bu kod, yalnızca Latin alfabesindeki harfleri kaydırır; boşluk ve noktalama işaretlerini korur. Negatif kaydırma verilerek şifre çözme işlemi de yapılabilir.

Polybius karesi: Harfler koordinata dönüşüyor

MÖ 2. yüzyılda yaşamış Yunan tarihçi Polybius, karakterleri bir tablo üzerindeki koordinatlarla temsil etti. Klasik $5 \times 5$ karede I ve J aynı hücreyi paylaşır. Örneğin A 11, B 12, F ise 21 olarak yazılır.

Bu yaklaşımın önemli özelliği, harfleri sayısal çiftlere dönüştürmesidir. Böylece mesajlar meşale, ses veya işaret kombinasyonlarıyla iletilebilir. Ancak standart kare gizli değilse saldırgan koordinatları doğrudan geri çevirebilir. Karışık anahtarlı bir alfabe kullanılsa bile tek bir harf daima aynı çifte dönüştüğü için frekans analizi hâlâ etkilidir.

Vigenère: Tek kaydırma yetmezse

1. yüzyılda Blaise de Vigenère ile özdeşleşen bu yöntem, tekrar eden bir anahtar kelime kullanarak her karaktere farklı Caesar kaydırması uygular. Matematiksel olarak:

ANAHTAR gibi bir anahtar, mesaj uzunluğunca tekrarlanır. Böylece aynı düz metin harfi farklı konumlarda farklı şifreli harflere dönüşebilir. Bu nedenle Vigenère uzun süre çözülemez şifre olarak ün kazandı.

def vigenere_sifrele(metin, anahtar):
    metin = metin.upper()
    anahtar = anahtar.upper()
    sonuc, sira = "", 0

    for harf in metin:
        if harf.isalpha() and "A" <= harf <= "Z":
            kaydirma = ord(anahtar[sira % len(anahtar)]) - ord("A")
            sonuc += chr((ord(harf) - ord("A") + kaydirma) % 26 + ord("A"))
            sira += 1
        else:
            sonuc += harf
    return sonuc

Şifrenin zayıf noktası anahtarın tekrarlanmasıdır. Kasiski incelemesi, şifreli metindeki yinelenen diziler arasındaki uzaklıkları ölçerek muhtemel anahtar uzunluğunu bulur. Friedman testi ise harflerin çakışma olasılığından yararlanır. Uzunluk belirlendikten sonra metin sütunlara ayrılır ve her sütun ayrı bir Caesar şifresi gibi frekans analiziyle çözülür.

Hızlı karşılaştırma

Bu üç yöntem bize önemli bir ders verir: Bir algoritmanın karmaşık görünmesi güvenli olduğu anlamına gelmez. Küçük anahtar uzayı, tekrar eden desenler ve dilin istatistiksel yapısı saldırgana ipucu verir. Yine de bu klasikler, modern kriptografideki saldırı modelini anlamak ve kendi şifre analiz araçlarımızı geliştirmek için vazgeçilmez başlangıç noktalarıdır.

``

Bölünebilmek ne demektir?

Bir $N$ tam sayısı, $d$ sayısına bölündüğünde kalan sıfırsa $d$ ile tam bölünür. Modüler aritmetik dilinde bunu şöyle yazarız:

Örneğin $42 ≡ 0 \pmod 7$ olduğundan 42, 7’ye tam bölünür. Bir sayının ondalık gösterimi ise basamak değerleri kullanılarak açılabilir:

Bölünebilme kuralları, buradaki $10$, $100$ ve diğer kuvvetlerin ilgili bölen karşısındaki kalanlarını kullanır. Yani mesele rakamları rastgele toplamak değil, onluk sistemin davranışını değerlendirmektir.

Yaygın kurallar ve nedenleri

Neden rakamları topluyoruz?

$5832$ sayısını ele alalım. Çünkü $10 ≡ 1 \pmod 3$ olduğundan, 10’un bütün pozitif kuvvetleri de 3’e göre 1 kalanını verir:

Dolayısıyla sayı 3’e bölünür. Aynı mantık 9 için de geçerlidir. Bu nedenle rakamlar toplamı yöntemi yalnızca pratik bir numara değil, basamak açılımının doğrudan sonucudur.

11 kuralındaki işaret değiştirme

$10 ≡ -1 \pmod {11}$ olduğu için kuvvetler sırayla $1, -1, 1, -1$ biçiminde ilerler. Örneğin 2728 için dönüşümlü toplamı hesaplayalım:

Sonuç 11’in katı olduğu için 2728 de 11’e tam bölünür. Bir bakıma rakamlar matematiksel bir tahterevalliye oturur; denge 11’in katında kurulursa test başarıyla tamamlanır.

Peki ya 7?

7 kuralı biraz daha afacan görünür: Son rakamın iki katını, kalan sayıdan çıkarın. Elde edilen sonuç 7’nin katıysa başlangıçtaki sayı da 7’nin katıdır. Örneğin 203 için:

14, 7’ye bölündüğünden 203 de bölünür. Bu işlem gerekirse sonuç küçülene kadar tekrarlanabilir.

Kuralları kodlamak

Aşağıdaki Python fonksiyonu, seçilen bölen için anlaşılır kontroller uygular. Böylece kuralların bir algoritmaya nasıl dönüştüğünü görebiliriz:

def bolunur_mu(sayi, bolen):
    rakamlar = [int(rakam) for rakam in str(abs(sayi))]

    if bolen in (3, 9):
        return sum(rakamlar) % bolen == 0
    if bolen == 4:
        return abs(sayi) % 100 % 4 == 0
    if bolen == 8:
        return abs(sayi) % 1000 % 8 == 0
    if bolen == 11:
        fark = sum(rakamlar[::2]) - sum(rakamlar[1::2])
        return fark % 11 == 0

    return sayi % bolen == 0

print(bolunur_mu(2728, 11))  # True

Kod, 3 ve 9 için rakamları toplar; 4 ve 8 için yalnızca gerekli son basamakları inceler. Genel durumda ise doğrudan kalan operatörünü kullanır.

Bölünebilme kuralları, zihinden hesaplamayı hızlandırmanın ötesinde modüler aritmetiği somutlaştırır. Kuralları ezberlemek işe yarar; fakat neden çalıştıklarını bilmek, yeni bölenler için kendi yöntemlerinizi geliştirmenizi sağlar.

Catalan sayısının matematiksel tanımı

Sıfırıncı Catalan sayısı $C_0=1$ kabul edilir. Genel formül şöyledir:

Buradaki merkezi binom katsayısı, $2n$ konum içinden $n$ tanesini seçer. Ancak seçilen her dizilim geçerli değildir. Örneğin açılan parantez sayısının hiçbir noktada kapanan parantez sayısından az olmaması gerekir. Formüldeki $n+1$ bölümü, bu geçersiz düzenlemeleri ayıklayan kombinatorik düzeltmedir.

Catalan sayıları özyinelemeli olarak da hesaplanabilir:

Bu bağıntının arkasındaki fikir bölüp birleştirmedir. Bir yapı kökünden iki parçaya ayrılıyorsa sol tarafta $i$, sağ tarafta $n-i$ eleman bulunabilir. Olasılıkların çarpılması ve bütün bölünmelerin toplanması Catalan sonucunu verir.

Dengeli parantezler neden Catalan sayısıdır?

$n$ çift açma ve kapama parantezi içeren bir dizide toplam $2n$ karakter vardır. Geçerli bir dizilim iki kurala uyar:

1. Toplam açma ve kapama parantezi sayıları eşittir.
2. Soldan sağa ilerlerken kapanan parantez sayısı, açılanlardan fazla olamaz.

Örneğin (()()) geçerliyken ())(() geçersizdir. İkinci dizi toplamda eşit sayıda parantez içerse bile üçüncü karakterde henüz açılmamış bir parantezi kapatmaya çalışır. Matematik bile “Önce aç, sonra kapat!” der.

İkili ağaçlarla bağlantısı

$n$ düğümlü farklı ikili ağaç biçimlerinin sayısı da $C_n$ değeridir. Kök düğümü seçtikten sonra kalan düğümler sol ve sağ alt ağaçlar arasında dağıtılır. Sol alt ağaçta $i$ düğüm varsa sağ tarafta $n-1-i$ düğüm bulunur.

Aynı sayıların ortaya çıkmasının nedeni, bu problemlerin yüzeyde farklı olsa da aynı özyinelemeli bölünme yapısını taşımasıdır.

Python ile hesaplama

Aşağıdaki dinamik programlama yaklaşımı, özyinelemeli bağıntıyı kullanır. dp[k], $k$ boyutundaki yapıların sayısını saklar:

def catalan(n):
    dp = [0] * (n + 1)
    dp[0] = 1

    for boyut in range(1, n + 1):
        for sol in range(boyut):
            sag = boyut - 1 - sol
            dp[boyut] += dp[sol] * dp[sag]

    return dp[n]

print([catalan(i) for i in range(8)])
# [1, 1, 2, 5, 14, 42, 132, 429]

Algoritmanın zaman karmaşıklığı $O(n^2)$, alan karmaşıklığı ise $O(n)$ olur. Yalnızca tek bir $C_n$ değeri gerekiyorsa faktöriyel formülü daha hızlı olabilir; dinamik programlama ise dizinin tüm ara terimlerini üretmek ve mantığı görmek için daha öğreticidir.

Catalan sayıları, farklı problemlerin ortak matematiksel iskeletini fark etmenin harika bir örneğidir. Bir soruda dengeli parantez, ikili ağaç, köşegeni aşmayan yol veya çokgen üçgenleme görürseniz, sahne arkasında bir Catalan sayısının kostümünü giymekte olabileceğini unutmayın.

``

Temel fikir: Aynı sayı, farklı saatler

Modüler aritmetiği farklı büyüklüklerde çalışan saatlere benzetebiliriz. Örneğin

ifadesi, $x$ sayısının 3’e bölündüğünde 2 kalanını verdiğini söyler. Benzer biçimde şu sistemi ele alalım:

Burada aynı $x$, üç farklı modüler saatte belirli konumlara gelmektedir. Modüller olan 3, 5 ve 7 ikişer ikişer aralarında asaldır. Yani her farklı çift için $\gcd(m_i,m_j)=1$ koşulu sağlanır.

Çinlilerin Kalan Teoremi şunu garanti eder: Modüller ikişer ikişer aralarında asalsa sistemin, modüllerin çarpımına göre tek bir çözüm sınıfı vardır.

Başka bir deyişle çözüm $M$ aralığında benzersizdir; fakat tam sayılarda sonsuz kez tekrar eder.

Çözüm nasıl inşa edilir?

Her denklem için toplam çarpımdan ilgili modülü çıkaran bir parça oluşturulur:

Ardından $M_i$ sayısının $m_i$ modülündeki çarpımsal tersi bulunur. Bu ters $y_i$ ile gösterilirse

olmalıdır. Son çözüm şu formülle birleştirilir:

Örneğimizde $M=105$ olur. Parçalar sırasıyla 35, 21 ve 15’tir. Bunların ilgili modüllerdeki tersleri 2, 1 ve 1 olarak bulunur. Dolayısıyla

elde edilir. $233$ sayısının 105’e göre kalanı 23 olduğundan en küçük pozitif çözüm $x=23$’tür. Gerçekten de 23; 3’e bölününce 2, 5’e bölününce 3 ve 7’ye bölününce 2 kalanını verir.

Python ile genel çözüm

Aşağıdaki fonksiyon, modüllerin bağımsızlığını kontrol eder ve yapıcı formülü uygular. pow(Mi, -1, mi) ifadesi Python’da modüler tersi hesaplar.

from math import gcd, prod

def crt(kalanlar, moduller):
    # Modüllerin ikişer ikişer aralarında asal olduğunu doğrula.
    for i in range(len(moduller)):
        for j in range(i + 1, len(moduller)):
            if gcd(moduller[i], moduller[j]) != 1:
                raise ValueError('Modüller aralarında asal değil')

    M = prod(moduller)
    toplam = 0

    for ai, mi in zip(kalanlar, moduller):
        Mi = M // mi
        ters = pow(Mi, -1, mi)
        toplam += ai * Mi * ters

    return toplam % M, M

cozum, periyot = crt([2, 3, 2], [3, 5, 7])
print(cozum, periyot)  # 23 105

Fonksiyon (23, 105) döndürür. Bu sonuç yalnızca 23’ü değil, $x=23+105k$ biçimindeki bütün çözümleri temsil eder.

Modüller aralarında asal değilse

Teoremin klasik biçimi doğrudan uygulanamaz; ancak sistem mutlaka çözümsüz değildir. İki denklem için kalanların $\gcd(m_1,m_2)$ modülünde uyumlu olması gerekir. Örneğin $x\equiv1\pmod4$ ve $x\equiv3\pmod6$ sistemi uyumludur; fakat $x\equiv1\pmod4$ ve $x\equiv2\pmod6$ değildir. Kısacası CRT, farklı modüler dünyaların aynı sayıda buluşabilmesi için güçlü ve zarif bir köprü kurar.

Bir davette herkes şapkasını vestiyere bırakıyor ve çıkışta şapkalar rastgele dağıtılıyor. Acaba hiç kimsenin kendi şapkasını almadığı kaç farklı dağıtım vardır? Kombinatorikte derangement, Türkçede düzensizleştirme olarak bilinen problem tam olarak bunu sorar. İlk bakışta yalnızca permütasyon üretip kontrol etmek yeterli görünse de teorik yaklaşım çok daha hızlı ve öğreticidir.

``

Problemin matematiksel tanımı

$n$ farklı elemanın bir permütasyonunu düşünelim. Bir eleman başlangıçtaki konumunda kalıyorsa buna sabit nokta denir. Derangement, sabit noktası bulunmayan permütasyondur.

Derangement sayısı genellikle $!n$, $D_n$ veya $d(n)$ ile gösterilir:

Küçük değerler problemi somutlaştırır:

$D_0=1$ tanımı ilk anda garip gelebilir. Ancak boş kümeyi düzenlemenin tek bir yolu vardır ve ortada kendi yerinde kalan eleman bulunmaz. Bu kabul, formüllerin düzgün çalışmasını sağlar.

Dahil etme–hariç tutma ilkesi

Toplam $n!$ permütasyon vardır. $A_i$, $i$ numaralı elemanın kendi yerinde kaldığı permütasyonlar kümesi olsun. İstenen sonuç, hiçbir $A_i$ kümesine girmeyen permütasyonların sayısıdır.

Bir elemanı sabitlersek kalanlar $(n-1)!$ şekilde, iki elemanı sabitlersek $(n-2)!$ şekilde dizilir. Dahil etme–hariç tutma ilkesi uygulandığında:

$\binom{n}{k}(n-k)!=\frac{n!}{k!}$ olduğundan daha kısa formül şöyledir:

Bu toplam, $e^{-1}$ sayısının Taylor açılımını andırır. Dolayısıyla:

Hatta tam sayı sonucu en yakın tam sayıya yuvarlayarak bulabiliriz:

Bunun ilginç sonucu şudur: $n$ büyüdükçe rastgele bir permütasyonda hiç sabit nokta bulunmama olasılığı yaklaşık $1/e$, yani yüzde $36{,}79$ olur.

Daha kullanışlı bağıntı

Derangement sayıları aşağıdaki yinelemeli bağıntıyla da hesaplanabilir:

İlk eleman başka bir konuma gönderilir. O konumdaki eleman ya ilk elemanın yerine gelir ya da üçüncü bir konuma gider. Bu iki durum sırasıyla daha küçük derangement problemlerine dönüşür.

Python ile hesaplama

Aşağıdaki fonksiyon bağıntıyı kullanır. Yalnızca son iki değeri sakladığı için ek diziye ihtiyaç duymaz:

def derangement(n):
    if n < 0:
        raise ValueError("n negatif olamaz")
    if n == 0:
        return 1
    if n == 1:
        return 0

    onceki_iki, onceki = 1, 0  # D0 ve D1

    for i in range(2, n + 1):
        simdiki = (i - 1) * (onceki + onceki_iki)
        onceki_iki, onceki = onceki, simdiki

    return onceki

for n in range(1, 9):
    print(n, derangement(n))

Program sırasıyla 0, 1, 2, 9, 44, 265, 1854, 14833 değerlerini üretir. Python tam sayıları otomatik büyüttüğü için büyük sonuçlarda taşma yaşanmaz.

Derangement; görev atama, gizli hediye çekilişi, test sorularını karıştırma ve kimsenin önceki eşleşmesini almaması gereken planlama problemlerinde kullanılır. Kısacası matematiğin düzen kurmak için bazen herkesi özellikle yanlış yere koyduğu eğlenceli örneklerden biridir.

``

İlkenin matematiksel temeli

Elimizde $n$ adet yuva ve bu yuvalara dağıtılan $n+1$ adet güvercin olsun. Her yuvada en fazla bir güvercin bulunduğunu varsayarsak yerleştirilebilecek toplam güvercin sayısı en fazla $n$ olur. Oysa elimizde $n+1$ güvercin vardır. Varsayımımız çelişkiye ulaştığı için en az bir yuvada iki veya daha fazla güvercin bulunmalıdır.

İlkenin genelleştirilmiş biçimi daha kullanışlıdır: $N$ nesne $k$ kutuya dağıtılırsa kutulardan en az biri en az

nesne içerir. Buradaki $ceil(x)$, sonucu yukarıdaki en yakın tam sayıya yuvarlar. Örneğin 100 dosya 9 sunucuya dağıtılırsa en az bir sunucuda en az $ceil(100/9)=12$ dosya bulunur.

Doğum günü örneği

Bir okulda 367 öğrenci olduğunu düşünelim. Yılın 366 gün sürebileceğini hesaba katsak bile en az iki öğrencinin doğum günü aynıdır. Öğrenciler güvercin, takvim günleri ise yuva rolündedir.

Daha güçlü bir soru soralım: 100 öğrenciden kaçının aynı ayda doğmuş olması garanti edilir? Aylar 12 yuva olduğuna göre:

Dolayısıyla hangi aylarda doğduklarını bilmeden, en az 9 öğrencinin aynı doğum ayını paylaştığını söyleyebiliriz. İlkenin büyüsü burada ortaya çıkar: Dağılımı hesaplamaz, kaçınılmaz sonucu yakalarız.

Sayı teorisinden şaşırtıcı bir kanıt

Herhangi $n+1$ tam sayı seçelim. Bu sayıları $n$ ile böldüğümüzde kalanlar yalnızca

olabilir. Yani $n$ farklı kalan yuvası vardır. Ancak $n+1$ sayı bulunduğu için iki sayı aynı kalanı verir. Bu sayılara $a$ ve $b$ dersek:

Buradan $a-b$ farkının $n$ ile tam bölündüğü sonucu çıkar. Sayıların değerlerini hiç bilmeden, aralarında $n$’nin katı olan bir fark bulunacağını kanıtladık.

Bilgisayar bilimindeki karşılığı

Hash tablolarında çok sayıda anahtar, sınırlı sayıdaki indekse eşlenir. Anahtar sayısı indeks sayısından fazlaysa çakışma kaçınılmazdır. İyi bir hash fonksiyonu çakışmayı yok etmez; dengeli dağıtmaya çalışır.

def pigeonhole_groups(values, bucket_count):
    # Sayıları kalanlarına göre sınıflandırır.
    buckets = [[] for _ in range(bucket_count)]

    for value in values:
        index = value % bucket_count
        buckets[index].append(value)

    return max(buckets, key=len)

numbers = [14, 27, 35, 42, 58, 63]
print(pigeonhole_groups(numbers, 5))

Kod, sayıları beş kalan sınıfına yerleştirir ve en kalabalık sınıfı döndürür. Altı sayı beş sınıfa dağıtıldığı için sınıflardan birinde en az iki sayı bulunacağı daha program çalışmadan garantidir.

Kanıtlarda nasıl fark edilir?

Bir problemde “en az iki tanesi”, “mutlaka aynı”, “garanti edilen minimum” veya “kaçınılmaz çakışma” ifadeleri geçiyorsa güvercin yuvası ilkesini düşünmek yararlıdır. Asıl ustalık, güvercinleri ve yuvaları doğru seçmektir. Bazen yuvalar aylar, bazen kalan sınıfları, bazen de geometrik bölgelerdir.

Bu ilke bize önemli bir matematiksel alışkanlık kazandırır: Her şeyi tek tek bulmak zorunda değiliz. Kapasite ile nesne sayısını karşılaştırmak, karmaşık görünen bir varlık kanıtını birkaç satırlık kaçınılmazlık argümanına dönüştürebilir.

``

Önce matematik: Kaç sonuç bekliyoruz?

$n$ elemanlı bir kümenin $k$ elemanlı alt kümelerinin sayısı binom katsayısıyla hesaplanır:

Örneğin $A={a,b,c,d}$ ve $k=2$ için toplam sonuç sayısı

olur. Üretilecek alt kümeler şunlardır: ${a,b}$, ${a,c}$, ${a,d}$, ${b,c}$, ${b,d}$ ve ${c,d}$.

Bir algoritmanın doğru olduğunu sınarken bu formül iyi bir kontrol mekanizmasıdır. Algoritma tam olarak ${n \choose k}$ sonuç vermeli ve hiçbir sonucu iki kez üretmemelidir.

1. Özyinelemeli geri izleme

En anlaşılır yaklaşım, her adımda bir elemanı seçip seçmemeye karar vermektir. Ancak yalnızca seçme dalını açıkça dolaşarak gereksiz adımları azaltabiliriz.

def kombinasyonlar(elemanlar, k):
    sonuc = []

    def ara(baslangic, secilenler):
        # İstenen büyüklüğe ulaştığımızda kopyayı kaydet.
        if len(secilenler) == k:
            sonuc.append(secilenler.copy())
            return

        gereken = k - len(secilenler)
        son_indeks = len(elemanlar) - gereken

        for i in range(baslangic, son_indeks + 1):
            secilenler.append(elemanlar[i])
            ara(i + 1, secilenler)
            secilenler.pop()  # Geri dön ve başka adayı dene.

    ara(0, [])
    return sonuc

print(kombinasyonlar(["a", "b", "c", "d"], 2))

baslangic değeri, daha önce kullanılan elemanlara geri dönülmesini engeller. Böylece hem tekrar oluşmaz hem de kombinasyonlar sözlük sırasına benzer bir düzende üretilir. son_indeks hesabı ise geride yeterli eleman kalmadığı bilinen dalları budar.

2. İndeksleri sözlük sırasıyla ilerletmek

Bir kombinasyonu elemanların kendisi yerine indeks dizisiyle temsil edebiliriz. Örneğin [0, 1, 3], kümenin birinci, ikinci ve dördüncü elemanlarını seçer. Her turda sağdan başlayarak artırılabilecek ilk indeks bulunur.

def sirali_k_alt_kumeler(veri, k):
    n = len(veri)
    if k < 0 or k > n:
        return

    indeksler = list(range(k))

    while True:
        yield [veri[i] for i in indeksler]

        i = k - 1
        while i >= 0 and indeksler[i] == i + n - k:
            i -= 1

        if i < 0:
            return

        indeksler[i] += 1
        for j in range(i + 1, k):
            indeksler[j] = indeksler[j - 1] + 1

Bu sürüm yield kullandığı için tüm sonuçları bellekte tutmaz. Büyük veri kümelerinde yalnızca sıradaki kombinasyona ihtiyaç duyulduğunda oldukça kullanışlıdır.

3. Bit maskesi yaklaşımı

Her elemanı bir bit ile temsil edebiliriz: 1 seçildiğini, 0 seçilmediğini gösterir. Örneğin 10110 maskesi üç eleman seçer. Dolayısıyla yalnızca içinde tam $k$ tane 1 bulunan maskeler kabul edilir.

def bitmask_kombinasyonlari(veri, k):
    n = len(veri)
    for maske in range(1 << n):
        if maske.bit_count() == k:
            yield [veri[i] for i in range(n) if maske & (1 << i)]

Kod son derece kısa olsa da $0$ ile $2^n-1$ arasındaki bütün maskeleri inceler. Bu nedenle özellikle $k$, $n$ değerine göre küçükken çok sayıda gereksiz maske kontrol edilir.

Yöntemlerin karşılaştırması

Pratikte genel amaçlı kullanım için indeks ilerletme yöntemi iyi bir dengedir. Seçimlere özel kurallar eklenecekse geri izleme daha esnektir. Bit maskesi ise küçük kümelerde, bit düzeyindeki temsiller zaten problemin parçasıysa parlamaya başlar. Hangi yolu seçerseniz seçin, sonuç sayısını ${n \choose k}$ ile doğrulamak algoritmik pusulanız olacaktır.

Problemi matematiksel olarak tanımlayalım

Kod uzunluğu $n$, kullanılabilecek renk sayısı ise $k$ olsun. Renk tekrarına izin verildiğinde toplam olası kod sayısı:

Örneğin klasik bir oyunda $n=4$ ve $k=6$ ise:

Bu sayı bilgisayar için oldukça küçüktür. Dolayısıyla bütün kodları üretip her ipucundan sonra uyumsuz olanları silmek mümkündür. Algoritmanın temel fikri şöyledir:

1. Bütün olası kodları oluştur.
2. Bir tahmin seç.
3. Tahmine verilen geri bildirimi al.
4. Aynı geri bildirimi üretmeyecek adayları ele.
5. Tek aday kalana veya kod bulunana kadar tekrarla.

Geri bildirim nasıl hesaplanır?

Mastermind değerlendirmesinde iki değer bulunur:

Önce tam eşleşmeleri saymak önemlidir. Ardından bu konumlar değerlendirme dışı bırakılarak kalan renklerin ortak miktarı hesaplanır. Aksi hâlde tekrarlanan renkler iki kez sayılabilir; algoritmik muz kabuğu tam olarak burada duruyor!

from collections import Counter
from itertools import product

def puanla(gizli, tahmin):
    tam = sum(a == b for a, b in zip(gizli, tahmin))

    kalan_gizli = [a for a, b in zip(gizli, tahmin) if a != b]
    kalan_tahmin = [b for a, b in zip(gizli, tahmin) if a != b]

    cg = Counter(kalan_gizli)
    ct = Counter(kalan_tahmin)
    yanlis_yer = sum((cg & ct).values())
    return tam, yanlis_yer

Bu fonksiyon, iki kod arasındaki ilişkiyi (tam, yanlış_yer) biçiminde döndürür. Counter kesişimi, her rengin yalnızca iki tarafta bulunan en küçük adedi kadar sayılmasını sağlar.

Adayları filtreleyen çözücü

Her turda yalnızca alınan ipucuyla uyumlu kodları tutabiliriz:

def tum_kodlar(renkler, uzunluk):
    return list(product(renkler, repeat=uzunluk))

def adaylari_filtrele(adaylar, tahmin, cevap):
    return [kod for kod in adaylar if puanla(kod, tahmin) == cevap]

renkler = range(6)
adaylar = tum_kodlar(renkler, 4)

tahmin = (0, 0, 1, 1)
cevap = (1, 1)  # Oyundan veya kullanıcıdan alınır
adaylar = adaylari_filtrele(adaylar, tahmin, cevap)

print("Kalan aday:", len(adaylar))

Filtreleme neden doğrudur? Gerçek gizli kod, yapılan tahmin karşısında verilen cevabı üretmek zorundadır. Bir aday farklı puan üretiyorsa onun gizli kod olması mantıksal olarak imkânsızdır.

Tahmin seçme stratejileri

Minimax yaklaşımı, her olası tahminin adayları hangi cevap gruplarına böleceğini inceler. En büyük grubun boyutu $G(t)$ olsun. Seçilecek tahmin:

Böylece algoritma, rakibin verebileceği en az yardımcı cevapta bile mümkün olduğunca az aday bırakmaya çalışır. Bu, “Umarım şansım yaver gider” yerine “En kötü ihtimale hazırım” demektir.

def minimax_tahmin(adaylar):
    en_iyi, en_kotu_boyut = None, float("inf")

    for tahmin in adaylar:
        gruplar = {}
        for gizli in adaylar:
            sonuc = puanla(gizli, tahmin)
            gruplar[sonuc] = gruplar.get(sonuc, 0) + 1

        en_buyuk_grup = max(gruplar.values())
        if en_buyuk_grup < en_kotu_boyut:
            en_iyi = tahmin
            en_kotu_boyut = en_buyuk_grup

    return en_iyi

Bu sürüm öğretici ve orta ölçekli oyunlar için yeterlidir. Daha büyük problemlerde önbellekleme, örnekleme veya bilgi entropisi kullanılabilir. Entropi yaklaşımı, beklenen bilgi kazancını yükseltmeye çalışır:

Sonuç olarak Mastermind çözücüsü; kombinatorik arama, kısıt yayılımı ve karar teorisini tek projede buluşturur. Aynı yaklaşım parola benzeri bulmacalara, test optimizasyonuna ve hata teşhisine de uyarlanabilir. Renkli pimlerle başlayan macera, küçük ama oldukça şık bir yapay zekâ uygulamasına dönüşür.

Mersenne sayısı nedir?

Bir Mersenne sayısı, pozitif bir $p$ tam sayısı için şu biçimde tanımlanır:

Örneğin $p=5$ seçilirse $M_5=2^5-1=31$ elde edilir ve 31 asaldır. Ancak formüle uyan her sayı asal değildir. $p=11$ için sonuç $2047$ olur; kulağa iddialı gelse de $2047=23 \times 89$ olduğundan bileşiktir.

Mersenne sayısının asal olabilmesi için $p$ değerinin asal olması zorunludur. Çünkü $p=ab$ biçiminde bileşikse:

Bu çarpanlara ayırma, $M_p$ sayısının da bileşik olduğunu gösterir. Fakat dikkat: $p$ değerinin asal olması yeterli değil, yalnızca gerekli bir koşuldur.

Neden asallık testlerinde özeller?

Genel amaçlı asallık testleri her tam sayıyla ilgilenmek zorundadır. Mersenne sayılarıysa ikilik sistemde yalnızca birlerden oluşur. Örneğin $31$, ikilik sistemde 11111 biçimindedir. Bu düzenli yapı, modüler işlemlerin daha verimli uygulanmasını sağlar.

En önemli avantaj, Lucas–Lehmer testi adlı deterministik algoritmadır. $p>2$ asal olmak üzere önce $s_0=4$ alınır ve şu yineleme $p-2$ kez çalıştırılır:

Son değer sıfırsa $M_p$ asaldır; değilse bileşiktir. Olasılıksal testlerin aksine sonuç “muhtemelen asal” değil, kesindir.

Python ile Lucas–Lehmer testi

Aşağıdaki fonksiyon, verilen asal üs için Mersenne adayını oluşturur ve yinelemeyi gerçekleştirir:

def lucas_lehmer(p):
    """2^p - 1 sayısının Mersenne asalı olup olmadığını test eder."""
    if p == 2:
        return True

    mersenne = (1 << p) - 1
    s = 4

    for _ in range(p - 2):
        s = (s * s - 2) % mersenne

    return s == 0

for p in [2, 3, 5, 7, 11, 13, 17]:
    print(p, lucas_lehmer(p))

Buradaki 1 << p işlemi, ikilik düzende 1 sayısını $p$ basamak sola kaydırarak $2^p$ üretir. Her adımda mod alınması da ara değerlerin gereksiz biçimde büyümesini engeller. Yine de milyonlarca basamaklı adaylarda hızlı büyük tam sayı çarpımı ve dikkatli bellek yönetimi gerekir.

Dev asallar neden aranıyor?

Mersenne asallarının doğrudan günlük şifrelemede kullanılması şart değildir. Asıl değerleri; hızlı aritmetik algoritmalarını sınamak, donanım hatalarını yakalamak ve sayı teorisini ilerletmektir. Ayrıca her Mersenne asalı, Öklid–Euler teoremi sayesinde bir çift mükemmel sayı üretir:

Bu arayışın en ünlü aktörlerinden biri GIMPS projesidir. Dünyanın dört bir yanındaki gönüllü bilgisayarlar aday üsleri paylaşarak test eder. Böylece tek bir makinenin yıllar sürecek işi, dev bir dijital define avına dönüşür. Kısacık $2^p-1$ formülü, matematiğin en büyük sayısal keşiflerinden bazılarına açılan şaşırtıcı derecede güçlü bir kapıdır.

Günlük matematikte sayılar büyüdükçe hesaplar zorlaşır; kriptografide ise sayılar yalnızca büyümez, adeta gökdelen olur. Binlerce bitlik anahtarlarla çalışırken sıradan üs alma yöntemleri bilgisayarı terletebilir. Modüler aritmetik ve hızlı üs alma, bu devasa işlemleri yönetilebilir parçalara ayırarak RSA ve Diffie–Hellman gibi sistemlerin çalışmasını sağlayan temel araçlardır.

``

Modüler aritmetik: Sayıların saat düzeni

Modüler aritmetiği anlamanın en kolay yolu bir saat düşünmektir. Saat 10 iken beş saat ilerlerseniz 15 değil, 3 sonucuna ulaşırsınız. Çünkü saat üzerindeki değerler 12’ye göre döngüseldir:

Genel olarak iki sayı, bir $m$ modülüne bölündüklerinde aynı kalanı veriyorsa eşdeğerdir:

Bu yaklaşımın önemli avantajı, ara sonuçların sürekli küçültülebilmesidir. Örneğin çarpma için şu özellik geçerlidir:

Dolayısıyla dev sayıları sonuna kadar taşımak yerine her adımda mod alabiliriz.

Neden doğrudan üs almıyoruz?

$7^{13} \bmod 11$ gibi küçük bir işlem doğrudan hesaplanabilir. Ancak kriptografide üsler yüzlerce veya binlerce bitten oluşabilir. Önce $a^n$ değerini üretip sonra mod almak, bellekte gereksiz büyüklükte bir sayı oluşturur.

Ayrıca üssü kadar çarpma yapan basit yöntem $O(n)$ zaman karmaşıklığına sahiptir. Hızlı üs alma, üssün ikili gösteriminden yararlanarak bu maliyeti $O(\log n)$ seviyesine indirir. Aradaki fark, bisikletle kıtalar arası yolculuk yapmak ile hızlı trene binmek gibidir.

Hızlı üs alma nasıl çalışır?

Temel fikir, üssü sürekli ikiye bölmek ve tabanı karelemektir. Örneğin:

Çünkü $13$ sayısının ikili gösterimi $1101_2$ biçimindedir. İkili gösterimdeki her 1, sonuca hangi kuvvetin katılacağını belirtir. Her aşamada mod alındığı için ara değerler kontrol altında kalır.

def moduler_us(taban, us, modul):
    sonuc = 1
    taban %= modul

    while us > 0:
        # Üs tekse mevcut tabanı sonuca dahil et.
        if us % 2 == 1:
            sonuc = (sonuc * taban) % modul

        # Sonraki ikili basamak için tabanı karele.
        taban = (taban * taban) % modul
        us //= 2

    return sonuc

print(moduler_us(7, 13, 11))  # 2

Bu fonksiyon yalnızca birkaç çarpma yapar. Python aynı işlemi yerleşik pow(7, 13, 11) çağrısıyla da gerçekleştirebilir.

Kriptografideki rolü

RSA’da şifreleme kabaca şu denklemle ifade edilir:

Burada $m$ mesajı, $e$ açık üssü, $n$ modülü ve $c$ şifreli metni temsil eder. Şifre çözme ise özel üs $d$ kullanılarak yapılır:

Güvenlik, modüler üs alma işleminin kolay; uygun gizli bilgiler olmadan işlemi tersine çevirmenin ise zor olmasına dayanır. Diffie–Hellman anahtar değişimi ve ElGamal gibi yöntemler de benzer matematiksel yapılardan yararlanır.

Uygulamadaki önemli ayrıntılar

Matematiksel doğruluk tek başına güvenlik anlamına gelmez. Koşullu dallanmalar ve işlem süreleri, yan kanal saldırılarına bilgi sızdırabilir. Gerçek kriptografik uygulamalarda sabit zamanlı algoritmalar, güvenilir kütüphaneler ve yeterince büyük parametreler kullanılmalıdır. Kendi algoritmanızı yazmak öğrenmek için harikadır; üretimde kullanmak ise paraşütü evde dikmeye biraz benzer.

Özetle modüler aritmetik sayıları döngüsel bir alana hapseder, hızlı üs alma da bu alandaki dev kuvvetleri az sayıda adımla hesaplar. İkisi birleştiğinde modern açık anahtarlı kriptografinin sessiz ama son derece güçlü matematik motoru ortaya çıkar.