Teorik olarak backtracking, derinlik öncelikli arama (DFS) mantığına çok benzer. Fakat klasik DFS sadece graf üzerinde dolaşırken, backtracking genellikle “karar ağacı” üzerinde aday çözümler üretir. Her düğüm bir kısmi çözümü, her kenar ise yeni bir seçimi temsil eder. Eğer dallanma faktörü $b$ ve maksimum derinlik $d$ ise kaba kuvvetle arama maliyeti yaklaşık $O(b^d)$ olabilir. Bu yüzden akıllı kontrol fonksiyonları çok önemlidir.

Basit bir formül gibi düşünürsek algoritmanın davranışı şöyle özetlenebilir: $Çözüm = Seçim + Kısıt\ Kontrolü + Geri\ Alma$. Yani yalnızca denemek değil, denediğini akıllıca geri sarmak önemlidir. Bu yüzden backtracking, “kaba kuvvetin gözlük takmış hali” olarak düşünülebilir.

En meşhur örneklerden biri N-Queens problemidir. Ama daha basit bir örnekle başlayalım: Verilen sayılardan toplamı hedef değere eşit olan bir alt küme bulmak. Aşağıdaki Python kodu, her sayıyı “al” veya “alma” kararlarıyla ilerler; çıkmaza girince önceki adıma döner.

def subset_sum(nums, target):
    result = []

    def backtrack(index, current, total):
        # Hedefe ulaşıldıysa çözümü kaydet
        if total == target:
            result.append(current.copy())
            return

        # Liste bitti veya toplam hedefi geçtiyse bu dalı bırak
        if index == len(nums) or total > target:
            return

        # 1. seçenek: mevcut sayıyı al
        current.append(nums[index])
        backtrack(index + 1, current, total + nums[index])

        # Geri alma: son eklenen sayıyı çıkar
        current.pop()

        # 2. seçenek: mevcut sayıyı alma
        backtrack(index + 1, current, total)

    backtrack(0, [], 0)
    return result

print(subset_sum([2, 3, 5, 7], 10))

Bu kodda current.append(...) bir karar vermektir. current.pop() ise o kararı geri almaktır. Bu ikili, backtracking’in sahnedeki dansıdır: bir adım ileri, gerekirse bir adım geri. Eğer total > target olursa algoritma o yolu sürdürmez; çünkü pozitif sayılarla hedefe geri inme şansı yoktur. İşte bu küçük kontrol ciddi performans kazandırır.

Backtracking ile dinamik programlama sık karıştırılır. İkisi de “zor problemi küçük parçalara bölme” fikrini sever, ama yaklaşımları farklıdır.

Backtracking’in kullanıldığı popüler alanlar arasında Sudoku çözümü, 8 vezir problemi, labirent rotası bulma, şifre kombinasyonu denemeleri, graf renklendirme ve kısıt tatmin problemleri vardır. Mesela Sudoku’da her boş hücreye 1’den 9’a kadar sayı denenir; satır, sütun veya kutu kuralı bozulursa sayı geri alınır. Bilgisayar sabırlı bir bulmaca çözücüye dönüşür.

Elbette backtracking her derde deva değildir. Seçenek sayısı çok büyükse ve iyi budama yoksa algoritma yavaşlayabilir. Bu durumda sezgisel sıralama, erken kontrol, memoization veya problemi matematiksel olarak daraltma gibi teknikler eklenir. Örneğin önce en kısıtlı hücreyi seçmek, Sudoku’da arama ağacını dramatik şekilde küçültebilir.

Sonuç olarak geriye izleme, yazılım dünyasının “denedim, olmadı, akıllıca geri döndüm” stratejisidir. Onu güçlü yapan şey sadece tüm yolları denemesi değil; yanlış yollardan zamanında vazgeçmesidir. Eğer bir problem “bir sürü ihtimal var ama kurallar geçersizleri elememi sağlıyor” diyorsa, backtracking büyük ihtimalle kapıda bekleyen kahramandır.

Bu ayrım özellikle fonksiyonel programlamada çok güçlüdür. Çünkü bir listeyi işlemek için genellikle şu soru sorulur: “Liste boş mu?” Boş değilse, baş elemanı alırız ve geri kalan kuyruk üzerinde aynı işlemi tekrarlarız. Bu yaklaşım, özyineleme yani recursion mantığının da temel taşlarından biridir.

Klasik dizilerle listeler çoğu dilde birbirine benzer görünür, fakat düşünme biçimi farklı olabilir. Özellikle head-tail yaklaşımı, listeyi parçalara ayırarak anlamayı kolaylaştırır.

Python’da köşeli parantezlerle liste oluşturmak oldukça basittir:

sayilar = [4, 7, 11, 18]

head = sayilar[0]
tail = sayilar[1:]

print(head)  # 4
print(tail)  # [7, 11, 18]

