| name | quality-enriched-prompting |
| description | [0,1]-enriched category implementation for gradient-based prompt quality optimization. Use when implementing quality-aware prompt systems, building enriched categorical structures for prompt evaluation, creating continuous optimization over prompt spaces, or applying Bradley's enriched category theory to language model quality scoring. |
Quality-Enriched Prompting
Implementation of [0,1]-enriched categories for continuous prompt quality optimization.
Enriched Category Foundations
In a [0,1]-enriched category (following Bradley's framework):
- Objects: Prompts, responses, contexts
- Hom-objects: Quality scores in [0,1] instead of sets
- Composition: Quality degradation via multiplication or minimum
- Identity: Perfect quality (1.0)
Basic Enriched Structure
from dataclasses import dataclass
from typing import Callable, Dict, Tuple, List
import numpy as np
@dataclass
class EnrichedHom:
"""
Morphism in [0,1]-enriched category.
Hom(A,B) ∈ [0,1] represents quality of transformation A → B.
"""
source: str
target: str
quality: float
def __post_init__(self):
assert 0 <= self.quality <= 1, "Quality must be in [0,1]"
def compose(self, other: 'EnrichedHom') -> 'EnrichedHom':
"""
Composition in enriched category.
Quality degrades: Hom(A,C) = Hom(A,B) ⊗ Hom(B,C)
Using multiplication as monoidal product.
"""
assert self.target == other.source, "Cannot compose non-adjacent morphisms"
return EnrichedHom(
source=self.source,
target=other.target,
quality=self.quality * other.quality
)
@staticmethod
def identity(obj: str) -> 'EnrichedHom':
"""Identity morphism with perfect quality."""
return EnrichedHom(source=obj, target=obj, quality=1.0)
def min_compose(h1: EnrichedHom, h2: EnrichedHom) -> EnrichedHom:
"""Composition using minimum (worst-case quality)."""
return EnrichedHom(
source=h1.source,
target=h2.target,
quality=min(h1.quality, h2.quality)
)
Quality Metrics
@dataclass
class QualityVector:
"""
Multi-dimensional quality as product of enriched categories.
Quality is a vector in [0,1]^n for n quality dimensions.
"""
clarity: float
specificity: float
completeness: float
coherence: float
relevance: float
def __post_init__(self):
for field in ['clarity', 'specificity', 'completeness', 'coherence', 'relevance']:
val = getattr(self, field)
assert 0 <= val <= 1, f"{field} must be in [0,1]"
def aggregate(self, weights: Dict[str, float] = None) -> float:
"""Weighted aggregation to scalar quality."""
weights = weights or {
'clarity': 0.2, 'specificity': 0.2, 'completeness': 0.2,
'coherence': 0.2, 'relevance': 0.2
}
return sum(
weights[k] * getattr(, k)
k weights
)
() -> :
dominated = (
(, f) >= (other, f)
f [, , , , ]
)
strictly_better = (
(, f) > (other, f)
f [, , , , ]
)
dominated strictly_better
() -> np.ndarray:
np.array([
.clarity, .specificity, .completeness,
.coherence, .relevance
])
Enriched Prompt Category
class EnrichedPromptCategory:
"""
Category of prompts enriched over [0,1].
Objects: Prompts
Hom(P1, P2): Quality of transformation from P1 to P2
"""
def __init__(self):
self.objects: Dict[str, str] = {}
self.homs: Dict[Tuple[str, str], float] = {}
def add_prompt(self, id: str, content: str):
"""Add prompt as object."""
self.objects[id] = content
def add_morphism(self, source: str, target: str, quality: float):
"""Add quality-enriched morphism."""
assert source in self.objects, f"Unknown source: {source}"
assert target in self.objects, f"Unknown target: {target}"
self.homs[(source, target)] = quality
def compose(self, path: []) -> :
(path) < :
quality =
i ((path) - ):
edge_quality = .homs.get((path[i], path[i+]), )
quality *= edge_quality
quality
() -> [[], ]:
heapq heappush, heappop
best = {source: (, [source])}
queue = [(-, source)]
queue:
neg_quality, current = heappop(queue)
quality = -neg_quality
current == target:
best[current][], best[current][]
(src, tgt), edge_q .homs.items():
src == current:
new_quality = quality * edge_q
tgt best new_quality > best[tgt][]:
best[tgt] = (new_quality, best[current][] + [tgt])
heappush(queue, (-new_quality, tgt))
[],
Quality-Based Optimization
class QualityOptimizer:
"""
Gradient-based optimization in enriched category.
Optimizes prompts to maximize quality morphisms.
"""
def __init__(self, evaluate: Callable[[str], QualityVector]):
self.evaluate = evaluate
self.history: List[Tuple[str, QualityVector]] = []
def optimize(
self,
initial_prompt: str,
improve: Callable[[str, QualityVector], str],
threshold: float = 0.9,
max_iterations: int = 10
) -> Tuple[str, QualityVector]:
"""
Iterative quality optimization.
Follows gradient in quality space until threshold reached.
"""
current = initial_prompt
quality = self.evaluate(current)
self.history.append((current, quality))
for _ in range(max_iterations):
if quality.aggregate() >= threshold:
break
improved = improve(current, quality)
new_quality = self.evaluate(improved)
if new_quality.aggregate() > quality.aggregate():
current = improved
quality = new_quality
self.history.append((current, quality))
:
current, quality
() -> [[, QualityVector]]:
frontier = []
prompt, quality .history:
dominated = (
other_q.pareto_dominates(quality)
_, other_q .history
)
dominated:
frontier.append((prompt, quality))
frontier
LLM-Based Quality Evaluation
from openai import OpenAI
client = OpenAI()
def llm_quality_eval(prompt: str, context: str = "") -> QualityVector:
"""
Evaluate prompt quality using LLM.
Returns quality vector in [0,1]^5.
"""
response = client.chat.completions.create(
model="gpt-4o",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": """
Evaluate the prompt quality on these dimensions (0.0-1.0):
- clarity: How clear and unambiguous?
- specificity: How specific and detailed?
- completeness: Does it cover all aspects?
- coherence: Is it logically structured?
- relevance: Is it relevant to the task?
Return JSON with these 5 fields.
"""},
{"role": "user", "content": f"Context: {context}\n\nPrompt: {prompt}"}
]
)
import json
data = json.loads(response.choices[0].message.content)
return QualityVector(**data)
def llm_quality_improve(prompt: str, quality: QualityVector) -> str:
"""
Use LLM to improve prompt based on quality assessment.
"""
weak_dimensions = []
if quality.clarity < 0.8: weak_dimensions.append("clarity")
if quality.specificity < 0.8: weak_dimensions.append("specificity")
if quality.completeness < : weak_dimensions.append()
quality.coherence < : weak_dimensions.append()
quality.relevance < : weak_dimensions.append()
response = client.chat.completions.create(
model=,
messages=[
{: , : },
{: , : prompt}
]
)
response.choices[].message.content.strip()
Enriched Functor
class QualityFunctor:
"""
Functor F: C → [0,1]-Cat preserving enriched structure.
Maps objects to quality assessments and morphisms to quality degradations.
"""
def __init__(self, eval_fn: Callable[[str], float]):
self.eval_fn = eval_fn
def map_object(self, prompt: str) -> float:
"""Map prompt to quality score."""
return self.eval_fn(prompt)
def map_morphism(self, transform: Callable[[str], str], source: str) -> EnrichedHom:
"""Map transformation to quality morphism."""
source_quality = self.map_object(source)
target = transform(source)
target_quality = self.map_object(target)
quality_ratio = target_quality / source_quality if source_quality > 0 else 0
return EnrichedHom(
source=source,
target=target,
quality=min(1.0, quality_ratio)
)
Categorical Guarantees
Quality-enriched prompting ensures:
- Enriched Composition: Quality degradation follows monoidal laws
- Transitivity: Composed quality ≤ individual qualities
- Reflexivity: Identity has perfect quality (1.0)
- Pareto Optimality: Frontier prompts are non-dominated
- Monotonic Improvement: Optimization never decreases aggregate quality
