Citation Probability

1// Citation Probability Measurement and Optimization Framework
2interface QuerySample {
3  query: string;
4  platform: string;
5  timestamp: Date;
6  cited: boolean;
7  citationPosition?: number; // 1 = first cited, 2 = second, etc.
8  citationContext?: 'primary' | 'supporting' | 'comparison' | 'example';
9  responseText?: string;
10}
11 
12interface ProbabilityEstimate {
13  probability: number;
14  sampleSize: number;
15  confidenceInterval: {
16    lower: number;
17    upper: number;
18  };
19  confidenceLevel: number;
20}
21 
22interface ContentProbabilityProfile {
23  contentUrl: string;
24  queries: Map<string, ProbabilityEstimate>;
25  overallProbability: ProbabilityEstimate;
26  platformBreakdown: Record<string, ProbabilityEstimate>;
27  probabilityDrivers: ProbabilityDriver[];
28  optimizationOpportunities: OptimizationOpportunity[];
29}
30 
31interface ProbabilityDriver {
32  factor: string;
33  impact: 'high' | 'medium' | 'low';
34  currentState: string;
35  recommendation: string;
36}
37 
38interface OptimizationOpportunity {
39  description: string;
40  expectedProbabilityIncrease: number;
41  effort: 'low' | 'medium' | 'high';
42  priority: number;
43}
44 
45class CitationProbabilityAnalyzer {
46  private samples: QuerySample[] = [];
47  private contentUrl: string;
48  private platforms: string[];
49 
50  constructor(contentUrl: string, platforms: string[] = ['chatgpt', 'perplexity', 'claude', 'gemini']) {
51    this.contentUrl = contentUrl;
52    this.platforms = platforms;
53  }
54 
55  // Record a query sample
56  recordSample(sample: QuerySample): void {
57    this.samples.push(sample);
58  }
59 
60  // Calculate probability estimate with confidence interval
61  calculateProbability(
62    samples: QuerySample[],
63    confidenceLevel: number = 0.95
64  ): ProbabilityEstimate {
65    const n = samples.length;
66    if (n === 0) {
67      return {
68        probability: 0,
69        sampleSize: 0,
70        confidenceInterval: { lower: 0, upper: 0 },
71        confidenceLevel,
72      };
73    }
74 
75    const successes = samples.filter(s => s.cited).length;
76    const p = successes / n;
77 
78    // Calculate confidence interval using Wilson score interval
79    // More accurate than simple binomial for small samples or extreme probabilities
80    const z = this.getZScore(confidenceLevel);
81    const denominator = 1 + z * z / n;
82    const center = (p + z * z / (2 * n)) / denominator;
83    const margin = (z / denominator) * Math.sqrt(p * (1 - p) / n + z * z / (4 * n * n));
84 
85    return {
86      probability: p * 100,
87      sampleSize: n,
88      confidenceInterval: {
89        lower: Math.max(0, (center - margin)) * 100,
90        upper: Math.min(1, (center + margin)) * 100,
91      },
92      confidenceLevel,
93    };
94  }
95 
96  private getZScore(confidenceLevel: number): number {
97    const zScores: Record<number, number> = {
98      0.90: 1.645,
99      0.95: 1.96,
100      0.99: 2.576,
101    };
102    return zScores[confidenceLevel] || 1.96;
103  }
104 
105  // Calculate position-weighted probability
106  calculatePositionWeightedProbability(samples: QuerySample[]): number {
107    const positionWeights: Record<number, number> = {
108      1: 1.0,   // First citation
109      2: 0.7,   // Second citation
110      3: 0.5,   // Third citation
111      4: 0.3,   // Fourth or later
112    };
113 
114    let totalWeight = 0;
115    samples.forEach(sample => {
116      if (sample.cited && sample.citationPosition) {
117        const weight = positionWeights[Math.min(sample.citationPosition, 4)];
118        totalWeight += weight;
119      }
120    });
121 
122    return (totalWeight / samples.length) * 100;
123  }
124 
125  // Generate comprehensive probability profile
126  generateProfile(): ContentProbabilityProfile {
127    // Overall probability
128    const overallProbability = this.calculateProbability(this.samples);
129 
130    // By query
131    const queries = new Map<string, ProbabilityEstimate>();
132    const queryGroups = this.groupBy(this.samples, 'query');
133    queryGroups.forEach((samples, query) => {
134      queries.set(query, this.calculateProbability(samples));
135    });
136 
137    // By platform
138    const platformBreakdown: Record<string, ProbabilityEstimate> = {};
139    this.platforms.forEach(platform => {
140      const platformSamples = this.samples.filter(s => s.platform === platform);
141      platformBreakdown[platform] = this.calculateProbability(platformSamples);
142    });
143 
144    // Analyze probability drivers
145    const drivers = this.analyzeProbabilityDrivers();
146 
147    // Identify optimization opportunities
148    const opportunities = this.identifyOpportunities(overallProbability, platformBreakdown);
149 
150    return {
151      contentUrl: this.contentUrl,
152      queries,
153      overallProbability,
154      platformBreakdown,
155      probabilityDrivers: drivers,
156      optimizationOpportunities: opportunities,
157    };
158  }
159 
160  private groupBy<T>(array: T[], key: keyof T): Map<string, T[]> {
161    const map = new Map<string, T[]>();
162    array.forEach(item => {
163      const k = String(item[key]);
164      const collection = map.get(k) || [];
165      collection.push(item);
166      map.set(k, collection);
167    });
168    return map;
169  }
170 
171  // Analyze what's driving citation probability
172  private analyzeProbabilityDrivers(): ProbabilityDriver[] {
173    // In production, this would analyze actual content characteristics
174    // Here we show the framework structure
175    return [
176      {
177        factor: 'Content Structure',
178        impact: 'high',
179        currentState: 'Clear headings, structured data present',
180        recommendation: 'Add FAQ schema and more explicit definitions',
181      },
182      {
183        factor: 'Authority Signals',
184        impact: 'high',
185        currentState: 'Expert author listed, 45 referring domains',
186        recommendation: 'Increase external citations from recognized authorities',
187      },
188      {
189        factor: 'Content Freshness',
190        impact: 'medium',
191        currentState: 'Last updated 3 months ago',
192        recommendation: 'Implement quarterly review cycle',
193      },
194      {
195        factor: 'Extractable Elements',
196        impact: 'medium',
197        currentState: 'Statistics present but not highlighted',
198        recommendation: 'Format key statistics for easy extraction',
199      },
200      {
201        factor: 'Topic Comprehensiveness',
202        impact: 'high',
203        currentState: 'Covers 70% of related subtopics',
204        recommendation: 'Expand coverage to address missing subtopics',
205      },
206    ];
207  }
208 
209  // Identify specific optimization opportunities
210  private identifyOpportunities(
211    overall: ProbabilityEstimate,
212    platforms: Record<string, ProbabilityEstimate>
213  ): OptimizationOpportunity[] {
214    const opportunities: OptimizationOpportunity[] = [];
215 
216    // Platform-specific opportunities
217    const avgPlatformProb = Object.values(platforms).reduce(
218      (sum, p) => sum + p.probability, 0
219    ) / Object.keys(platforms).length;
220 
221    Object.entries(platforms).forEach(([platform, prob]) => {
222      if (prob.probability < avgPlatformProb * 0.7) {
223        opportunities.push({
224          description: `Improve ${platform}-specific optimization (currently ${prob.probability.toFixed(1)}% vs ${avgPlatformProb.toFixed(1)}% average)`,
225          expectedProbabilityIncrease: avgPlatformProb - prob.probability,
226          effort: 'medium',
227          priority: (avgPlatformProb - prob.probability) / 10,
228        });
229      }
230    });
231 
232    // Overall probability opportunities
233    if (overall.probability < 20) {
234      opportunities.push({
235        description: 'Build foundational authority - probability too low for tactical optimizations',
236        expectedProbabilityIncrease: 10,
237        effort: 'high',
238        priority: 10,
239      });
240    } else if (overall.probability < 40) {
241      opportunities.push({
242        description: 'Improve content structure and extractability for moderate probability gains',
243        expectedProbabilityIncrease: 8,
244        effort: 'medium',
245        priority: 8,
246      });
247    }
248 
249    return opportunities.sort((a, b) => b.priority - a.priority);
250  }
251 
252  // Compare probability against competitor
253  compareProbability(
254    competitorSamples: QuerySample[]
255  ): {
256    yourProbability: ProbabilityEstimate;
257    competitorProbability: ProbabilityEstimate;
258    gap: number;
259    statisticallySignificant: boolean;
260  } {
261    const yours = this.calculateProbability(this.samples);
262    const competitor = this.calculateProbability(competitorSamples);
263    
264    const gap = yours.probability - competitor.probability;
265    
266    // Check if gap is statistically significant
267    // Using simplified significance test
268    const pooledN = yours.sampleSize + competitor.sampleSize;
269    const pooledP = (
270      yours.probability * yours.sampleSize + 
271      competitor.probability * competitor.sampleSize
272    ) / pooledN / 100;
273    
274    const standardError = Math.sqrt(
275      pooledP * (1 - pooledP) * (1/yours.sampleSize + 1/competitor.sampleSize)
276    ) * 100;
277    
278    const zScore = Math.abs(gap) / standardError;
279    const statisticallySignificant = zScore > 1.96; // 95% confidence
280 
281    return {
282      yourProbability: yours,
283      competitorProbability: competitor,
284      gap,
285      statisticallySignificant,
286    };
287  }
288 
289  // Calculate required sample size for desired confidence
290  static calculateRequiredSampleSize(
291    expectedProbability: number,
292    marginOfError: number,
293    confidenceLevel: number = 0.95
294  ): number {
295    const zScores: Record<number, number> = {
296      0.90: 1.645,
297      0.95: 1.96,
298      0.99: 2.576,
299    };
300    const z = zScores[confidenceLevel] || 1.96;
301    const p = expectedProbability / 100;
302    const e = marginOfError / 100;
303    
304    return Math.ceil((z * z * p * (1 - p)) / (e * e));
305  }
306}
307 
308// Usage example
309const analyzer = new CitationProbabilityAnalyzer(
310  'https://example.com/guide/project-management-best-practices'
311);
312 
313// Simulate collecting samples
314for (let i = 0; i < 100; i++) {
315  analyzer.recordSample({
316    query: 'project management best practices',
317    platform: ['chatgpt', 'perplexity', 'claude', 'gemini'][i % 4],
318    timestamp: new Date(),
319    cited: Math.random() < 0.32, // Simulating ~32% citation rate
320    citationPosition: Math.random() < 0.4 ? 1 : Math.ceil(Math.random() * 3) + 1,
321    citationContext: ['primary', 'supporting', 'example'][Math.floor(Math.random() * 3)] as any,
322  });
323}
324 
325// Generate profile
326const profile = analyzer.generateProfile();
327 
328console.log('=== CITATION PROBABILITY PROFILE ===\n');
329console.log(`Content: ${profile.contentUrl}\n`);
330 
331console.log('Overall Citation Probability:');
332console.log(`  Probability: ${profile.overallProbability.probability.toFixed(1)}%`);
333console.log(`  95% CI: [${profile.overallProbability.confidenceInterval.lower.toFixed(1)}%, ${profile.overallProbability.confidenceInterval.upper.toFixed(1)}%]`);
334console.log(`  Sample size: ${profile.overallProbability.sampleSize}\n`);
335 
336console.log('Platform Breakdown:');
337Object.entries(profile.platformBreakdown).forEach(([platform, estimate]) => {
338  console.log(`  ${platform}: ${estimate.probability.toFixed(1)}% (n=${estimate.sampleSize})`);
339});
340 
341console.log('\nProbability Drivers:');
342profile.probabilityDrivers.forEach(driver => {
343  console.log(`  [${driver.impact.toUpperCase()}] ${driver.factor}`);
344  console.log(`    Current: ${driver.currentState}`);
345  console.log(`    Recommendation: ${driver.recommendation}`);
346});
347 
348console.log('\nOptimization Opportunities:');
349profile.optimizationOpportunities.forEach(opp => {
350  console.log(`  • ${opp.description}`);
351  console.log(`    Expected gain: +${opp.expectedProbabilityIncrease.toFixed(1)}pp, Effort: ${opp.effort}`);
352});
353 
354// Calculate required sample size for future measurement
355const requiredSamples = CitationProbabilityAnalyzer.calculateRequiredSampleSize(30, 5, 0.95);
356console.log(`\nFor ±5pp margin of error at 95% confidence with ~30% probability: need ${requiredSamples} samples`);