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.

Prolog’un Kafası Nasıl Çalışır?

Prolog, mantıksal programlama ailesindendir. Program; olgular, kurallar ve sorgular üzerine kurulur. Klasik dillerde akış çoğunlukla yukarıdan aşağıya komutlarla ilerlerken, Prolog hedefe ulaşmak için kuralları dener, eşleştirme yapar ve gerekirse geri izleme, yani backtracking, uygular.

Bir Prolog kuralını kabaca şöyle düşünebiliriz:

$H \leftarrow B_1 \land B_2 \land … \land B_n$

Yani “$H$ doğrudur, eğer tüm $B$ koşulları doğruysa.” Prolog’da bu yapı şöyle yazılır:

ata(ahmet, mehmet).
ata(mehmet, zeynep).

dede(X, Y) :- ata(X, Z), ata(Z, Y).

Bu kodda ilk iki satır olgu, son satır ise kuraldır. dede(X, Y) sorgusu için Prolog, uygun Z değerini arar. Değişkenler büyük harfle başlar; X, Y, Z birer bilinmeyendir. Eşleştirme işleminde Prolog bir yerine koyma bulur; buna $\theta = {X/ahmet, Y/zeynep}$ gibi bakabiliriz.

SWI-Prolog Kurulumu

Modern Prolog geliştirme için en pratik seçeneklerden biri SWI-Prolog’dur. Windows, macOS ve Linux üzerinde çalışır, paket yöneticileriyle kolay kurulur ve VS Code ile iyi anlaşır.

# macOS
brew install swi-prolog

# Ubuntu/Debian
sudo apt update
sudo apt install swi-prolog

Bu komutlar SWI-Prolog yorumlayıcısını sisteminize kurar. Kurulumdan sonra terminalde şu komutla kontrol edebilirsiniz:

swipl --version

Eğer sürüm bilgisi görüyorsanız, derleyici/yorumlayıcı yolu başarıyla yapılandırılmış demektir. Windows’ta kurulum sihirbazında Add swipl to PATH benzeri seçeneği işaretlemek önemlidir. İşaretlemediyseniz, SWI-Prolog’un bin klasörünü sistem PATH değişkenine elle eklemeniz gerekir.

VS Code Ortamını Hazırlama

VS Code tarafında amaç; dosya düzenleme, sözdizimi renklendirme ve terminal üzerinden hızlı çalıştırma konforunu sağlamaktır. Eklentiler bölümünden VSC-Prolog veya güncel Prolog sözdizimi desteği sunan bir uzantı kurabilirsiniz.

Proje klasörünüzü açın ve aile.pl adında bir dosya oluşturun:

kadın(ayse).
erkek(ali).
ebeveyn(ayse, ali).

anne(X, Y) :- kadın(X), ebeveyn(X, Y).

Bu dosya basit bir bilgi tabanı kurar. anne(X, Y) kuralı, X kişisinin kadın ve Y kişisinin ebeveyni olup olmadığını kontrol eder.

Terminalde dosyayı şu şekilde yükleyin:

swipl aile.pl

Ardından Prolog etkileşimli kabuğunda sorgu yazabilirsiniz:

?- anne(ayse, ali).
?- anne(Kim, ali).

İlk sorgu doğruysa true. döner. İkinci sorguda Prolog değişkeni doldurmaya çalışır ve Kim = ayse. gibi bir cevap üretir.

İlk Ayar Kontrol Listesi

Kurulumda sorun yaşarsanız şu küçük liste hayat kurtarır:

• swipl --version çalışıyor mu?
• .pl dosyası doğru klasörde mi?
• VS Code terminali aynı proje dizininde mi açıldı?
• Dosyadaki her olgu ve kural nokta ile bitiyor mu?
• Değişkenler büyük harfle, atomlar küçük harfle mi başlıyor?

Prolog öğrenirken en güzel yöntem, küçük bilgi tabanları kurup bol bol sorgu sormaktır. Çünkü Prolog’da program yazmak biraz şehir haritası çizmek gibidir: yolları siz tanımlarsınız, hedefe giden rotayı mantık motoru bulur.

Emirsel dillerde geliştirici genellikle belleğin zaman içindeki durumunu yönetir. Değişkenler atanır, döngüler kurulur, koşullar dallanır. Mantıksal programlamada ise amaç, sonucu hangi adımlarla bulacağını tarif etmekten çok, sonucun hangi mantıksal koşullarda doğru olacağını belirtmektir. Bu yüzden Prolog kodu bazen programdan çok küçük bir bilgi tabanı gibi görünür.

