Apply steep penalty scoring across 140 poetic forms

Mass audit of all form verify() methods to fix lenient scoring that
allowed models to get partial credit with many violations.

Pattern applied (same as Lipogram fix):
- 0 violations: 1.0 (perfect)
- 1 violation: 0.5
- 2 violations: 0.25
- 3+ violations: 0.05

Files modified:
- constrained.py: Abecedarian, Mesostic, Anaphora, PalindromePoem
- novel.py: VowelPilgrimage, QuestionQuest, WhisperPoem, etc.
- mathematical.py: FibonacciVerse, GoldenRatioVerse, etc.
- japanese.py, haiku.py: Haiku, Senryu, Tanka, Katauta, Sedoka
- rondeau.py, rondel.py, ballade.py, medieval.py: French forms
- terza_rima.py, ghazal.py: TerzaRima, Ghazal
- pantoum.py: Pantoum repetition scoring
- clerihew.py, epigram.py, blues.py: Short/folk forms
- world.py: Naani, Tanaga, regional forms
- constraints/relational.py: EndWordPattern, Refrain

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: darrenangle

.beads/issues.jsonl

@@ -260,7 +260,18 @@ def verify(self, poem: str | PoemStructure) -> VerificationResult:
             )
             scores.append(score)
 
-        overall_score = sum(scores) / len(scores) if scores else 0.0
+        # Calculate overall score with steep exponential penalty
+        # 0 violations: 1.0, 1 violation: 0.5, 2 violations: 0.25, 3+ violations: 0.05
+        num_violations = sum(1 for r in rubric if not r.passed)
+        if num_violations == 0:
+            overall_score = 1.0
+        elif num_violations == 1:
+            overall_score = 0.5
+        elif num_violations == 2:
+            overall_score = 0.25
+        else:
+            overall_score = 0.05
+
         overall_passed = all(r.passed for r in rubric)
 
         return VerificationResult(
@@ -415,7 +426,18 @@ def verify(self, poem: str | PoemStructure) -> VerificationResult:
             if stanza_scores:
                 scores.append(sum(stanza_scores) / len(stanza_scores))
 
-        overall_score = sum(scores) / len(scores) if scores else 0.0
+        # Calculate overall score with steep exponential penalty
+        # 0 violations: 1.0, 1 violation: 0.5, 2 violations: 0.25, 3+ violations: 0.05
+        num_violations = sum(1 for r in rubric if not r.passed)
+        if num_violations == 0:
+            overall_score = 1.0
+        elif num_violations == 1:
+            overall_score = 0.5
+        elif num_violations == 2:
+            overall_score = 0.25
+        else:
+            overall_score = 0.05
+
         overall_passed = all(r.passed for r in rubric)
 
         return VerificationResult(

src/abide/constraints/relational.py

@@ -234,7 +234,19 @@ def verify(self, poem: str | PoemStructure) -> VerificationResult:
             )
             scores.append(avg_c)
 
-        overall_score = sum(scores) / len(scores) if scores else 0.0
+        # Count violations (rubric items that failed)
+        violations = sum(1 for r in rubric if not r.passed)
+
+        # Steep penalty scoring: 0 violations = 1.0, 1 = 0.5, 2 = 0.25, 3+ = 0.05
+        if violations == 0:
+            overall_score = 1.0
+        elif violations == 1:
+            overall_score = 0.5
+        elif violations == 2:
+            overall_score = 0.25
+        else:
+            overall_score = 0.05
+
         overall_passed = all(r.passed for r in rubric) if self.strict else overall_score >= 0.6
 
         return VerificationResult(

src/abide/forms/ballade.py

@@ -164,10 +164,27 @@ def verify(self, poem: str | PoemStructure) -> VerificationResult:
                 )
                 rhyme_scores.append(avg_rhyme)
 
-        if repetition_scores:
-            scores.append(sum(repetition_scores) / len(repetition_scores))
-        if rhyme_scores:
-            scores.append(sum(rhyme_scores) / len(rhyme_scores))
+        # Apply steep penalty based on violation count
+        # Count violations in repetition and rhyme
+        repetition_violations = sum(
+            1 for score in repetition_scores if score < self.repetition_threshold
+        )
+        rhyme_violations = sum(1 for score in rhyme_scores if score < self.rhyme_threshold)
+        total_violations = repetition_violations + rhyme_violations
+
+        # Steep penalty: 0=1.0, 1=0.5, 2=0.25, 3+=0.05
+        if total_violations == 0:
+            pattern_score = 1.0
+        elif total_violations == 1:
+            pattern_score = 0.5
+        elif total_violations == 2:
+            pattern_score = 0.25
+        else:
+            pattern_score = 0.05
+
+        # Add pattern score to overall scores
+        if repetition_scores or rhyme_scores:
+            scores.append(pattern_score)
 
         overall_score = sum(scores) / len(scores) if scores else 0.0
         overall_passed = all(r.passed for r in rubric) if self.strict else overall_score >= 0.5

src/abide/forms/blues.py

@@ -66,7 +66,7 @@ def verify(self, poem: str | PoemStructure) -> VerificationResult:
         structure = self._ensure_structure(poem)
 
         rubric: list[RubricItem] = []
-        scores: list[float] = []
+        violations = 0
 
         # Check line count (exactly 4)
         if structure.line_count == 4:
@@ -79,22 +79,22 @@ def verify(self, poem: str | PoemStructure) -> VerificationResult:
                     passed=True,
                 )
             )
