Açık Doğrulama

Bir önceki ders üç değerlendirme türünü karşılaştırdı ve hepsinde aynı kalıntıyı buldu: kara kutuda 62, gri kutuda 36, beyaz kutuda 19 aday gerçek bir açığa karşılık gelmiyordu. O sayılar tek bir gürültü çarpanıyla üretilmişti. Gerçekte hangi adayın eleneceğini çarpan değil, adayın hangi belirtiye dayandığı belirler.

Bu ders bir aday listesini doğrulama kurallarından geçirir ve her kuralın kaç adayı çıkardığını, kaç gerçek bulguyu birlikte götürdüğünü sayar. Yanlış pozitif (false positive), gerçek bir açığa karşılık gelmeyen adaydır; doğrulama, adayı kanıta çeviren adımdır. Doğrulama adımı kâğıt üzerinde kalmaz, hedefe gerçekten dokunur: yazılı yetki ve tanımlı kapsam olmadan bu adımı atmak hem yasadışı hem meslek dışıdır.

• TS13. Aday listesi 240 ham kalemdir ve önceki iki dersin 20 kapsam içi kalemi üzerinde durur. Liste de açık kümesi de kurgudur; hiçbir hedefe işlem yapılmaz.
• TS14. Bir yer, bir kalemin bir zincir adımıdır. 20 kalem ve 4 adım 80 yer verir; yerlerin bir bölümünde gerçekten açık vardır. Bu küme modelin doğrusudur, değerlendirme onu bilmez.
• TS15. Her aday bir belirti sınıfı taşır: sürüm bilgisi, yanıt farkı, yapılandırma ya da davranış. Zayıf sınıflar adayların çoğunu temiz yerlere dağıtır.
• TS16. Bir bulgu, bir yerdeki gerçek açıktır; aynı bulguya birden çok aday işaret edebilir. Kayıp, hiçbir adayı kalmayan gerçek bulgu sayısıdır.
• TS17. Doğrulamanın üç bedeli vardır: süre, hedefe eklenen risk puanı ve savunmada bırakılan iz kaydı. Üçü de aday başına ve belirti sınıfına göre değişir.
• TS18. Zincir modeli önceki kurstan girdi olarak alınır: bir adımda açık bulunamazsa o kalemin sonraki adımları ulaşılamaz sayılabilir.

Eleme Hattı

// eleme.mjs — aday listesini dogrulama kurallarindan gecirip yanlis pozitifi sayar.
// MODELDIR; aday listesi kurgudur, hicbir hedefe islem yapilmaz.
export const TOHUM = 20260214, KALEM = 20;
const uretec = (t) => { let s = t >>> 0;
  return () => (s = (s * 1664525 + 1013904223) >>> 0) / 4294967296; };
const r = uretec(TOHUM);

// Belirti sinifi: adayin hangi kanita dayandigi ve o kanitin gercek cikma orani.
// Surum bilgisi en zayif belirtidir, cunku duzeltme geriye tasinmis olabilir.
export const SINIF = [
  { ad: "surum bilgisi", pay: 0.46, gercek: 0.17, sure: 0.15, risk: 0.0, iz: 2 },
  { ad: "yanit farki", pay: 0.24, gercek: 0.44, sure: 0.35, risk: 0.1, iz: 5 },
  { ad: "yapilandirma", pay: 0.18, gercek: 0.71, sure: 0.50, risk: 0.0, iz: 1 },
  { ad: "davranis", pay: 0.12, gercek: 0.88, sure: 0.90, risk: 0.6, iz: 9 },
];
const sinifSec = (u) => { let t = 0;
  for (const s of SINIF) { t += s.pay; if (u < t) return s; } return SINIF.at(-1); };

// Yer: bir kalemin bir zincir adimi. 20 kalem x 4 adim = 80 yer; bir bolumunde
// gercekten acik var. Bu kume modelin dogrusudur, degerlendirme onu bilmez.
const YER = [];
for (let k = 0; k < KALEM; k++) for (let z = 1; z <= 4; z++) YER.push({ k, z, acik: r() < 0.35 });
const ACIK_YER = YER.filter((y) => y.acik), TEMIZ_YER = YER.filter((y) => !y.acik);
const sec = (l) => l[Math.floor(r() * l.length)];