Bu kodda sayilar[0] listenin ilk elemanını verir. sayilar[1:] ise bir dilimleme işlemidir ve birinci indeksten sona kadar olan kısmı yeni bir liste olarak döndürür. Yani elimizdeki listeyi “ilk lokma” ve “tabakta kalanlar” diye ayırmış oluruz.

Python’da daha zarif bir ayrıştırma yöntemi de vardır:

meyveler = ['elma', 'armut', 'kiraz', 'muz']

head, *tail = meyveler

print(head)  # elma
print(tail)  # ['armut', 'kiraz', 'muz']

Buradaki *tail ifadesi, geri kalan tüm elemanları toplar. Kodun yaptığı şey şudur: “İlk elemanı head değişkenine koy, kalanları da tail listesi olarak sakla.” Bu, head-tail mantığını doğrudan ifade ettiği için okunması da oldukça rahattır.

Ancak dikkat: boş liste üzerinde head almaya çalışmak hataya yol açar. Çünkü $L = []$ iken $x_1$ diye bir eleman yoktur. Bu yüzden güvenli işlem yapmak için önce listenin boş olup olmadığı kontrol edilmelidir.

def listeyi_yaz(liste):
    if not liste:
        return

    head, *tail = liste
    print('Baş:', head)
    listeyi_yaz(tail)

listeyi_yaz([10, 20, 30])

Bu örnekte fonksiyon önce listenin boş olup olmadığını kontrol eder. Boş değilse baş elemanı yazdırır ve kuyruğu aynı fonksiyona tekrar gönderir. Böylece liste adım adım küçülür. Her adımda problem boyutu $n$ değerinden $n - 1$ değerine iner. Bu da algoritmanın doğal bir sonlanma noktasına sahip olmasını sağlar.

Performans açısından da düşünmek önemlidir. Bir listenin ilk elemanına erişmek çoğu modern dilde $O(1)$ kabul edilir. Fakat liste[1:] gibi kuyruk üretmek bazı dillerde yeni liste oluşturduğu için $O(n)$ maliyetli olabilir. Bu yüzden teoriyi bilmek güzel, ama kullandığın dilin veri yapısı davranışlarını bilmek daha da güzeldir.

Sonuç olarak listeler yalnızca “yan yana yazılmış değerler” değildir. Onlar, veriyi sıraya koymanın, parçalamanın ve anlamlı biçimde işlemenin temel araçlarındandır. Head-tail mantığı ise bu araç kutusundaki İsviçre çakısı gibidir: basit görünür, ama doğru yerde kullanıldığında kodu hem sadeleştirir hem de düşünme biçimini keskinleştirir.

``

Karşılaştırma Operatörü Nedir?

Karşılaştırma operatörleri iki değeri yan yana koyup aralarındaki ilişkiyi test eder. Matematiksel olarak bunu bir önerme gibi düşünebiliriz. Örneğin $x = 10$ ve $y = 7$ ise $x > y$ önermesi doğrudur. Programlama dilinde bu ifade çoğunlukla true sonucunu verir.

Temel mantık şudur:

Yani iki değer girer, mantıksal bir sonuç çıkar. Bu sonuç daha sonra if, while, for, switch veya filtreleme gibi karar mekanizmalarında kullanılır.

Eşitlik ve Denklik Aynı Şey mi?

Burada eğlenceli bir tuzak var: “eşit” olmak ile “aynı türden ve aynı değer” olmak her zaman aynı değildir. Özellikle JavaScript gibi dillerde == değeri karşılaştırırken tür dönüşümü yapabilir. === ise daha disiplinlidir; hem değerin hem de tipin aynı olmasını ister.

Bu yüzden karar mekanizması yazarken “Ben sadece değer mi kontrol ediyorum, yoksa tip de önemli mi?” sorusu kritik hale gelir.

Karar Mekanizmasına Dahil Etmek

Karşılaştırmalar tek başına test yapar; asıl güçleri karar yapılarıyla birleşince ortaya çıkar. Mesela bir kullanıcının sisteme giriş yapıp yapamayacağını düşünelim. Yaşı yeterli mi? Hesabı aktif mi? Deneme hakkı kaldı mı?

const yas = 20;
const hesapAktif = true;
const denemeHakki = 3;

if (yas >= 18 && hesapAktif === true && denemeHakki > 0) {
  console.log('Giriş izni verildi.');
} else {
  console.log('Giriş reddedildi.');
}

Bu kodda üç farklı karşılaştırma vardır. yas >= 18 kullanıcının reşit olup olmadığını kontrol eder. hesapAktif === true hesabın gerçekten aktif olup olmadığını tip güvenli biçimde denetler. denemeHakki > 0 ise kullanıcının hâlâ giriş denemesi yapabileceğini gösterir. && operatörü ise tüm koşulların doğru olmasını ister.

Mantıksal olarak bunu şöyle yazabiliriz:

Eğer bu üç parçadan biri bile false olursa genel karar da false olur.

