# Resolver Operations Reference Detailed pseudocode for each resolver operation. These are language-agnostic specifications; any implementation must produce equivalent results. --- ## Op 1: ValidateRefs ``` procedure ValidateRefs(world_state): warnings = [] for each constraint C in world_state.constraints: for each ref in C.argument_refs: if ref not in world_state.objects: warnings.append(f"Dangling ref {ref} in constraint {C.constraint_id}") mark C.status = suspended for each facet F in world_state.facets: if F.object_ref not in world_state.objects: warnings.append(f"Dangling object_ref {F.object_ref} in facet {F.facet_id}") return warnings ``` --- ## Op 2: ApplyHardConstraints ``` procedure ApplyHardConstraints(world_state): hard_constraints = [C for C in world_state.constraints where C.strength = "hard" and C.status = "unresolved"] for each C in hard_constraints: conflicts = [C2 for C2 in hard_constraints where C2 ≠ C and C2.status = "unresolved" and DirectlyContradicts(C, C2)] if conflicts: for C2 in conflicts: mark C.status = "contradicted" mark C2.status = "contradicted" add ContradictionRecord(constraint_refs=[C.id, C2.id]) else: mark C.status = "resolved" log ResolutionEntry(operation="apply_hard", affected_refs=C.argument_refs, result="resolved") ``` ``` function DirectlyContradicts(C1, C2): -- Same type, same arguments, opposite polarity if C1.constraint_type = C2.constraint_type and C1.argument_refs = C2.argument_refs and C1.polarity ≠ C2.polarity: return true -- Known incompatible pairs if {C1.constraint_type, C2.constraint_type} = {"before", "after"} and C1.argument_refs = reverse(C2.argument_refs): return true return false ``` --- ## Op 3: ResolveArithmetic ``` procedure ResolveArithmetic(world_state): arithmetic_types = { "quantity_difference": (result, minuend, subtrahend) -> minuend - subtrahend, "quantity_sum": (result, *addends) -> sum(addends), "quantity_product": (result, *factors) -> product(factors), "quantity_quotient": (result, dividend, divisor) -> dividend / divisor, "quantity_equals": (result, value) -> value } for each C in world_state.constraints where C.constraint_type in arithmetic_types: if C.status ≠ "unresolved": continue arg_objects = [world_state.objects[ref] for ref in C.argument_refs] result_obj = arg_objects[0] operands = arg_objects[1:] operand_values = [GetQuantityValue(O) for O in operands] if all(V is not None and is_exact(V) for V in operand_values): fn = arithmetic_types[C.constraint_type] computed = fn(*operand_values) SetQuantityValue(result_obj, computed) result_facet = GetOrCreateQuantityFacet(result_obj) result_facet.value = computed result_facet.is_exact = true result_facet.derived_from_refs = [O.object_id for O in operands] mark C.status = "resolved" log ResolutionEntry(operation="resolve_arithmetic", affected_refs=[result_obj.object_id], result="resolved", note=f"computed {computed}") else: -- operands not yet resolved; defer pass ``` --- ## Op 4: PropagateTruth ``` procedure PropagateTruth(world_state): implies_constraints = [C for C in world_state.constraints where C.constraint_type = "implies" and C.status = "resolved"] changed = true while changed: changed = false for each C in implies_constraints: antecedent_id, consequent_id = C.argument_refs antecedent = world_state.objects[antecedent_id] consequent = world_state.objects[consequent_id] if GetTruthStatus(antecedent) = "true": if GetTruthStatus(consequent) ≠ "true": SetTruthStatus(consequent, "true") log ResolutionEntry(operation="propagate_truth", affected_refs=[consequent_id], result="resolved", note=f"derived from {antecedent_id} via implies constraint {C.id}") changed = true if GetTruthStatus(antecedent) = "false": -- modus tollens: do not propagate without explicit negation constraint pass ``` --- ## Op 5: ResolveCoreference ``` procedure ResolveCoreference(world_state): same_entity_constraints = [C for C in world_state.constraints where C.constraint_type = "same_entity" and C.status = "resolved"] for each C in same_entity_constraints: id_a, id_b = C.argument_refs obj_a = world_state.objects[id_a] obj_b = world_state.objects[id_b] if obj_a.confidence >= obj_b.confidence: survivor = obj_a deprecated = obj_b else: survivor = obj_b deprecated = obj_a -- Transfer all refs from deprecated to survivor for ref in deprecated.facet_refs: world_state.facets[ref].object_ref = survivor.object_id survivor.facet_refs.append(ref) for ref in deprecated.constraint_refs: constraint = world_state.constraints[ref] replace deprecated.object_id with survivor.object_id in constraint.argument_refs survivor.constraint_refs.append(ref) -- Transfer aliases survivor.aliases += deprecated.aliases + [deprecated.canonical_label] deprecated.status = "merged" deprecated.merged_into = survivor.object_id log ResolutionEntry(operation="merge_coreference", affected_refs=[survivor.object_id, deprecated.object_id], result="merged", note=f"merged {deprecated.object_id} into {survivor.object_id}") ``` --- ## Op 6: DetectSoftContradictions ``` procedure DetectSoftContradictions(world_state): soft_constraints = [C for C in world_state.constraints where C.strength in {"soft", "defeasible"} and C.status = "unresolved"] for each C in soft_constraints: -- Check against hard resolved constraints first hard_conflicts = [C2 for C2 in world_state.constraints where C2.strength = "hard" and C2.status = "resolved" and DirectlyContradicts(C, C2)] if hard_conflicts: mark C.status = "suspended" log ResolutionEntry(operation="suspend_soft", affected_refs=C.argument_refs, result="suspended", note=f"overridden by hard constraint {hard_conflicts[0].id}") continue -- Check against other soft constraints soft_conflicts = [C2 for C2 in soft_constraints where C2 ≠ C and DirectlyContradicts(C, C2)] if soft_conflicts: C.confidence *= 0.7 for C2 in soft_conflicts: C2.confidence *= 0.7 add ContradictionRecord(constraint_refs=[C.id] + [C2.id for C2 in soft_conflicts], description="Soft constraint conflict, confidence reduced") else: mark C.status = "resolved" ``` --- ## Op 7: PropagateConfidence ``` procedure PropagateConfidence(world_state): REINFORCE_DELTA = 0.05 CONTRADICT_DELTA = 0.10 MAX_DELTA = 0.15 for each constraint C where C.status = "resolved": for ref in C.argument_refs: obj = world_state.objects.get(ref) if obj: delta = min(REINFORCE_DELTA * C.confidence, MAX_DELTA) obj.confidence = min(1.0, obj.confidence + delta) for each constraint C where C.status = "contradicted": for ref in C.argument_refs: obj = world_state.objects.get(ref) if obj: delta = min(CONTRADICT_DELTA, MAX_DELTA) obj.confidence = max(0.0, obj.confidence - delta) ``` --- ## Op 8: FinalizeState ``` procedure FinalizeState(world_state): -- Promote high-confidence proposed objects for each obj in world_state.objects where obj.status = "proposed": resolved_constraints = [C for C in world_state.constraints where obj.object_id in C.argument_refs and C.status = "resolved"] if obj.confidence >= 0.75 and len(resolved_constraints) >= 1: obj.status = "active" log ResolutionEntry(operation="promote_object", affected_refs=[obj.object_id], result="resolved") world_state.stage = "resolved" ```