// 240 ham aday. Zayif belirti siniflari adaylarin cogunu temiz yerlere dagitir.
export const ADAY = Array.from({ length: 240 }, (_, i) => {
  const s = sinifSec(r()), y = r() < s.gercek ? sec(ACIK_YER) : sec(TEMIZ_YER);
  return { no: i, kalem: y.k, zincir: y.z, sinif: s.ad, gercek: y.acik, etki: r() < 0.08 };
});

// Bir bulgu, bir kalemin bir zincir adimindaki gercek aciktir; ayni bulguya birden
// cok aday isaret edebilir. Kayip, hicbir adayi kalmayan gercek bulgu sayisidir.
export const BULGU = new Set(ADAY.filter((a) => a.gercek).map((a) => `${a.kalem}|${a.zincir}`));
const kayip = (l) => BULGU.size -
  new Set(l.filter((a) => a.gercek).map((a) => `${a.kalem}|${a.zincir}`)).size;

export function hat() {
  const adim = [];
  const gecir = (ad, liste, kalir) => {
    const kalan = [], elenen = [];
    for (const a of liste) (kalir(a) ? kalan : elenen).push(a);
    adim.push({ ad, giren: liste.length, elenen: elenen.length, kalan: kalan.length,
      kayip: kayip(kalan) });
    return kalan;
  };
  let l = ADAY;
  // K1: ayni kalemde ayni belirtiden ayni zincir adimina birden cok aday tekillestirilir.
  const gorulen = new Set();
  l = gecir("tekillestirme", l, (a) => {
    const k = `${a.kalem}|${a.sinif}|${a.zincir}`;
    if (gorulen.has(k)) return false;
    gorulen.add(k); return true;
  });
  // K2: yalniz surum bilgisine dayanan aday, ayni kalemin ayni zincir adiminda
  // davranis ya da yanit belirtisi yoksa elenir. Surum eslesmesi kanit degildir.
  const destekli = new Set(l.filter((a) => a.sinif === "davranis" || a.sinif === "yanit farki")
    .map((a) => `${a.kalem}|${a.zincir}`));
  l = gecir("surum destegi", l,
    (a) => a.sinif !== "surum bilgisi" || destekli.has(`${a.kalem}|${a.zincir}`));
  // K3: kaniti hizmeti etkileyecek eylem gerektiren aday dogrulanmaz, askida kalir.
  const askida = l.filter((a) => a.etki);
  l = gecir("etki siniri", l, (a) => !a.etki);
  // K4: kalan adaylar dogrulanir; gercek olmayanlar elenen yanlis pozitiftir.
  const dogrulanacak = l;
  l = gecir("dogrulama", l, (a) => a.gercek);
  return { adim, kanit: l, askida, dogrulanacak };
}

if (import.meta.url === `file://${process.argv[1]}`) {
  const gen = (B) => (h) => h.map((v, j) => (j ? String(v).padStart(B[j])
    : String(v).padEnd(B[0]))).join("");
  const { adim, kanit, askida } = hat();
  console.log(`model (tohum ${TOHUM}): ${ADAY.length} ham aday, ${KALEM} kalem, ` +
    `${ADAY.filter((a) => a.gercek).length} tanesi gercekte acik`);
  const y1 = gen([16, 9, 9, 9, 13]);
  console.log("\n" + y1(["kural", "giren", "elenen", "kalan", "kayip bulgu"]));
  for (const a of adim) console.log(y1([a.ad, a.giren, a.elenen, a.kalan, a.kayip]));
  console.log(y1(["kalan sonuc", "", `${askida.length} askida`, `${kanit.length} kanit`, ""]));

  const y2 = gen([16, 8, 9, 10, 9, 8]);
  console.log("\n" + y2(["belirti sinifi", "aday", "gercek", "gercek %", "kanit", "elenen"]));
  for (const s of SINIF) {
    const l = ADAY.filter((a) => a.sinif === s.ad);
    const k = kanit.filter((a) => a.sinif === s.ad).length;
    console.log(y2([s.ad, l.length, l.filter((a) => a.gercek).length,
      `${(100 * l.filter((a) => a.gercek).length / l.length).toFixed(1)}%`, k, l.length - k]));
  }
  console.log(`\n${ADAY.length} adaydan ${ADAY.length - kanit.length - askida.length}'i ` +
    `eleniyor, ${kanit.length}'i kanit oluyor, ${askida.length}'i askida kaliyor`);
  console.log(`${BULGU.size} gercek bulgunun ${adim.at(-1).kayip}'i eleme sirasinda ` +
    `kayboluyor; surum destegi kurali ${adim[1].kayip - adim[0].kayip}, etki siniri ` +
    `${adim[2].kayip - adim[1].kayip} tanesini goturuyor`);
}