Karşılaştırmalar Sadece Sayılar İçin Değildir

Karşılaştırma deyince akla hemen sayılar gelse de metinler, tarihler, boole değerler ve nesneler de karşılaştırılabilir. Ancak her veri türünün kuralları farklıdır. Metinlerde alfabetik sıralama, tarihlerde zaman damgası, nesnelerde ise referans karşılaştırması devreye girebilir.

Mini Strateji: Okunabilir Koşullar Yazmak

Karmaşık kararlar yazarken karşılaştırmaları değişkenlere ayırmak kodu daha okunabilir yapar. Aşağıdaki örnek, iş kuralını neredeyse düz Türkçe gibi okutmayı hedefler:

const sepetTutari = 1250;
const uyeMi = true;
const stokVarMi = true;

const indirimHakEder = sepetTutari >= 1000 && uyeMi === true;
const satinAlabilir = indirimHakEder && stokVarMi === true;

console.log(satinAlabilir);

Burada indirimHakEder ve satinAlabilir ara karar değişkenleridir. Böylece tek satırlık dev bir koşul yerine, mantığı parçalara bölen temiz bir yapı elde edilir.

Özetle karşılaştırma operatörleri, programların karar verme kaslarıdır. Doğru kullanıldıklarında kodunuz daha güvenilir, okunabilir ve tahmin edilebilir olur. Yanlış kullanıldıklarında ise “Neden bu kullanıcı içeri girdi?” gibi klasik yazılımcı dedektiflik hikâyeleri başlar.

Özyinelemenin Temel Fikri

Özyineleme, bir fonksiyonun veya kuralın kendi kendini çağırmasıdır. Ancak bu, sonsuza kadar süren sihirli bir ayna koridoru değildir. Sağlıklı bir özyinelemeli yapı iki parçaya dayanır:

Matematiksel olarak bunu şöyle düşünebiliriz: Bir listenin toplamı için $S(n)$, ilk $n$ elemanın toplamı olsun. O zaman:

ve temel durum:

Bu tanımda döngü yoktur ama tekrar vardır. Her çağrı, problemi bir adım küçültür. Liste bittiğinde sonuç geriye doğru taşınır.

Döngü mü, Özyineleme mi?

Geleneksel döngüler kontrolü açıkça yönetir: sayaç artırılır, koşul kontrol edilir, gövde çalıştırılır. Özyineleme ise kontrolü çağrı zincirine bırakır. Bu yüzden özellikle ağaçlar, klasör yapıları, grafik aramaları ve parçala-fethet algoritmalarında çok doğal görünür.

Örneğin bir listedeki sayıların toplamını özyinelemeyle hesaplayalım:

function toplam(liste, index = 0) {
  if (index === liste.length) return 0;
  return liste[index] + toplam(liste, index + 1);
}

const sonuc = toplam([4, 8, 15, 16]);
console.log(sonuc); // 43

Bu kodda index === liste.length temel durumdur. Liste bittiğinde sıfır döner. Aksi halde mevcut eleman alınır ve listenin geri kalanı için aynı fonksiyon tekrar çağrılır. Bir döngü yazmadık ama listeyi baştan sona gezdik.

Çağrı Yığını: Görünmeyen Merdiven

Özyineleme çalışırken her fonksiyon çağrısı bellekte çağrı yığınına eklenir. Bunu bir merdiven gibi düşünebiliriz. Önce aşağı inilir, temel duruma ulaşılır, sonra cevaplar yukarı çıkarken birleşir.

toplam([4, 8, 15], 0) çağrısı kabaca şöyle açılır:

4 + toplam(index 1)
4 + 8 + toplam(index 2)
4 + 8 + 15 + toplam(index 3)
4 + 8 + 15 + 0

Zaman karmaşıklığı her elemanı bir kez ziyaret ettiği için $O(n)$ olur. Ancak bellek tarafında da çağrı yığını kullanılır; bu nedenle ek bellek maliyeti genellikle $O(n)$ kabul edilir. Döngüsel çözümde ise çoğu zaman bellek $O(1)$ olabilir.

Kural Tabanlı Düşünmek

Özyinelemeyi güçlü yapan şey, işlemi emir listesi gibi değil, kural gibi yazmamızdır. Mesela bir listede ilk çift sayıyı bulalım:

function ilkCift(liste, index = 0) {
  if (index >= liste.length) return null;
  if (liste[index] % 2 === 0) return liste[index];
  return ilkCift(liste, index + 1);
}

console.log(ilkCift([3, 7, 10, 12])); // 10

Burada strateji nettir: Eğer liste bittiyse yoktur. Mevcut eleman çiftse cevap odur. Değilse aynı aramayı bir sonraki elemandan başlat. Bu ifade biçimi, özellikle kuralların kendi kendini genişlettiği mantıksal programlama, ayrıştırıcılar ve yapay zeka arama problemlerinde çok okunaklıdır.

Ne Zaman Dikkatli Olmalı?

