"""Offline, standard-library teaching checks; no models or external services. Run: python stanford-2026-lab.py These checks validate the articles' toy data and counterexamples, not papers, model performance, production concurrency, or Stanford coursework. """ import itertools import math import sqlite3 import unittest def overlap(day1, start1, end1, day2, start2, end2): return day1 == day2 and start1 < end2 and start2 < end1 def tv_and(a, b): if False in (a, b): return False return None if None in (a, b) else True def tv_or(a, b): if True in (a, b): return True return None if None in (a, b) else False def tv_not(a): return None if a is None else not a def classify_worlds(facts, predicate): worlds = [dict(zip(('A', 'B', 'conflict'), values)) for values in itertools.product((False, True), repeat=3)] compatible = [w for w in worlds if all(f(w) for f in facts)] if not compatible: return 'inconsistent' values = {predicate(w) for w in compatible} if values == {True}: return 'entailed' if values == {False}: return 'refuted' return 'undetermined' def edit_distance(reference, prediction): row = list(range(len(prediction) + 1)) for i, r in enumerate(reference, 1): nxt = [i] for j, p in enumerate(prediction, 1): nxt.append(min(row[j] + 1, nxt[j - 1] + 1, row[j - 1] + (r != p))) row = nxt return row[-1] def cer(reference, prediction): if not reference: raise ValueError('Empty references need a separate evaluation policy') return edit_distance(reference, prediction) / len(reference) def increasing(values, expected_years): if any(values.get(y) is None for y in expected_years): return None ordered = [values[y] for y in sorted(expected_years)] return all(a < b for a, b in zip(ordered, ordered[1:])) class ToyService: """Sequential in-memory mock, intentionally NOT crash/concurrency safe.""" def __init__(self): self.results = {} def create(self, operation_id, body, lose_response=False): if operation_id in self.results: old_body, ticket = self.results[operation_id] if body != old_body: raise ValueError('same operation ID, different intent') else: ticket = 'ticket-' + str(len(self.results) + 1) self.results[operation_id] = (body, ticket) if lose_response: raise TimeoutError('side effect happened; response was lost') return ticket class Draft: """Single-process state example; methods run sequentially.""" def __init__(self): self.revision, self.course = 1, 'C1' self.checked_revision = self.confirmed_revision = None def change(self, course): self.course, self.revision = course, self.revision + 1 self.checked_revision = self.confirmed_revision = None def accept_check(self, revision): if revision != self.revision: return False self.checked_revision = revision return True def confirm(self): self.confirmed_revision = self.revision def submittable(self): return self.checked_revision == self.confirmed_revision == self.revision class ArticleExamples(unittest.TestCase): def setUp(self): self.db = sqlite3.connect(':memory:') self.addCleanup(self.db.close) self.db.executescript(''' CREATE TABLE offerings(id TEXT PRIMARY KEY, term TEXT, credits INTEGER, prerequisite TEXT, practice TEXT, schedule_complete INTEGER); CREATE TABLE meetings(offering_id TEXT, day INTEGER, start_min INTEGER, end_min INTEGER); CREATE TABLE busy(day INTEGER, start_min INTEGER, end_min INTEGER); CREATE TABLE completed(prerequisite TEXT PRIMARY KEY); CREATE TABLE reviews(course_id TEXT, text TEXT); INSERT INTO busy VALUES(3,840,960); INSERT INTO completed VALUES('A'); ''') self.db.executemany('INSERT INTO offerings VALUES(?,?,?,?,?,1)', [ ('C1', 'autumn', 3, 'A', 'support'), ('C2', 'autumn', 4, 'A', 'support'), ('C3', 'autumn', 3, 'B', 'unknown'), ('C4', 'spring', 3, 'A', 'support'), ('C5', 'autumn', 4, 'A', 'contradict'), ('C6', 'autumn', 3, 'A', 'unknown')]) self.db.executemany('INSERT INTO meetings VALUES(?,?,?,?)', [ ('C1', 1, 540, 660), ('C2', 3, 900, 1020), ('C3', 2, 540, 660), ('C4', 4, 540, 660), ('C5', 4, 540, 660), ('C6', 5, 540, 660)]) def candidates(self, limit=10): rows = self.db.execute(''' SELECT o.id FROM offerings o WHERE o.term='autumn' AND 4+o.credits <= ? AND o.schedule_complete=1 AND EXISTS(SELECT 1 FROM completed c WHERE c.prerequisite=o.prerequisite) AND NOT EXISTS( SELECT 1 FROM meetings m JOIN busy b ON m.day=b.day WHERE m.offering_id=o.id AND m.start_min < b.end_min AND b.start_min < m.end_min) ORDER BY o.id ''', (limit,)) return [r[0] for r in rows] def test_01_hard_candidates_and_credit_boundary(self): self.assertEqual(self.candidates(), ['C1', 'C5', 'C6']) self.assertEqual(self.candidates(limit=6), []) self.assertEqual(self.candidates(limit=7), ['C1', 'C6']) def test_02_interval_boundaries_and_multiple_meetings(self): self.assertTrue(overlap(3, 840, 960, 3, 900, 1020)) self.assertFalse(overlap(3, 840, 960, 3, 960, 1080)) self.db.execute("UPDATE meetings SET start_min=960 WHERE offering_id='C2'") self.assertIn('C2', self.candidates()) self.db.execute("INSERT INTO meetings VALUES('C1',3,900,930)") self.assertNotIn('C1', self.candidates()) def test_03_missing_schedule_is_not_no_conflict(self): self.db.execute("DELETE FROM meetings WHERE offering_id='C1'") self.assertIn('C1', self.candidates()) # counterexample to stale completeness self.db.execute("UPDATE offerings SET schedule_complete=0 WHERE id='C1'") self.assertNotIn('C1', self.candidates()) def test_04_join_granularity(self): self.db.executemany('INSERT INTO reviews VALUES(?,?)', [('C1', 'review 1'), ('C1', 'review 2')]) counts = self.db.execute('''SELECT COUNT(*),COUNT(DISTINCT o.id) FROM offerings o JOIN reviews r ON o.id=r.course_id''').fetchone() self.assertEqual(counts, (2, 1)) def test_05_top_k_and_or_pushdown_counterexamples(self): ranking = ['C2', 'C4', 'C1'] hard = set(self.candidates()) self.assertEqual([x for x in ranking[:2] if x in hard], []) self.assertEqual([x for x in ranking if x in hard][:2], ['C1']) correct = [r[0] for r in self.db.execute('''SELECT id FROM offerings WHERE (term='autumn' AND practice='support') OR id='C4' ORDER BY id''')] wrong = [r[0] for r in self.db.execute('''SELECT id FROM offerings WHERE term='autumn' AND (practice='support' OR id='C4') ORDER BY id''')] self.assertEqual(correct, ['C1', 'C2', 'C4']) self.assertEqual(wrong, ['C1', 'C2']) def test_06_three_valued_logic(self): self.assertIsNone(tv_and(True, None)) self.assertFalse(tv_and(False, None)) self.assertTrue(tv_or(True, None)) self.assertIsNone(tv_or(False, None)) self.assertIsNone(tv_not(None)) labels = {'C1': True, 'C5': False, 'C6': None} self.assertEqual([c for c in self.candidates() if labels[c] is True], ['C1']) self.assertEqual([c for c in self.candidates() if labels[c] is None], ['C6']) def test_07_local_eligibility_not_set_feasibility(self): self.assertLessEqual(4 + 3, 10) self.assertLessEqual(4 + 4, 10) self.assertGreater(4 + 3 + 4, 10) def test_08_graph_time_overlap(self): records = [('R1', 'O1', 2020, 2022), ('R2', 'O1', 2023, 2025), ('R3', 'O1', 2021, 2024), ('R4', 'O2', 2021, 2024)] answer = [p for p, org, s, e in records if p != 'R1' and org == 'O1' and s < 2022 and 2020 < e] self.assertEqual(answer, ['R3']) def test_09_document_units_and_year_coverage(self): self.assertEqual(12 * 10000, 120000) self.assertIsNone(increasing({2023: 120000, 2024: 150000}, [2023, 2024, 2025])) self.assertTrue(increasing({2023: 120000, 2024: 150000, 2025: 160000}, [2023, 2024, 2025])) self.assertFalse(increasing({2023: 120000, 2024: 150000, 2025: 150000}, [2023, 2024, 2025])) def test_10_simpson_and_standardization(self): self.assertGreater(81 / 110, 29 / 110) self.assertLess(80 / 100, 9 / 10) self.assertLess(1 / 10, 20 / 100) self.assertAlmostEqual(.5 * .9 + .5 * .2, .55) self.assertAlmostEqual(.5 * .8 + .5 * .1, .45) def test_11_possible_worlds_and_consistency(self): facts = [lambda w: not w['A'], lambda w: not w['conflict']] eligible = lambda w: (w['A'] or w['B']) and not w['conflict'] and 4 + 3 <= 10 self.assertEqual(classify_worlds(facts, eligible), 'undetermined') self.assertEqual(classify_worlds(facts + [lambda w: w['B']], eligible), 'entailed') self.assertEqual(classify_worlds(facts + [lambda w: not w['B']], eligible), 'refuted') self.assertEqual(classify_worlds(facts + [lambda w: w['A']], eligible), 'inconsistent') def test_12_edit_distance_and_cer(self): self.assertEqual(cer('ABCD', 'ABXD'), .25) self.assertEqual(cer('ABCD', 'XABCD'), .25) self.assertEqual(edit_distance('AB', 'BA'), 2) self.assertEqual(cer('A', 'ABCD'), 3) with self.assertRaises(ValueError): cer('', 'A') def test_13_unknown_result_and_idempotent_retry(self): service = ToyService() with self.assertRaises(TimeoutError): service.create('op-17', 'A', lose_response=True) self.assertEqual(service.create('op-17', 'A'), 'ticket-1') self.assertEqual(len(service.results), 1) with self.assertRaises(ValueError): service.create('op-17', 'B') service.create('new-operation', 'A') self.assertEqual(len(service.results), 2) # new key repeats the side effect def test_14_late_check_and_confirmation_invalidation(self): draft = Draft() draft.accept_check(1) draft.confirm() self.assertTrue(draft.submittable()) draft.change('C2') self.assertFalse(draft.accept_check(1)) self.assertFalse(draft.submittable()) draft.accept_check(2) self.assertFalse(draft.submittable()) draft.confirm() self.assertTrue(draft.submittable()) def test_15_rag_version_and_rrf(self): corpus = [('D1', 'A', '2.0'), ('D2', 'A', '2.0'), ('D3', 'B', '1.0'), ('D4', 'B', '2.0')] self.assertEqual([d for d, product, version in corpus if product == 'B' and version == '2.0'], ['D4']) scores = {} for ranking in [['D1', 'D2'], ['D2', 'D4']]: for rank, doc in enumerate(ranking, 1): scores[doc] = scores.get(doc, 0) + 1 / (60 + rank) self.assertEqual(max(scores, key=scores.get), 'D2') def test_16_any_evidence_is_not_all_evidence(self): needed = [{'a', 'b'} for _ in range(10)] retrieved = [{'a'} for _ in range(10)] self.assertEqual(sum(bool(n & r) for n, r in zip(needed, retrieved)), 10) self.assertEqual(sum(n <= r for n, r in zip(needed, retrieved)), 0) def test_17_evaluation_probability_and_judge_denominators(self): self.assertAlmostEqual(1 - (1 - .8) ** 3, .992) self.assertAlmostEqual(.8 ** 3, .512) self.assertAlmostEqual((72 + 16) / 100, .88) self.assertAlmostEqual(4 / 20, .2) self.assertAlmostEqual(4 / (72 + 4), .05263157894736842) def test_18_distribution_weighting(self): self.assertAlmostEqual(.9 * .98 + .1 * .50, .932) self.assertAlmostEqual(.9 * .96 + .1 * .70, .934) self.assertAlmostEqual(.5 * .98 + .5 * .50, .74) self.assertAlmostEqual(.5 * .96 + .5 * .70, .83) def test_19_cost_latency_and_notification_threshold(self): self.assertAlmostEqual(.1 + .2 * 5, 1.1) self.assertAlmostEqual(5 + .4 * .1, 5.04) self.assertEqual(6 + 8 + 3, 17) self.assertEqual(max(6, 8) + 3 + 2, 13) threshold = 2 / (5 + 2) self.assertAlmostEqual(threshold * 5 - (1 - threshold) * 2, 0) def test_20_masked_training_loss(self): # Toy assigned probabilities, NOT a trained model or tokenizer. probabilities = [.9, .9, .1] mask = [0, 0, 1] loss = -sum(m * math.log(p) for m, p in zip(mask, probabilities)) / sum(mask) self.assertAlmostEqual(loss, -math.log(.1)) averaged = -sum(math.log(p) for p in probabilities) / 3 self.assertLess(averaged, loss) # easy tokens hide difficult decision token if __name__ == '__main__': unittest.main(verbosity=2)