model (tohum 20260214): 240 ham aday, 20 kalem, 114 tanesi gercekte acik

kural               giren   elenen    kalan  kayip bulgu
tekillestirme         240      101      139            0
surum destegi         139       23      116            1
etki siniri           116        9      107            2
dogrulama             107       46       61            2
kalan sonuc               9 askida 61 kanit

belirti sinifi      aday   gercek  gercek %    kanit  elenen
surum bilgisi        104       17     16.3%        7      97
yanit farki           60       33     55.0%       18      42
yapilandirma          37       30     81.1%       17      20
davranis              39       34     87.2%       19      20

240 adaydan 170'i eleniyor, 61'i kanit oluyor, 9'i askida kaliyor
29 gercek bulgunun 2'i eleme sirasinda kayboluyor; surum destegi kurali 1, etki siniri 1 tanesini goturuyor

Hattın dört kuralı çok farklı işler yapıyor. Tekilleştirme tek başına 101 adayı, yani listenin yüzde 42’sini siliyor ve hiçbir bulgu düşürmüyor. Bu, hattın en ucuz kuralıdır: aynı kalemin aynı zincir adımında aynı belirtiden üretilmiş yinelenen adaylar tek bir kaleme iner. Bir rapordaki “240 bulgu” sayısının neredeyse yarısı, bu tek işlemle ortadan kalkabilecek bir sayım hatasıdır.

Sürüm desteği kuralı 23 aday eliyor ve karşılığında 1 gerçek bulgu götürüyor. Etki sınırı 9 adayı askıya alıyor, bir bulgu daha düşüyor. Asıl doğrulama adımı 46 adayı eliyor — bunlar hattın gerçek yanlış pozitifleridir. Geriye 61 kanıt kalıyor: 240 ham adaydan yüzde 25,4.

Dördüncü sütun hattın kendi hatasını yazıyor. 29 gerçek bulgunun 2’si eleme sırasında kayboluyor, yani yüzde 6,9. Bir eleme hattının değeri yalnız kaç aday sildiğiyle ölçülemez; her kural bir eşiktir ve eşik hem gürültüyü hem sinyali keser. Bu iki sayı bir arada raporlanmazsa agresif bir eleme hattı, kapsamı daralttığı halde kaliteli görünür.

İkinci tablo adayların nereden geldiğini gösteriyor ve hattın niçin bu sırayla kurulduğunu açıklıyor. Sürüm bilgisi 104 adayla listenin en büyük kaynağıdır ama yalnız yüzde 16,3’ü gerçektir ve yalnız 7 kanıt bırakır: adayların yüzde 43’ü, kanıtların yüzde 11,5’i. Nedeni bir ölçüm kusuru değildir — bir düzeltme geriye taşındığında sürüm dizesi değişmeden açık kapanır, dolayısıyla sürüm eşleşmesi kanıt taşımaz. Davranış sınıfı ise 39 adayla en küçük kaynak olduğu halde 19 kanıtla en büyük katkıyı verir: gözlenen davranış, çıkarım değil ölçümdür.

Doğrulama Sırası ve Eklenen Risk

// sira.mjs — dogrulama sirasi: zincirin onkosul adimi once dogrulanirsa
// sonraki adimlarin adaylari hic kosturulmadan karara baglanir.
import { SINIF, hat } from "./eleme.mjs";

const bilgi = (ad) => SINIF.find((s) => s.ad === ad);
const LISTE = hat().dogrulanacak;                   // eleme kurallarindan gecmis adaylar

const topla = (l) => l.reduce((o, a) => {
  const s = bilgi(a.sinif);
  return { sayi: o.sayi + 1, saat: o.saat + s.sure, risk: o.risk + s.risk, iz: o.iz + s.iz };
}, { sayi: 0, saat: 0, risk: 0, iz: 0 });