Özyineleme şık olabilir ama her yere serpilmiş algoritmik pul biber gibi kullanılmamalıdır. Temel durum unutulursa fonksiyon sonsuza kadar kendini çağırır. Çok büyük listelerde çağrı yığını dolabilir. Bazı diller kuyruk özyinelemesini optimize eder, bazıları etmez.

Kuyruk özyinelemesinde son işlem doğrudan özyinelemeli çağrıdır:

function toplamKuyruk(liste, index = 0, acc = 0) {
  if (index === liste.length) return acc;
  return toplamKuyruk(liste, index + 1, acc + liste[index]);
}

Burada acc, yani biriktirici, ara sonucu taşır. Teorik olarak bu yapı daha kolay optimize edilebilir.

Sonuç olarak özyineleme, döngülerin rakibi değil; tekrar eden işlemleri farklı bir soyutlama katmanında ifade etmenin yoludur. Problem doğal olarak alt problemlere ayrılıyorsa, özyineleme kodu hem daha kısa hem daha açıklayıcı hale getirebilir. Yeter ki şu üç soruyu unutmayalım: Nerede duruyorum, problemi nasıl küçültüyorum ve çağrılar bellekte ne kadar yer kaplıyor?

X is 2 + 3.
% X = 5

Burada sağ taraf, yani 2 + 3, önce değerlendirilir. Sonra elde edilen sonuç sol taraftaki değişkene bağlanır. Matematiksel olarak söylemek gerekirse:

$X = 2 + 3 \Rightarrow X = 5$

Ama Prolog’daki = operatörü ile bu aynı şey değildir. = birleştirme, yani unification yapar. Hesaplama yapmaz. Bu ayrım Prolog öğrenirken küçük ama çok kritik bir virajdır.

Bunu bir mutfak benzetmesiyle düşünelim. 2 + 3 bir yemek tarifi olsun. = operatörü tarifi deftere yapıştırır. is ise mutfağa girer, malzemeleri toplar ve tabağa gerçek yemeği koyar. Tarif başka, yemek başka!

Aşağıdaki örnek, sembolik bağlama ile gerçek hesaplama arasındaki farkı gösterir:

sembolik_ornek(X) :-
    X = 10 * 4 + 2.

hesapli_ornek(X) :-
    X is 10 * 4 + 2.

İlk kural çağrıldığında X, 10*4+2 terimine bağlanır. İkinci kuralda ise işlem önceliği uygulanır ve sonuç 42 olur. Yani:

$10 \times 4 + 2 = 42$

is operatörünün önemli bir şartı vardır: Sağ taraftaki ifade hesaplanabilir olmalıdır. Yani içinde değeri bilinmeyen bir değişken varsa Prolog hesaplama yapamaz.

?- X is Y + 1.
% Hata: Y henüz bir sayıya bağlı değil

Doğru kullanımda önce Y bağlanmalıdır:

?- Y = 4, X is Y + 1.
% Y = 4,
% X = 5

Bu davranış, Prolog’un soldan sağa hedef çözme mantığıyla ilgilidir. Prolog önce Y = 4 hedefini çözer, sonra X is Y + 1 ifadesinde artık Y değerini bildiği için hesaplama yapabilir.

Karşılaştırma işlemlerinde de dikkatli olmak gerekir. is, sonuç üretmek içindir; iki aritmetik ifadenin değerini karşılaştırmak için =:= kullanılır.

Küçük bir alan hesabı örneği yazalım:

alan_dikdortgen(Genislik, Yukseklik, Alan) :-
    Alan is Genislik * Yukseklik.

cevre_dikdortgen(Genislik, Yukseklik, Cevre) :-
    Cevre is 2 * (Genislik + Yukseklik).

Bu kurallar şu şekilde çalışır:

?- alan_dikdortgen(5, 8, A).
% A = 40

?- cevre_dikdortgen(5, 8, C).
% C = 26

Teorik olarak burada yaptığımız şey, bir bağıntının içinde deterministik bir hesaplama adımı tanımlamaktır. alan_dikdortgen(5, 8, A) ilişkisi, $A = 5 \times 8$ formülünü kullanır ve A değişkenini kesin sonuç olan 40’a bağlar.

Özetle: Prolog’da matematiksel formül yazmak, onun otomatik hesaplanacağı anlamına gelmez. = sembolik dünyada kalır; is ise hesaplama motorunu çalıştırır. Eğer formülün gerçekten değerlendirilmesini ve sonucun yeni bir değişkene atanmasını istiyorsanız, doğru araç is operatörüdür. Prolog’un büyüsü de burada başlar: Sembollerle düşünür, gerektiğinde sayılarla hesaplar.

Prolog’da çıktı işlemlerini anlamak için önce şu fikri netleştirelim: Prolog programı, doğruluğu araştırılan ilişkilerden oluşur. Ancak bazen yalnızca “sonuç doğru mu?” sorusunu değil, “bu sonucu kullanıcıya nasıl gösteririm?” sorusunu da cevaplamak isteriz. İşte write/1, writeln/1, nl/0 ve format/2 gibi yüklemler bu noktada sahneye çıkar.