Prolog’un en küçük yapı taşı olgudur. Olgu, dünyaya dair doğru kabul edilen basit bir cümledir. Örneğin aşağıdaki bilgi tabanı aile ilişkilerini tanımlar:

% Olgular: Bunlar doğru kabul edilir.
ebeveyn(ayse, mehmet).
ebeveyn(mehmet, zeynep).
ebeveyn(zeynep, deniz).

% Kural: X, Y'nin atasıdır; eğer X, Y'nin ebeveyniyse.
ata(X, Y) :- ebeveyn(X, Y).

% Özyinelemeli kural: X, Z'nin atasıdır; eğer X, Y'nin ebeveyni
% ve Y de Z'nin atasıysa.
ata(X, Z) :- ebeveyn(X, Y), ata(Y, Z).

Burada ata(X, Y) klasik anlamda bir fonksiyon değildir. Daha çok, doğru olup olmadığı araştırılan bir ilişkidir. Prolog’a ata(ayse, deniz). diye sorduğumuzda motor, olguları ve kuralları kullanarak bir kanıt arar. Bu süreçte iki temel mekanizma devrededir: eşleme ve geri izleme.

Eşleme, Prolog’un iki ifadeyi birbirine uygun hale getirmesidir. Örneğin ebeveyn(ayse, Kim) sorgusunda Kim = mehmet sonucu bulunur. Geri izleme ise bir çözümden sonra başka çözüm var mı diye alternatif yolları denemesidir. Yani Prolog, küçük bir dedektif gibi ipuçlarını takip eder; çıkmaz sokağa girerse geri dönüp başka kapıyı çalar.

Bildirimsel felsefenin güzelliği burada ortaya çıkar. Diyelim ki bir liste içinde eleman aramak istiyoruz. Emirsel bir dilde sayaç açar, listenin sonuna kadar gider, karşılaştırma yaparız. Prolog’da ise ilişkinin tanımını yaparız:

% Eleman, listenin başındaysa üyedir.
uye(X, [X|_]).

% Değilse, listenin kuyruğunda aranır.
uye(X, [_|Kuyruk]) :- uye(X, Kuyruk).

Bu iki satır şunu söyler: Bir şey listenin ilk elemanıysa üyedir; değilse geri kalanında üyeyse yine üyedir. Burada döngü yoktur, sayaç yoktur, indeks yoktur. Yine de Prolog bu tanımı kullanarak hem uye(3, [1,2,3]) sorusuna doğru cevabını verebilir hem de uye(X, [a,b,c]) sorgusuyla olası değerleri tek tek üretebilir.

Elbette Prolog sihirli değnek değildir. Sayısal hesaplama, grafik arayüz, sistem programlama gibi alanlarda emirsel diller daha doğal olabilir. Ancak kural tabanlı sistemler, uzman sistemler, doğal dil işleme, planlama, bulmaca çözme ve sembolik yapay zeka gibi konularda Prolog’un mantıksal modeli çok güçlüdür.

Sonuç olarak Prolog öğrenmek sadece yeni bir dil öğrenmek değildir; programlama hakkında düşünme biçimini genişletmektir. Emirsel paradigmada algoritmayı yürütürüz; mantıksal paradigmada gerçeği tarif ederiz. Birinde bilgisayara yolu çizeriz, diğerinde hedefin tanımını veririz. Ve bazen en zarif program, ne yapılacağını bağıran değil, neyin doğru olduğunu sakin sakin anlatandır.

Birleştirmeyi basit eşitlikten ayırmak önemlidir. Matematikte $2 + 3 = 5$ gibi bir eşitlik doğruluk kontrolüdür. Prolog’da ise X = elma dediğimizde çoğu zaman soru şu değildir: Bunlar zaten eşit mi? Asıl soru şudur: Bunları eşit yapmanın bir yolu var mı? Eğer varsa Prolog değişkenlere uygun değerleri bağlar.

Teorik olarak birleştirme, iki terim $T_1$ ve $T_2$ için bir yer değiştirme kümesi, yani $\sigma$ arar. Bu küme uygulandığında $T_1\sigma = T_2\sigma$ oluyorsa işlem başarılıdır. En iyi sonuç ise MGU, yani most general unifier olarak bilinir. Türkçesiyle en genel birleştirici. Bu, gereksiz kısıtlama koymadan iki ifadeyi eşitleyen en esnek çözümdür.

Prolog terimleri üç ana grupta düşünülebilir: atomlar, değişkenler ve bileşik terimler. Atomlar sabit isimlerdir: ali, kitap, mavi. Değişkenler büyük harfle başlar: X, Kisi, Sonuc. Bileşik terimler ise functor ve argümanlardan oluşur: seviyor(ali, kitap) gibi. Birleştirme bu yapıları katman katman karşılaştırır.