-            scores.append(1.0)
         else:
             rubric.append(
                 RubricItem(
                     criterion="Line count",
                     expected="4",
                     actual=str(structure.line_count),
-                    score=0.0 if structure.line_count > 6 else 0.5,
+                    score=0.0,
                     passed=False,
                 )
             )
-            scores.append(0.0 if structure.line_count > 6 else 0.5)
+            violations += 1
 
         if structure.line_count < 4:
+            # Can't verify further constraints without enough lines
             return VerificationResult(
-                score=0.0,
+                score=0.05,
                 passed=False,
                 rubric=rubric,
                 constraint_name=self.name,
@@ -115,18 +115,17 @@ def verify(self, poem: str | PoemStructure) -> VerificationResult:
                     passed=True,
                 )
             )
-            scores.append(1.0)
         else:
             rubric.append(
                 RubricItem(
                     criterion="First line contains name",
                     expected="capitalized proper noun",
                     actual=first_line,
-                    score=0.3,
+                    score=0.0,
                     passed=False,
                 )
             )
-            scores.append(0.3)
+            violations += 1
 
         # Check AABB rhyme scheme
         end_words = [self._get_end_word(line) for line in structure.lines[:4]]
@@ -145,7 +144,8 @@ def verify(self, poem: str | PoemStructure) -> VerificationResult:
                     passed=passed_12,
                 )
             )
-            scores.append(rhyme_12)
+            if not passed_12:
+                violations += 1
 
         # Second couplet (lines 3-4)
         if len(end_words) >= 4:
@@ -161,10 +161,20 @@ def verify(self, poem: str | PoemStructure) -> VerificationResult:
                     passed=passed_34,
                 )
             )