Teorik olarak çıktı, bir terimin standart çıktı akışına gönderilmesidir. Bunu küçük bir modelle düşünebiliriz:

$Program \rightarrow Standart\ Çıktı \rightarrow Ekran$

Eğer elimizde X = 42 gibi bir değişken bağlaması varsa, write(X) çağrısı artık ekrana 42 değerini taşır. Prolog’da değişkenler başlangıçta bilinmeyen varlıklardır; değerleri birleştirme, yani unification süreciyle belirlenir. Kısaca:

$X = Değer \Rightarrow write(X) = Değerin\ gösterimi$

Aşağıdaki tablo temel çıktı yüklemlerini karşılaştırır:

En basit örnekle başlayalım:

selamla :-
    write('Merhaba Prolog!'),
    nl,
    write('Bugun cikti islemlerini ogreniyoruz.').

Bu kodda selamla/0 adlı bir yüklem tanımlıyoruz. İlk write/1 metni ekrana basar, nl/0 imleci bir alt satıra indirir, ikinci write/1 ise yeni satırdan devam eder. Burada önemli nokta şudur: write/1 yazdırır ama satır sonunu kendiliğinden eklemez. Bu yüzden nl küçük ama kahraman bir yardımcıdır.

Değişken değerlerini göstermek için de aynı mantık geçerlidir:

not_goster(Isim, Not) :-
    write(Isim),
    write(' isimli ogrencinin notu: '),
    write(Not),
    nl.

not_goster('Ayse', 95). sorgusu çalıştırıldığında ekranda okunabilir bir cümle oluşur. Burada Prolog, Isim ve Not değişkenlerini çağrı sırasında aldığı değerlere bağlar. Böylece çıktı yalnızca sabit metinden değil, çalışma zamanında gelen bilgilerden oluşur.

Daha düzenli ve profesyonel çıktılar için format/2 oldukça kullanışlıdır. format/2, bir şablon ve bu şablona yerleştirilecek değerler listesiyle çalışır:

rapor(Isim, Puan) :-
    format('Ogrenci: ~w~nPuan: ~w~n', [Isim, Puan]).

Buradaki ~w, verilen değeri yazdırır; ~n ise yeni satır anlamına gelir. Yani format/2, write ve nl ikilisini daha kontrollü bir biçimde kullanmamızı sağlar. Özellikle birden fazla değeri aynı çıktıda göstermek istediğimizde kod daha okunur hale gelir.

Bir mini örnekle konuyu bağlayalım:

urun_etiketi(Ad, Fiyat, Stok) :-
    ToplamDeger is Fiyat * Stok,
    format('Urun: ~w~n', [Ad]),
    format('Birim fiyat: ~w TL~n', [Fiyat]),
    format('Stok: ~w adet~n', [Stok]),
    format('Toplam stok degeri: ~w TL~n', [ToplamDeger]).

Bu yüklem, ürün bilgilerini hesaplayıp okunabilir biçimde gösterir. is/2 aritmetik hesaplama yapar; ardından format/2 sonucu ekrana taşır. Matematiksel olarak hesaplanan değer şudur:

$ToplamDeger = Fiyat \times Stok$

Sonuç olarak çıktı işlemleri, programın dış dünyaya açılan penceresidir. write/1 hızlı ve basittir, nl/0 satır düzenini sağlar, writeln/1 pratiklik sunar, format/2 ise ciddi raporların yıldızıdır. Kodunuz doğru çalışabilir; ama iyi biçimlendirilmiş çıktı, kullanıcının “Evet, bu program ne yaptığını biliyor!” demesini sağlar.

Basitçe düşünelim: elimizde bazı bilgiler olsun.

seviyor(ali, kahve).
seviyor(ayse, cay).
seviyor(ali, kitap).

Burada ali, kahve, ayse gibi küçük harfle başlayan ifadeler sabit değerlerdir. Yani sistem için bunlar zaten bilinen şeylerdir. Ama X ya da Ne gibi büyük harfle başlayan semboller değişkendir. Şu sorguyu yazdığımızda:

seviyor(ali, X).

sistem şunu sorar: Ali neyi seviyor? Arka planda tüm seviyor kayıtlarını dolaşır ve birinci konumu ali olanları bulur. Sonuçlar sırayla şöyle eşleşir:

Yani değişken, tek bir sihirli cevap değil, mümkün olan cevaplar kümesidir. Matematiksel olarak bunu şöyle düşünebiliriz: Bir ilişki $R(kisi, nesne)$ olsun. seviyor(ali, X) sorgusu aslında $R(ali, X)$ koşulunu sağlayan tüm $X$ değerlerini arar. Sonuç kümesi ${kahve, kitap}$ olur.