// Kesme adimlari: hangi zincir adiminda olumsuz sonuc alinirsa kalemin geri kalani
// ulasilamaz sayilir. Bos kume = her aday tek tek dogrulanir.
function kosum(kesme) {
  const kosan = [], atlanan = [];
  for (const k of new Set(LISTE.map((a) => a.kalem))) {
    const kalemAdayi = LISTE.filter((a) => a.kalem === k);
    let kesildi = false;
    for (let z = 1; z <= 4; z++) {
      const adimAdayi = kalemAdayi.filter((a) => a.zincir === z);
      if (kesildi) { atlanan.push(...adimAdayi); continue; }
      kosan.push(...adimAdayi);
      if (kesme.has(z) && adimAdayi.length && !adimAdayi.some((a) => a.gercek)) kesildi = true;
    }
  }
  return { ...topla(kosan), kanit: kosan.filter((a) => a.gercek).length, atlanan,
    kacan: atlanan.filter((a) => a.gercek).length, kosan };
}

const YOL = [["sirasiz", new Set()], ["yalniz onkosul", new Set([1])],
  ["tam zincir", new Set([1, 2, 3, 4])]];
const gen = (B) => (h) => h.map((v, j) => (j ? String(v).padStart(B[j])
  : String(v).padEnd(B[0]))).join("");
const yz = gen([16, 12, 8, 10, 16, 8, 8, 10]);
console.log(`dogrulama hattina ${LISTE.length} aday giriyor; risk puani bir dogrulama ` +
  `adiminin hizmeti etkileme agirligidir`);
console.log(yz(["dogrulama sirasi", "dogrulanan", "kanit", "atlanan", "atlanan gercek",
  "saat", "risk", "iz kaydi"]));
const sonuc = {};
for (const [ad, kesme] of YOL) {
  const o = kosum(kesme); sonuc[ad] = o;
  console.log(yz([ad, o.sayi, o.kanit, o.atlanan.length, o.kacan, o.saat.toFixed(1),
    o.risk.toFixed(1), o.iz]));
}

const y2 = gen([16, 12, 14, 14, 12]);
console.log("\n" + y2(["belirti sinifi", "risk/aday", "hattaki aday", "tam zincirde",
  "kosulmayan"]));
for (const s of SINIF) {
  const a = LISTE.filter((x) => x.sinif === s.ad).length;
  const b = sonuc["tam zincir"].kosan.filter((x) => x.sinif === s.ad).length;
  console.log(y2([s.ad, s.risk.toFixed(1), a, b, a - b]));
}
const [d, o1, o2] = YOL.map(([ad]) => sonuc[ad]);
console.log(`\nonkosul kesmesi ${o1.atlanan.length} adayi kosturmuyor: riski ` +
  `${d.risk.toFixed(1)}'ten ${o1.risk.toFixed(1)}'e, izi ${d.iz}'ten ${o1.iz}'e indiriyor`);
console.log(`tam zincir kesmesi ${o2.atlanan.length} adayi kosturmuyor ve riski ` +
  `${(100 * (1 - o2.risk / d.risk)).toFixed(1)}% dusuruyor; bedeli, onkosulu kapali sayilan ` +
  `${o2.kacan} gercek acigin kanitsiz kalmasidir`);

dogrulama hattina 107 aday giriyor; risk puani bir dogrulama adiminin hizmeti etkileme agirligidir
dogrulama sirasi  dogrulanan   kanit   atlanan  atlanan gercek    saat    risk  iz kaydi
sirasiz                  107      61         0               0    48.9    17.8       461
yalniz onkosul            89      53        18               8    41.3    15.2       383
tam zincir                74      45        33              16    33.3    11.9       313

belirti sinifi     risk/aday  hattaki aday  tam zincirde  kosulmayan
surum bilgisi            0.0            26            19           7
yanit farki              0.1            34            23          11
yapilandirma             0.0            23            16           7
davranis                 0.6            24            16           8

onkosul kesmesi 18 adayi kosturmuyor: riski 17.8'ten 15.2'e, izi 461'ten 383'e indiriyor
tam zincir kesmesi 33 adayi kosturmuyor ve riski 33.1% dusuruyor; bedeli, onkosulu kapali sayilan 16 gercek acigin kanitsiz kalmasidir

