Methodology

Legal Outcome Prediction Task:

Input:  C = (T, M, G)
  where:
    T = case text (opinion, arguments)
    M = metadata (date, court, parties)
    G = citation subgraph context

Output: y ∈ {petitioner, respondent}

Objective: Learn f: (T, M, G) → y
  that maximizes P(y | T, M, G)
                

GraphSAGE Layer (Hamilton et al., 2017):

AGGREGATE:
  a_v^(k) = MEAN({h_u^(k-1) : u ∈ N(v)})

COMBINE:
  h_v^(k) = σ(W^(k) · CONCAT(h_v^(k-1), a_v^(k)))

With L2 normalization:
  h_v^(k) = h_v^(k) / ||h_v^(k)||₂

Where:
  h_v^(0) = x_v (initial node features)
  N(v) = {u : (u,v) ∈ E} (cited cases)
  σ = ReLU activation
  W^(k) ∈ ℝ^{d_k × 2d_{k-1}}
                

Standard Cross-Entropy:

ℒ_CE = -∑_{i=1}^{N} ∑_{c=1}^{C} y_{i,c} · log(p_{i,c})

For binary classification (C=2):

ℒ_CE = -1/N ∑_{i=1}^{N} [y_i·log(p_i) + (1-y_i)·log(1-p_i)]

Where:
  N = number of samples
  C = number of classes (2)
  y_{i,c} = ground truth (one-hot)
  p_{i,c} = predicted probability
                

Label Smoothing (Szegedy et al., 2016):

Smoothed targets:
  y'_{i,c} = y_{i,c}·(1-ε) + ε/C

With ε = 0.1:
  Hard: [1, 0] → Soft: [0.95, 0.05]
  Hard: [0, 1] → Soft: [0.05, 0.95]

Equivalent loss:
  ℒ_LS = (1-ε)·ℒ_CE(y,p) + ε·H(u,p)

Where H(u,p) is CE with uniform dist.
                

Negative Sampling Distribution:

P_n(v) ∝ degree(v)^α

With α = 0.75 (Mikolov et al., 2013):
  - α = 0: uniform sampling
  - α = 1: degree-proportional
  - α = 0.75: smoothed (empirically optimal)

Effect: Reduces sampling of rare nodes,
focuses on distinguishing similar cases.
                

Simple Concatenation:

e_concat = [e_text; e_graph]
         = [384-dim; 128-dim]
         = 512-dim

Fusion MLP:
h1 = ReLU(W1 · e_concat + b1)  # 512→256
h1 = Dropout(h1, p=0.2)
h2 = ReLU(W2 · h1 + b2)        # 256→128
e_fused = L2_normalize(h2)

Where:
  W1 ∈ ℝ^{256×512}, b1 ∈ ℝ^256
  W2 ∈ ℝ^{128×256}, b2 ∈ ℝ^128
                

Gated Fusion (Arevalo et al., 2017):

g = σ(W_g · [e_text; e_graph] + b_g)
e_fused = g ⊙ tanh(W_t·e_text) +
          (1-g) ⊙ tanh(W_g·e_graph)

Where:
  g ∈ ℝ^d: learned gating vector
  σ: sigmoid activation
  ⊙: element-wise multiplication

Advantage: Adaptive weighting per
dimension based on input content.
                

Hierarchical truncation:

1. Case text: truncate to 5000 tokens
   - Keep first 2500 (background)
   - Keep last 2500 (holding/conclusion)

2. Precedent excerpts: 3000 tokens each
   - Prioritize holding sections
   - Include key cited passages

3. If over budget:
   - Reduce precedent count (k=5→4→3)
   - Further truncate excerpts
                

Multi-Head Attention Aggregation:

For layer L, head h:
  A^{(L,h)} = softmax(QK^T / √d_k)

Attention to precedent p:
  α_p = (1/H) ∑_{h=1}^{H} ∑_{t∈T_p} A^{(L,h)}_{cls,t}

Where:
  H = 32 attention heads
  T_p = token positions for precedent p
  cls = classification token (last)
  L = 32 (final layer)
                

ECE (Naeini et al., 2015):

ECE = ∑_{m=1}^{M} (|B_m|/n) · |acc(B_m) - conf(B_m)|

Where:
  M = 15 equal-width bins
  B_m = samples in confidence bin m
  acc(B_m) = accuracy in bin m
  conf(B_m) = mean confidence in bin m

Interpretation:
  ECE = 0.00: perfect calibration
  ECE < 0.05: well-calibrated
  ECE > 0.15: poorly calibrated
                

Post-hoc calibration (Guo et al., 2017):

p_calibrated = softmax(z / T)

Where:
  z = logits from model
  T = temperature parameter

Optimization:
  T* = argmin_T NLL(y, softmax(z/T))

Effects:
  T > 1: soften predictions (less confident)
  T < 1: sharpen predictions (more confident)
  T = 1: no change
                

McNemar's Test (Dietterich, 1998):

Contingency table for paired predictions:

              Model B
            Correct  Wrong
Model A  ┌─────────┬─────────┐
Correct  │    a    │    b    │
Wrong    │    c    │    d    │
         └─────────┴─────────┘

Test statistic:
  χ² = (|b - c| - 1)² / (b + c)

H₀: P(b) = P(c) (models equivalent)
H₁: P(b) ≠ P(c) (models differ)

Reject H₀ if χ² > 3.84 (α = 0.05)
                

BCa Bootstrap (Efron & Tibshirani, 1993):

for b in 1..B:  # B = 10,000
    D_b = sample(D_test, n, replace=True)
    θ_b = metric(model, D_b)

Percentile CI:
  CI_95% = [θ_{(0.025·B)}, θ_{(0.975·B)}]

BCa Correction:
  z₀ = Φ⁻¹(#{θ_b < θ̂} / B)
  a = ∑(θ̄ - θ_i)³ / (6·(∑(θ̄ - θ_i)²)^1.5)

Adjusted percentiles account for bias
and skewness in bootstrap distribution.