% Basit birleştirme örnekleri
?- X = elma.
% X = elma

?- kisi(ali, Yas) = kisi(ali, 30).
% Yas = 30

?- nokta(X, 5) = nokta(3, Y).
% X = 3, Y = 5

Bu örneklerde Prolog, yapıların adlarına ve argüman sayılarına bakar. nokta(X, 5) ile nokta(3, Y) aynı functor adına ve aynı arity değerine sahiptir. Bu yüzden argümanlar sırayla birleştirilir. Önce X = 3, sonra 5 = Y; sonuçta iki değişken de uygun değerlere bağlanır.

Birleştirmenin en eğlenceli tarafı, sadece tek bir değişkeni değil, tüm yapıyı dönüştürebilmesidir. Mesela aile(anne(X), baba(Y)) gibi iç içe terimler varsa Prolog en dıştan başlayıp içeri doğru ilerler. Her katmanda aynı soru sorulur: Bu iki şeyi aynı yapabilir miyim?

% İç içe yapılarda birleştirme
?- aile(anne(X), baba(veli)) = aile(anne(ayse), baba(Y)).
% X = ayse,
% Y = veli

Burada aile yapısı eşleşir, sonra anne(X) ile anne(ayse) karşılaştırılır. Ardından baba(veli) ile baba(Y) birleştirilir. Sonuç, iki küçük bağlamanın birleşimidir: $\sigma = {X/ayse, Y/veli}$.

Bir noktaya dikkat: Prolog’daki = aritmetik hesap yapmaz, birleştirme yapar. Yani X = 2 + 3 sorgusu X değişkenini 5 değerine değil, 2 + 3 terimine bağlar. Hesaplama için genellikle is kullanılır.

?- X = 2 + 3.
% X = 2+3

?- X is 2 + 3.
% X = 5

Özetle birleştirme, Prolog’un kalbidir. Kuralların çalışması, sorguların cevaplanması, değişkenlerin anlam kazanması hep bu süreçle olur. Eğer Prolog’u bir bulmaca oyunu gibi düşünürsek, unification parçaları masaya dizen, kenarlarını karşılaştıran ve uygun olanları sessizce birbirine kilitleyen mekanizmadır. Onu anladığınızda Prolog artık sihirli değil; mantıklı, sistemli ve oldukça keyifli görünmeye başlar.

Teorik olarak bir sorgu, bir mantıksal ifadenin bilgi tabanından türetilip türetilemeyeceğini sorar. Bunu şöyle yazabiliriz: $KB \models q$. Burada $KB$ bilgi tabanını, $q$ ise sorguyu temsil eder. İfade şu anlama gelir: Bilgi tabanı doğru kabul edildiğinde, sorgu da zorunlu olarak doğru mudur? Eğer sistem bunu kanıtlayabiliyorsa sonuç true, kanıtlayamıyorsa çoğu mantıksal programlama sisteminde false döner.

Basit bir Prolog benzeri örnek üzerinden gidelim:

parent(ayse, mehmet).
parent(mehmet, zeynep).

grandparent(X, Z) :- parent(X, Y), parent(Y, Z).

?- grandparent(ayse, zeynep).

Bu kodda ilk iki satır gerçektir. Üçüncü satır ise bir kuraldır: X, Y’nin ebeveyni ve Y de Z’nin ebeveyni ise X, Z’nin büyükanne veya büyükbabasıdır. Sorgu çalıştırıldığında sistem değişkenleri eşleştirir, yani unification yapar. $X = ayse$, $Y = mehmet$, $Z = zeynep$ değerleriyle kural sağlandığı için cevap true olur.

Sorgu motorunun çalışma mantığı genellikle geriye doğru zincirleme ile açıklanır. Motor, hedef sonucu kanıtlamak için şu soruyu sorar: Bu hedef hangi alt hedeflere bağlı? Sonra alt hedefleri tek tek çözmeye çalışır. Bir bakıma final sorusundan başlayıp ipuçlarını geriye doğru takip eden bir dedektif gibi davranır.

Buradaki önemli ayrım şudur: SQL genellikle var olan satırları filtrelerken, mantıksal sorgular var olmayan ama türetilebilen bilgileri de bulabilir. Örneğin tabloda doğrudan büyükebeveyn bilgisi bulunmayabilir; ama ebeveyn ilişkilerinden bu bilgi hesaplanabilir. Yani sorgu motoru yalnızca arama yapmaz, akıl yürütür.

Küçük bir Python benzeri taslakla bu fikri sezgisel olarak görebiliriz:

facts = {
    ('parent', 'ayse', 'mehmet'),
    ('parent', 'mehmet', 'zeynep')
}

def is_grandparent(x, z):
    for relation, a, y in facts:
        if relation == 'parent' and a == x:
            if ('parent', y, z) in facts:
                return True
    return False

print(is_grandparent('ayse', 'zeynep'))

Bu örnek, kural motorunun yaptığı işi sadeleştirerek gösterir. Gerçekler kümesi içinde uygun ara kişi aranır. Eğer $parent(x, y)$ ve $parent(y, z)$ aynı anda sağlanıyorsa, $grandparent(x, z)$ sonucu true kabul edilir.

Elbette gerçek sistemlerde işler biraz daha karmaşıktır. Değişken bağlama, geri izleme, çakışan kurallar, sonsuz döngüler ve kapalı dünya varsayımı gibi konular devreye girer. Kapalı dünya varsayımı özellikle önemlidir: Sistem bir bilgiyi kanıtlayamıyorsa onu yanlış kabul eder. Bu, günlük hayattaki bilmiyorum ile aynı şey değildir. Mantıksal sistem açısından kanıt yoksa cevap çoğu zaman false olur.

Sonuç olarak sorgular mekanizması, kural ve gerçeklerden oluşan bir bilgi tabanını pasif bir veri yığını olmaktan çıkarır. Ona soru sorabilir, ilişkileri test edebilir ve yeni sonuçları otomatik olarak keşfedebiliriz. İyi tasarlanmış sorgular, yazılımınıza küçük ama çalışkan bir mantık asistanı eklemek gibidir: az konuşur, çok çıkarım yapar.

Bu basitlik aldatıcıdır. Çünkü her piksel için aynı işlem yapılmasına rağmen sonuçlar dramatik biçimde değişir. Bir piksel 10 yinelemede kaçarken komşusu 500 yineleme boyunca dayanabilir. İşte renkleri de genellikle bu kaçış hızına göre veririz.

Aşağıdaki C++ kodu, Mandelbrot kümesini PPM formatında bir görsele yazar. PPM seçmemizin nedeni eğlenceli derecede basit olmasıdır: dosyanın başına birkaç bilgi, ardından RGB değerleri. Yani kütüphane canavarı çağırmadan piksel piksel resim üretebiliriz.

#include <fstream>
#include <complex>

int main() {
    const int width = 900;
    const int height = 600;
    const int maxIter = 300;

    std::ofstream out("mandelbrot.ppm");
    out << "P3\n" << width << " " << height << "\n255\n";

    for (int y = 0; y < height; ++y) {
        for (int x = 0; x < width; ++x) {
            double real = -2.5 + x * (3.5 / width);
            double imag = -1.2 + y * (2.4 / height);

            std::complex<double> c(real, imag);
            std::complex<double> z(0, 0);

            int iter = 0;
            while (std::abs(z) <= 2.0 && iter < maxIter) {
                z = z * z + c;
                ++iter;
            }

            int r = (iter * 9) % 256;
            int g = (iter * 5) % 256;
            int b = (iter * 13) % 256;

            if (iter == maxIter) {
                r = g = b = 0;
            }

            out << r << " " << g << " " << b << " ";
        }
        out << "\n";
    }
}

Kodda real ve imag değişkenleri, ekran koordinatını matematiksel düzleme çevirir. Yani (x, y) pikselini doğrudan çizmek yerine, onu karmaşık sayı düzlemindeki bir noktaya dönüştürürüz. Sonrasında z = z * z + c satırı fraktalın motorudur. Bu satır her piksel için yüzlerce kez çalışır; C++ burada hız avantajını gösterir.

Renk seçimi tamamen deney alanıdır. Yukarıdaki örnekte mod alma ile basit ama canlı bir palet oluşturduk. Daha yumuşak geçişler için logaritmik renklendirme kullanılabilir. Teorik olarak kaçış süresi $n$ ise, renk fonksiyonu $color=f(n)$ gibi düşünülebilir. Fonksiyon ne kadar yaratıcıysa fraktal o kadar “galaksi posteri” havasına bürünür.

Fraktalların büyüsü, deterministik olmalarına rağmen organik görünmeleridir. Aynı formül, aynı başlangıç, aynı sonuç; fakat sonuç, doğadaki kıyı çizgilerini, bulutları ve damar yapılarını hatırlatır. Kaos teorisi burada “rastgelelik” değil, başlangıç koşullarına aşırı duyarlılık demektir.