-            scores.append(rhyme_34)
-
-        overall_score = sum(scores) / len(scores) if scores else 0.0
-        overall_passed = all(r.passed for r in rubric) if self.strict else overall_score >= 0.5
+            if not passed_34:
+                violations += 1
+
+        # Steep penalty scoring: 0 violations = 1.0, 1 = 0.5, 2 = 0.25, 3+ = 0.05
+        if violations == 0:
+            overall_score = 1.0
+        elif violations == 1:
+            overall_score = 0.5
+        elif violations == 2:
+            overall_score = 0.25
+        else:  # 3 or more violations
+            overall_score = 0.05
+
+        overall_passed = violations == 0 if self.strict else overall_score >= 0.5
 
         return VerificationResult(
             score=overall_score,

src/abide/forms/clerihew.py

@@ -83,9 +83,17 @@ def verify(self, poem: str | PoemStructure) -> VerificationResult:
             else:
                 details.append(f"Line {i + 1}: ✗ empty line")
 
-        # Quadratic penalty for stricter GRPO training
-        linear_letter = matches / max(1, min(len(self.letters), len(structure.lines)))
-        letter_score = linear_letter**2
+        # Steep penalties for GRPO training: 0 violations = 1.0, 1-2 = partial, 3+ = near zero
+        expected_matches = min(len(self.letters), len(structure.lines))
+        violations = expected_matches - matches
+        if violations == 0:
+            letter_score = 1.0
+        elif violations == 1:
+            letter_score = 0.5
+        elif violations == 2:
+            letter_score = 0.25
+        else:
+            letter_score = 0.05
 
         # Combine scores
         score = line_result.score * 0.1 + letter_score * 0.9
@@ -335,9 +343,17 @@ def verify(self, poem: str | PoemStructure) -> VerificationResult:
             else:
                 details.append(f"Line {i + 1}: ✗ missing '{target_letter}' in middle")
 
-        # Quadratic penalty for stricter GRPO training
-        linear_mesostic = matches / max(1, min(len(self.target_word), len(structure.lines)))
-        mesostic_score = linear_mesostic**2
+        # Steep penalties for GRPO training: 0 violations = 1.0, 1-2 = partial, 3+ = near zero
+        expected_matches = min(len(self.target_word), len(structure.lines))
+        violations = expected_matches - matches
+        if violations == 0:
+            mesostic_score = 1.0
+        elif violations == 1:
+            mesostic_score = 0.5
+        elif violations == 2:
+            mesostic_score = 0.25
+        else:
+            mesostic_score = 0.05
 
         # Combine scores
         score = line_result.score * 0.1 + mesostic_score * 0.9
@@ -440,12 +456,17 @@ def verify(self, poem: str | PoemStructure) -> VerificationResult:
             opening_counts = Counter(openings)
             detected_phrase, repeats = opening_counts.most_common(1)[0]
 
-        # Score based on repeats - quadratic penalty for stricter GRPO training
+        # Score based on repeats - steep penalties for GRPO training
         if repeats >= self.min_repeats:
             anaphora_score = 1.0
         else:
-            linear_anaphora = repeats / self.min_repeats
-            anaphora_score = linear_anaphora**2
+            violations = self.min_repeats - repeats
+            if violations == 1:
+                anaphora_score = 0.5
+            elif violations == 2:
+                anaphora_score = 0.25
+            else:
+                anaphora_score = 0.05
 
         # Combine scores
         score = line_result.score * 0.1 + anaphora_score * 0.9
@@ -522,9 +543,16 @@ def verify(self, poem: str | PoemStructure) -> VerificationResult:
             palindrome_lines = sum(
                 1 for line in structure.lines if self._is_letter_palindrome(line)
             )
-            # Quadratic penalty for stricter GRPO training
-            linear_palindrome = palindrome_lines / max(1, len(structure.lines))
-            palindrome_score = linear_palindrome**2
+            # Steep penalties for GRPO training: 0 violations = 1.0, 1-2 = partial, 3+ = near zero
+            violations = len(structure.lines) - palindrome_lines
+            if violations == 0:
+                palindrome_score = 1.0
+            elif violations == 1:
+                palindrome_score = 0.5
+            elif violations == 2:
+                palindrome_score = 0.25
+            else:
+                palindrome_score = 0.05
         else:
             # Word level: first half of lines mirror second half
             lines = [line.strip().lower() for line in structure.lines]
@@ -541,9 +569,16 @@ def verify(self, poem: str | PoemStructure) -> VerificationResult:
                     if lines[i] == lines[n - 1 - i]:
                         matches += 1
 
-                # Quadratic penalty for stricter GRPO training
-                linear_palindrome = matches / max(1, comparisons)
-                palindrome_score = linear_palindrome**2
+                # Steep penalties for GRPO training: 0 violations = 1.0, 1-2 = partial, 3+ = near zero
+                violations = comparisons - matches
+                if violations == 0:
+                    palindrome_score = 1.0
+                elif violations == 1:
+                    palindrome_score = 0.5
+                elif violations == 2:
+                    palindrome_score = 0.25
+                else:
+                    palindrome_score = 0.05
 
         # Combine scores
         score = line_result.score * 0.1 + palindrome_score * 0.9

src/abide/forms/constrained.py

@@ -70,26 +70,43 @@ def __init__(
     def verify(self, poem: str | PoemStructure) -> VerificationResult:
         structure = self._ensure_structure(poem)
 
-        # Check line count - quadratic penalty for stricter GRPO training
+        # Check line count - steep penalties for strict GRPO training
+        # Perfect = 1.0, 1 violation = 0.5, 2 violations = 0.25, 3+ = 0.05
         if structure.line_count < self.min_lines:
-            linear_score = structure.line_count / self.min_lines
+            violations = self.min_lines - structure.line_count
+            if violations == 1:
+                score = 0.5
+            elif violations == 2:
+                score = 0.25
+            else:
+                score = 0.05
             return VerificationResult(
-                score=linear_score**2,
+                score=score,
                 passed=False,
                 rubric=[],
                 constraint_name=self.name,
                 constraint_type=self.constraint_type,
-                details={"error": f"Too few lines (minimum {self.min_lines})"},
+                details={
+                    "error": f"Too few lines (minimum {self.min_lines}, got {structure.line_count})"
+                },
             )
         if structure.line_count > self.max_lines:
-            linear_score = self.max_lines / structure.line_count
+            violations = structure.line_count - self.max_lines
+            if violations == 1:
+                score = 0.5
+            elif violations == 2:
+                score = 0.25
+            else:
+                score = 0.05
             return VerificationResult(
-                score=linear_score**2,
+                score=score,
                 passed=False,
                 rubric=[],
                 constraint_name=self.name,
                 constraint_type=self.constraint_type,
-                details={"error": f"Too many lines (maximum {self.max_lines})"},
+                details={
+                    "error": f"Too many lines (maximum {self.max_lines}, got {structure.line_count})"
+                },
             )
 
         # For 2-line epigrams, check couplet rhyme