Summarising reliably — grounding against the fabricated authority

# You don't need to change the code — just edit the box above and press Run.
# (It runs on its own the first time, so you can see what it does straight away.)

# `sources` is a pre-loaded set of SOURCE passages — the retrieved material a summary is
# allowed to rely on (the output of Lesson 2). `claim` is the sentence in the box above: one
# statement the summary makes. The discipline of this lesson, in one line: EVERY claim in a
# summary must trace back to one of these sources. Anything that doesn't is not "probably fine" —
# it is the exact red flag that gets practitioners sanctioned, and it must be FLAGGED, not smoothed.

# A claim is built of words; so is each source. The most honest cheap check we can do is ask:
# do the claim's distinctive words actually appear together in a source passage? Strip out the
# common filler ("the", "of", "a"...) so we test the words that carry the legal content —
# the period, the figure, the holding, the case name — not the grammar around them.
STOPWORDS = {"the", "a", "an", "of", "for", "is", "are", "to", "in", "on", "and",
             "or", "that", "this", "with", "by", "be", "as", "it", "no", "not"}

def key_terms(text):
    # lower-case, keep only the content words (length > 2, not a stopword)
    words = "".join(c.lower() if c.isalnum() or c.isspace() else " " for c in text).split()
    return {w for w in words if len(w) > 2 and w not in STOPWORDS}

claim_terms = key_terms(claim)

# Walk every source and measure how many of the claim's key terms it contains. We treat the
# claim as SUPPORTED by a source only if MOST of its key terms (>= 60%) co-occur there — a
# single shared word ("negligence" appearing somewhere) is not support, it is coincidence.
best_source = None
best_overlap = 0.0
for name, passage in sources.items():
    passage_terms = key_terms(passage)
    shared = claim_terms & passage_terms
    overlap = len(shared) / max(len(claim_terms), 1)   # fraction of the claim that is grounded
    if overlap > best_overlap:
        best_overlap = overlap
        best_source = name

print("claim:", claim)
print("checked against", len(sources), "source passages")
print("-" * 60)

if best_overlap >= 0.6:
    # The claim's content is actually present in a source. We can cite that source.
    print("SUPPORTED  (" + str(round(best_overlap * 100)) + "% of the claim's key terms found)")
    print("  -> grounded in source:", best_source)
    print("  -> safe to keep in the summary, cited to that source.")
else:
    # The claim's content is NOT in any source. In a real workflow this is where a confident
    # holding or — worse — a case citation that exists nowhere in the file ("Harrington v
    # Bellwether") gets caught. A claim with no source is a POSSIBLE FABRICATED AUTHORITY.
    print("UNSUPPORTED  (best match only " + str(round(best_overlap * 100)) + "% — below the 60% bar)")
    print("  -> NOT found in any source passage.")
    print("  -> FLAG: possible FABRICATED AUTHORITY. Do NOT cite this. Verify against the")
    print("     primary record before it goes anywhere near a court or a client.")

# Honest about the tool: real grounding is much harder than counting shared words — a paraphrase
# that uses none of the source's vocabulary can still be perfectly faithful, and two passages can
# share words yet mean opposite things. This keyword check will miss some of that. But the
# DISCIPLINE it enforces — trace EVERY claim to a source, and flag anything you can't — is the
# transferable skill, and it is the one you bank as your first saved skill: the Grounding check.

claim: The limitation period for a negligence claim is three years (Harrington v Bellwether [2019] EWHC 244).
checked against 5 source passages
------------------------------------------------------------
UNSUPPORTED  (best match only 18% — below the 60% bar)
  -> NOT found in any source passage.
  -> FLAG: possible FABRICATED AUTHORITY. Do NOT cite this. Verify against the
     primary record before it goes anywhere near a court or a client.