Bu mantık, klasik atamadan önemli ölçüde farklıdır:

Daha eğlenceli bir örnek yapalım. Diyelim ki aile ilişkilerimiz var:

ebeveyn(aylin, zeynep).
ebeveyn(murat, zeynep).
ebeveyn(zeynep, deniz).

anne_baba(X, Y) :- ebeveyn(X, Y).

Burada anne_baba(X, Y) kuralı, X kişisinin Y kişisinin ebeveyni olduğunu söyler. Şu sorgu:

anne_baba(Kim, zeynep).

sisteme şunu dedirtir: Zeynep’in ebeveyni kim? Cevaplar Kim = aylin ve Kim = murat olur. Değişkenin adı Kim seçildiği için insan gözüyle de okunaklıdır; fakat sistem için önemli olan büyük harfle başlamasıdır.

Eşleştirme süreci kabaca şöyle işler:

1. Sorgudaki yapı ile veritabanındaki yapı karşılaştırılır.
2. Sabitler aynı mı diye bakılır.
3. Değişken varsa uygun değerle bağlanır.
4. Çelişki yoksa çözüm üretilir.
5. Başka olasılık varsa geri izleme ile yeni çözüm aranır.

Örneğin:

seviyor(Kisi, kahve).

Bu sorguda Kisi bilinmeyendir. Sistem kahveyi sevenleri arar. Eğer seviyor(ali, kahve) varsa Kisi = ali sonucu çıkar. Burada değişken yalnızca boşluk doldurmaz; sorgunun yönünü de esnetir. Aynı ilişkiyle hem Ali’nin ne sevdiğini hem de kahveyi kimin sevdiğini sorabiliriz.

Bu fikri denklem çözmeye benzetebiliriz. $X + 2 = 5$ denkleminde $X$ bilinmeyendir ve $X = 3$ bulunur. Mantıksal programlamada da seviyor(ali, X) ifadesi, ilişki tablosunda X’i tamamlayacak değerleri arar. Ancak burada tek bir sayı yerine sembolik bilgiler ve birden fazla olası cevap olabilir.

Sonuç olarak büyük harfle başlayan değişkenler, mantıksal programlamanın en güçlü parçalarındandır. Onlar bellekteki sıradan kutular değil, soru işaretleridir. Programcı olarak siz ilişkiyi tanımlarsınız; motor ise bilinmeyenleri uygun değerlerle eşleştirir. Küçük harfli sabitler sahnedeki oyuncularsa, büyük harfli değişkenler dedektif şapkası takıp sahne arkasında kimin kimle eşleştiğini bulan zeki yardımcılarımızdır.

Teorik olarak bir gerçek, çoğu zaman özne-yüklem-nesne üçlüsüyle ifade edilir. Mesela “Pamuk bir kedidir” cümlesi şu şekilde modellenebilir:

$kedi(Pamuk)$

“Nesne A, nesne B ile ilişkilidir” demek için de iki değişkenli yüklemler kullanılır:

$sahibi(Pamuk, Zeynep)$

Burada sahibi ilişkiyi, Pamuk ve Zeynep ise ilişkiye katılan nesneleri temsil eder. Bilgi tabanının gücü, bu küçük ifadelerin net ve tutarlı olmasından gelir. Çünkü mantıksal çıkarımda belirsizlik sevmez; yanlış ya da çelişkili gerçekler, sistemin tuhaf sonuçlar üretmesine neden olabilir.

Basit bir bilgi tabanını kodla hayal edelim. Aşağıdaki Python örneği, gerçekleri üçlü yapılar halinde tutar ve belirli bir ilişkiyi sorgular:

facts = {
    ('Pamuk', 'tür', 'kedi'),
    ('Köpük', 'tür', 'köpek'),
    ('Ankara', 'başkentidir', 'Türkiye'),
    ('Pamuk', 'renk', 'beyaz')
}

def sorgula(özne=None, ilişki=None, nesne=None):
    sonuçlar = []
    for fact in facts:
        o, r, n = fact
        if özne is not None and o != özne:
            continue
        if ilişki is not None and r != ilişki:
            continue
        if nesne is not None and n != nesne:
            continue
        sonuçlar.append(fact)
    return sonuçlar

print(sorgula(özne='Pamuk'))

Bu kodun amacı, bilgi tabanındaki gerçekleri filtrelemektir. Pamuk hakkında ne biliyoruz diye sorduğumuzda sistem, onun türünü ve rengini döndürür. Henüz akıl yürütme yoktur; yalnızca kayıtlı gerçekler aranır. Ancak bu temel yapı üzerine kurallar eklendiğinde işler eğlenceli hale gelir.

Bir kuralı matematiksel olarak şöyle düşünebiliriz:

$kedi(x) \Rightarrow memeli(x)$