Bu programı geliştirmek için yakınlaştırma parametreleri ekleyebilir, PNG çıktısı almak için stb_image_write kullanabilir veya çok çekirdekli işlem için pikselleri paralel hesaplatabilirsiniz. Sonuçta C++ ile fraktal üretimi sadece görsel bir oyuncak değildir; matematik, performans ve yaratıcılığın aynı döngüde buluştuğu küçük bir evrendir.

Teorik olarak kaynak koddan çalışmaya giden yol şöyle modellenebilir:

Burada “VM”, sanal makine demektir. Gerçek CPU yerine kendi küçük işlemcimizi C içinde simüle ederiz. Mesela ADD x 3 komutu, bellekteki x değerini alıp üzerine 3 ekleyen bir bytecode talimatına dönüşür.

Önce komut kümemizi tanımlayalım. Bu dilde üç işlem olsun: değişkene değer atama, toplama ve ekrana yazdırma. Matematiksel olarak belleği bir fonksiyon gibi düşünebiliriz: $M(v)$, v değişkeninin değeridir. ADD x 3 çalışınca yeni durum $M’(x)=M(x)+3$ olur.

typedef enum {
    OP_SET,
    OP_ADD,
    OP_PRINT,
    OP_HALT
} OpCode;

typedef struct {
    OpCode op;
    int var;
    int value;
} Instruction;

Bu yapı bizim mini makine dilimizdir. op hangi işlemin yapılacağını söyler, var değişkenin kimliğini, value ise sayısal argümanı taşır. Gerçek makinelerde bunlar baytlara sıkıştırılır; biz okunabilir kalsın diye struct kullandık.

Şimdi basit bir değişken tablosu yazalım. Oyuncak örnekte değişkenleri tek harf kabul etmek işi çok kolaylaştırır: a, b, x gibi. Böylece x - 'a' bize 0-25 arası bir indeks verir.

int var_id(const char *name) {
    if (name[0] >= 'a' && name[0] <= 'z' && name[1] == '\0')
        return name[0] - 'a';
    return -1;
}

Parser tarafında satırı okuyup ilk kelimeye göre karar verebiliriz. Bu, tam teşekküllü bir parser değildir ama sözdizimi analizinin özünü gösterir: beklenen kalıba uyuyor mu?

int compile_line(char *line, Instruction *out) {
    char cmd[16], name[16];
    int value;

    if (sscanf(line, "SET %15s %d", name, &value) == 2) {
        out->op = OP_SET;
        out->var = var_id(name);
        out->value = value;
        return out->var >= 0;
    }

    if (sscanf(line, "ADD %15s %d", name, &value) == 2) {
        out->op = OP_ADD;
        out->var = var_id(name);
        out->value = value;
        return out->var >= 0;
    }

    if (sscanf(line, "PRINT %15s", name) == 1) {
        out->op = OP_PRINT;
        out->var = var_id(name);
        out->value = 0;
        return out->var >= 0;
    }

    return 0;
}

Bu kodun eğlenceli yanı, sscanf ile minik bir dilbilgisi kontrolü yapmasıdır. Daha ciddi bir projede token üretir, ardından recursive descent parser yazardık. Örneğin expr -> term ((+|-) term)* gibi kurallarla matematiksel ifadeleri ayrıştırmak mümkün olurdu.

Son adımda bytecode’u çalıştıran sanal makineyi yazıyoruz:

void run(Instruction *code, int count) {
    int memory[26] = {0};

    for (int ip = 0; ip < count; ip++) {
        Instruction in = code[ip];

        switch (in.op) {
            case OP_SET:
                memory[in.var] = in.value;
                break;
            case OP_ADD:
                memory[in.var] += in.value;
                break;
            case OP_PRINT:
                printf("%d\n", memory[in.var]);
                break;
            case OP_HALT:
                return;
        }
    }
}

Buradaki ip, instruction pointer’dır; yani sıradaki talimatın adresini gösterir. CPU’larda da benzer bir mantık vardır. Program sayacı ilerler, talimat çözülür, işlem yapılır. Bizim VM bunu C döngüsüyle taklit eder.

Örnek program şöyle olabilir:

SET x 10
ADD x 7
PRINT x

Derleme sonucunda yaklaşık olarak şu bytecode dizisi oluşur:

Çıktı doğal olarak 17 olur. Küçük ama güçlü bir fikir yakaladık: sözdizimi sadece metin kontrolü değildir; anlamlı eylemlere açılan kapıdır. Buradan sonra ifadeler, koşullar, döngüler ve hata mesajları ekleyerek mini dilinizi büyütebilirsiniz. Bir noktadan sonra fark edeceksiniz: derleyiciler büyü yapmıyor, sadece çok disiplinli bir çeviri işi gerçekleştiriyor.