Üç satır aynı 107 adayı üç ayrı sırayla ele alıyor ve üçü de farklı bir şey satın alıyor. Sırasız doğrulama en çok kanıtı veriyor — 61 — ama en pahalı olanıdır: 48,9 saat, 17,8 risk puanı ve savunmada 461 kayıt. Tam zincir sırası koşturulan aday sayısını 74’e indiriyor; risk yüzde 33,1 düşüyor, iz 313 kayda iniyor ve 15,6 saat kazanılıyor.

Kazancın nereden geldiği ikinci tabloda yazıyor. Risk puanının neredeyse tamamı davranış sınıfındadır; sürüm ve yapılandırma adaylarının hedefe eklediği risk sıfırdır, çünkü ikisi de gözlemdir. Tam zincir sırası 24 davranış adayının 8’ini hiç koşturmuyor, ve düşen riskin büyük bölümü bu sekiz koşumun yapılmamasından geliyor. Aynı mantık iz sütununda da işler: davranış adayı başına 9 kayıt üretilirken yapılandırma adayı başına 1 kayıt üretilir.

Bedeli dördüncü sütundadır: tam zincir sırasında 33 aday hiç koşturulmaz ve bunların 16’sı gerçekte açıktır. Bu 16 kalem bir kayıp mıdır, sorunun yanıtı zincir modelinin doğruluğuna bağlıdır. Model doğruysa o açıklara giden önkoşul kapalıdır ve bir saldırgan da oraya ulaşamaz — o zaman 16 koşum gereksiz risktir. Model eksikse, yani aynı yere ikinci bir yol varsa, 16 gerçek açık kanıtsız kalır. Ara satır bu yüzden vardır: yalnız önkoşul adımında kesmek riski 17,8’den 15,2’ye indirirken atlanan gerçek açığı 8’de tutar.

Hangi sıra seçilirse seçilsin rapor tarafında değişmeyen bir kural kalır. Koşturulmayan aday listeden silinmez; “önkoşulu kapalı sayıldığı için doğrulanmadı” kaydıyla ve hangi adımın hangi sonucu verdiği yazılarak durur. Aksi durumda rapor, kapsamı olduğundan geniş gösterir.

Özet

• 240 ham aday dört kuraldan geçip 61 kanıta iniyor; tekilleştirme tek başına 101 adayı, listenin yüzde 42’sini, hiçbir bulgu düşürmeden siliyor.
• Eleme hattı kendi hatasını da üretiyor: 29 gerçek bulgunun 2’si kurallar sırasında kayboluyor, bu yüzden silinen aday sayısı ile düşen bulgu sayısı birlikte raporlanmalıdır.
• Adayların yüzde 43’ü sürüm bilgisinden geliyor ama bu sınıfın yalnız yüzde 16,3’ü gerçek ve kanıtların yalnız yüzde 11,5’ini veriyor; düzeltme geriye taşındığında sürüm dizesi değişmez.
• Davranış sınıfı en küçük kaynak olduğu halde en çok kanıtı veriyor — 39 adaydan 19 — çünkü gözlenen davranış çıkarım değil ölçümdür.
• Doğrulama sırası zincire bağlandığında koşturulan aday 107’den 74’e, risk 17,8’den 11,9’a ve iz 461’den 313 kayda iniyor; düşüşün büyük bölümü koşturulmayan 8 davranış adayından geliyor.
• Tam zincir sırasının bedeli, önkoşulu kapalı sayılan 16 gerçek açığın kanıtsız kalmasıdır; bu kalemler rapordan silinmez, doğrulanmama gerekçesiyle birlikte yazılır.

Sonraki Adım

Elde 61 kanıt, 9 askıda aday ve doğrulanmadan bırakılmış bir liste var. Bu üç küme bir düzeltme kuyruğuna girecekse sıraya konmak zorundadır, ve sıralamanın ölçütü henüz yazılmadı. Teknik ağırlık bir sıra üretir: erişim kolaylığı, etkinin genişliği, düzeltmenin zorluğu. Aynı liste iş tarafından bakıldığında başka bir sıra üretir, çünkü bir kalemin taşıdığı iş bir başkasınınkiyle aynı değildir. Sonraki ders aynı bulgu kümesini iki ayrı iş bağlamında puanlar ve iki sıralamanın kaç sırada ayrıştığını sayar.