Bu ifade “Eğer x bir kediyse, x memelidir” der. Pamuk için $kedi(Pamuk)$ gerçeği varsa, sistem $memeli(Pamuk)$ sonucunu çıkarabilir. Buna çıkarım denir. Bilgi tabanı + kurallar = basit bir mantık motoru.

Gerçeklerin kesin ve değişmez olması özellikle önemlidir. “Bugün hava sıcak” gibi bağlama bağlı ifadeler bilgi tabanına eklenebilir ama zaman, yer veya koşul belirtilmezse sorun çıkarır. Daha sağlam bir ifade şöyle olur: sıcaklık(İstanbul, 2026-07-11, 30). Böylece gerçek, ölçülebilir ve izlenebilir hale gelir.

Bilgi tabanları; uzman sistemlerde hastalık teşhisi, oyun yapay zekâsında karakter davranışları, semantik aramada kavram ilişkileri ve robotikte çevre modelleme için kullanılır. Bir robotun “masa mutfaktadır” ve “bardak masanın üzerindedir” bilgilerini bilmesi, bardağı bulmak için mutfağa gitmesini sağlayabilir.

Özetle gerçekler, yazılıma dünyanın LEGO parçalarını verir. Kurallar ise bu parçaları nasıl birleştireceğini anlatır. İyi tasarlanmış bir bilgi tabanı, sadece bilgi depolayan değil, bildiklerinden sonuç çıkarabilen sistemlerin temelidir. Yani küçük gerçekler, doğru kurallarla birleştiğinde oldukça zeki davranışların kapısını aralar.

Neden 3D Görselleştirme?

Klasik 2D grafikler çoğu durumda harikadır; çizgi grafikler trendleri, sütun grafikler karşılaştırmaları, pasta grafikler oranları gösterir. Fakat veri çok boyutlu hale geldiğinde işler zorlaşır. Örneğin bir müşteri veri setinde yaş, gelir, satın alma sıklığı, lokasyon ve sosyal ağ bağlantıları aynı anda incelenmek istenebilir. 3D sahnede üç değişken eksenlere yerleştirilirken renk, boyut, parlaklık veya animasyonla ek değişkenler temsil edilebilir.

Basit bir eşleme şöyle düşünülebilir: veri noktası $d = (a, b, c)$ ise sahnedeki konumu $p = (x, y, z)$ olur. Ölçekleme genellikle şu mantıkla yapılır: $x = (a - minA) / (maxA - minA)$. Böylece farklı aralıklardaki değerler aynı görsel evrene taşınır.

Temel Teori: Sahne, Kamera, Nesne

Web tarafında 3D denince akla genellikle WebGL gelir. WebGL güçlüdür ama ham haliyle biraz dikenlidir. Bu yüzden Three.js gibi kütüphaneler kullanılır. Three.js dünyasında üç temel karakter vardır: sahne, kamera ve renderer. Sahne evrenin kendisidir, kamera kullanıcının gözüdür, renderer ise bu evreni ekrana çizen motordur.

Veri noktalarını kürelerle göstermek yaygın bir yaklaşımdır. Ağ görselleştirmelerinde düğümler küre, bağlantılar çizgi olarak modellenir. Bir düğümün büyüklüğü derece merkeziliğini gösterebilir. Örneğin bir ağda düğümün bağlantı sayısı $k$ ise yarıçap $r = sqrt(k)$ seçilebilir. Bu sayede çok bağlantılı düğümler görünür olur ama sahneyi ezmez.

Mini Three.js Örneği

Aşağıdaki kod, veri noktalarını üç boyutlu uzayda küçük küreler olarak yerleştirir. Mantık şudur: her veri satırı bir konuma çevrilir, ardından sahneye mesh olarak eklenir.

import * as THREE from 'three';

const scene = new THREE.Scene();
const camera = new THREE.PerspectiveCamera(60, window.innerWidth / window.innerHeight, 0.1, 1000);
const renderer = new THREE.WebGLRenderer({ antialias: true });
renderer.setSize(window.innerWidth, window.innerHeight);
document.body.appendChild(renderer.domElement);

camera.position.z = 80;

const data = [
  { x: 10, y: 25, z: 5, value: 12 },
  { x: -20, y: 5, z: 15, value: 30 },
  { x: 5, y: -15, z: -10, value: 18 }
];

const material = new THREE.MeshStandardMaterial({ color: 0x44aaff });
const light = new THREE.PointLight(0xffffff, 1);
light.position.set(40, 40, 40);
scene.add(light);

data.forEach(item => {
  const radius = Math.sqrt(item.value);
  const geometry = new THREE.SphereGeometry(radius, 24, 24);
  const point = new THREE.Mesh(geometry, material);
  point.position.set(item.x, item.y, item.z);
  scene.add(point);
});

function animate() {
  requestAnimationFrame(animate);
  scene.rotation.y += 0.003;
  renderer.render(scene, camera);
}

animate();

Bu örnekte value alanı kürenin boyutunu belirler. Büyük değerler büyük kürelere dönüşür. Gerçek projelerde renk skalası, tooltip, tıklama olayları ve filtreleme eklenerek grafik çok daha bilgilendirici hale gelir.

