tomevault-io 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 # Value in [0,1]
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)
# Alternative composition: minimum (pessimistic)
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(self, k)
for k in weights
)
def pareto_dominates(self, other: 'QualityVector') -> bool:
"""Check Pareto dominance (better in all dimensions)."""
dominated = all(
getattr(self, f) >= getattr(other, f)
for f in ['clarity', 'specificity', 'completeness', 'coherence', 'relevance']
)
strictly_better = any(
getattr(self, f) > getattr(other, f)
for f in ['clarity', 'specificity', 'completeness', 'coherence', 'relevance']
)
return dominated and strictly_better
def as_array(self) -> np.ndarray:
return np.array([
self.clarity, self.specificity, self.completeness,
self.coherence, self.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] = {} # id → prompt content
self.homs: Dict[Tuple[str, str], float] = {} # (src, tgt) → quality
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: List[str]) -> float:
"""
Compute composed quality along a path.
Uses multiplicative composition (quality degradation).
"""
if len(path) < 2:
return 1.0
quality = 1.0
for i in range(len(path) - 1):
edge_quality = self.homs.get((path[i], path[i+1]), 0.0)
quality *= edge_quality
return quality
def best_path(self, source: str, target: str) -> Tuple[List[str], float]:
"""Find highest-quality path between objects."""
from heapq import heappush, heappop
# Dijkstra variant maximizing quality
best = {source: (1.0, [source])}
queue = [(-1.0, source)] # Negative for max-heap behavior
while queue:
neg_quality, current = heappop(queue)
quality = -neg_quality
if current == target:
return best[current][1], best[current][0]
for (src, tgt), edge_q in self.homs.items():
if src == current:
new_quality = quality * edge_q
if tgt not in best or new_quality > best[tgt][0]:
best[tgt] = (new_quality, best[current][1] + [tgt])
heappush(queue, (-new_quality, tgt))
return [], 0.0
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
# Generate improvement
improved = improve(current, quality)
new_quality = self.evaluate(improved)
# Accept if quality improves
if new_quality.aggregate() > quality.aggregate():
current = improved
quality = new_quality
self.history.append((current, quality))
else:
# Try again with different parameters
continue
return current, quality
def pareto_frontier(self) -> List[Tuple[str, QualityVector]]:
"""Extract Pareto-optimal prompts from history."""
frontier = []
for prompt, quality in self.history:
dominated = any(
other_q.pareto_dominates(quality)
for _, other_q in self.history
)
if not dominated:
frontier.append((prompt, quality))
return 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 < 0.8: weak_dimensions.append("completeness")
if quality.coherence < 0.8: weak_dimensions.append("coherence")
if quality.relevance < 0.8: weak_dimensions.append("relevance")
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system", "content": f"""
Improve this prompt focusing on: {', '.join(weak_dimensions)}.
Current scores: clarity={quality.clarity:.2f},
specificity={quality.specificity:.2f},
completeness={quality.completeness:.2f},
coherence={quality.coherence:.2f},
relevance={quality.relevance:.2f}
Return only the improved prompt.
"""},
{"role": "user", "content": prompt}
]
)
return response.choices[0].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 preservation ratio
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
Converted and distributed by TomeVault — claim your Tome and manage your conversions.