Etkileşim Neden Kritik?

3D görselleştirmede kullanıcı kontrolü yoksa sahne kısa sürede süslü bir akvaryuma dönüşebilir. OrbitControls ile döndürme, raycasting ile tıklanan nesneyi bulma ve filtre panelleri ile veri katmanlarını açıp kapatma önemlidir.

Performans ve Tasarım İpuçları

Her veri noktası ayrı mesh olursa binlerce nesnede performans düşebilir. Bu durumda InstancedMesh, BufferGeometry veya veri ön işleme teknikleri kullanılmalıdır. Ayrıca 3D her zaman daha iyi değildir. Eğer iki değişken anlatılacaksa 2D daha temizdir. 3D, gerçekten üçüncü boyut anlam katıyorsa kullanılmalıdır.

Sonuç olarak JavaScript, tarayıcıyı küçük bir veri laboratuvarına dönüştürür. Three.js, D3.js ve WebGL ekosistemiyle karmaşık istatistikleri yalnızca göstermek değil, yaşatmak mümkündür. Doğru ölçekleme, bilinçli görsel kodlama ve güçlü etkileşim birleştiğinde kullanıcılar veriye bakmaz; veriyle sohbet eder.

$A \rightarrow B$

Burada $A$ koşul, $B$ ise sonuçtur. Anlamı şudur: Eğer $A$ doğruysa, $B$ de doğru kabul edilebilir. Daha karmaşık kurallarda birden fazla koşul bulunabilir:

Bu ifade, hem $A$ hem de $B$ doğruysa $C$ sonucuna ulaşılır demektir. Buradaki $\land$ sembolü mantıksal ve anlamına gelir.

Mantıksal çıkarımın iki popüler yöntemi vardır: ileri zincirleme ve geri zincirleme. İleri zincirleme, eldeki gerçeklerden başlayıp mümkün olan tüm sonuçları üretmeye çalışır. Geri zincirleme ise hedef bir sonucun doğru olup olmadığını kanıtlamaya çalışır. Dedektif benzetmesiyle düşünürsek, ileri zincirleme olay yerindeki tüm ipuçlarını inceleyip sonuçlara gider; geri zincirleme ise önce şüpheliyi seçer, sonra kanıt arar.

Basit bir ileri zincirleme motoru Python ile şöyle modellenebilir:

facts = {'hava_yagmurlu', 'bulutlu'}

rules = [
    ({'hava_yagmurlu'}, 'zemin_islak'),
    ({'zemin_islak'}, 'kayma_riski'),
    ({'bulutlu', 'hava_yagmurlu'}, 'semsiye_gerekli')
]

def forward_chain(facts, rules):
    changed = True
    while changed:
        changed = False
        for conditions, result in rules:
            if conditions.issubset(facts) and result not in facts:
                facts.add(result)
                changed = True
                print('Yeni sonuc:', result)
    return facts

final_facts = forward_chain(facts, rules)
print(final_facts)

Bu kodda facts başlangıçta doğru kabul edilen bilgileri tutar. rules listesinde ise her kuralın koşulları ve sonucu vardır. issubset kontrolü, kuralın tüm koşullarının mevcut gerçekler içinde olup olmadığını denetler. Eğer koşullar sağlanıyorsa sonuç bilgi tabanına eklenir. Döngü, artık yeni bilgi üretilemeyene kadar devam eder.

Bu yaklaşımın en güzel tarafı açıklanabilir olmasıdır. Bir sinir ağı bazen neden öyle karar verdiğini anlatmakta zorlanırken, kural tabanlı sistemlerde karar zinciri izlenebilir: Yağmur yağdı, bu yüzden zemin ıslandı; zemin ıslandı, bu yüzden kayma riski oluştu. Gayet dedikoducu ama şeffaf bir sistem!

Elbette kuralların da sınırları vardır. Çok fazla kural olduğunda çakışmalar ortaya çıkabilir. Örneğin bir kural klima aç derken başka bir kural pencere aç diyebilir. Bu durumda önceliklendirme, ağırlıklandırma veya çatışma çözme stratejileri gerekir. Bazen kurallara güven derecesi de eklenir. Mesela $P(yağmur)=0.8$ gibi olasılıksal ifadelerle sistem daha esnek hale getirilebilir.

Sonuç olarak kurallar ve mantıksal çıkarım, yapay zekanın en anlaşılır yapı taşlarından biridir. Veriyi ezberlemek yerine, bilgiden bilgi üretmeyi sağlar. Küçük bir eğer-öyleyse cümlesi, doğru bağlandığında koca bir karar mekanizmasına dönüşebilir. Yazılım dünyasında bu yapı; uzman sistemlerden oyun yapay zekasına, iş kurallarından otomasyon senaryolarına kadar birçok yerde sessizce çalışır.