🔗 Graph-of-Logic

# Graph-of-Logic confidence propagation
AND operator: conf(A AND B) = min(conf(A), conf(B))
  Example: min(0.9, 0.8) = 0.8 (chain is as weak as weakest link)

OR operator: conf(A OR B) = max(conf(A), conf(B))
  Example: max(0.9, 0.8) = 0.9 (at least one must be true)

NOT operator: conf(NOT A) = 1 - conf(A)
  Example: 1 - 0.7 = 0.3 (if A is 70% likely, NOT A is 30% likely)

IMPLIES: conf(A IMPLIES B) = (1 - conf(A)) + (conf(A) * conf(B))
  Example: if fever (0.9) implies sepsis, then:
           conf = (1 - 0.9) + (0.9 * 0.8) = 0.1 + 0.72 = 0.82
            

# Graph-of-Logic implementation for sepsis diagnosis
from anthropic import Anthropic
import json

client = Anthropic()

class GoLNode:
    def __init__(self, claim, node_type="claim"):
        self.claim = claim
        self.node_type = node_type  # "claim", "evidence"
        self.confidence = 0.0
        self.children = []  # Evidence nodes supporting this claim
        self.operator = None  # AND, OR, NOT

def gol_medical_diagnosis(patient_symptoms):
    """Diagnose using Graph-of-Logic reasoning"""

    # Step 1: Extract symptoms and evidence
    prompt = f"""
Patient presentation: {patient_symptoms}

Identify EVIDENCE NODES (factual observations):
- Format: "Observation: [description], confidence: 0.X"
- Example: "Fever: 39.5C, confidence: 0.95"

List all evidence nodes with confidence scores."""

    evidence_response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=400,
        messages=[{"role": "user", "content": prompt}]
    )
    evidence_nodes = evidence_response.content[0].text

    # Step 2: Build claim hierarchy
    claim_prompt = f"""
Given these evidence nodes:
{evidence_nodes}

What are the possible DIAGNOSES (claim nodes)?
For each diagnosis, specify:
1. The claim (e.g., "Sepsis")
2. Required evidence (e.g., "Fever AND Positive Culture AND Low BP")
3. Logic operator combining evidence (AND/OR)
4. Expected confidence

Format:
DIAGNOSIS: [name]
EVIDENCE_LOGIC: [claim logic]
OPERATOR: [AND/OR]
"""

    claims_response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=500,
        messages=[{"role": "user", "content": claim_prompt}]
    )
    claims = claims_response.content[0].text

    # Step 3: Propagate confidence through graph
    propagation_prompt = f"""
Given the evidence and claims:

Evidence: {evidence_nodes}
Claims: {claims}

For EACH diagnosis:
1. List supporting evidence
2. Calculate confidence using logic operators:
   - AND: min(conf1, conf2, conf3...)
   - OR: max(conf1, conf2)
3. Determine final diagnosis confidence

Output as JSON:
{
  "diagnosis": "Sepsis",
  "evidence": ["Fever: 0.95", "Low BP: 0.90", "Positive culture: 0.92"],
  "logic": "AND",
  "confidence": 0.90,
  "clinical_severity": "CRITICAL"
}
"""

    propagation_response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=600,
        messages=[{"role": "user", "content": propagation_prompt}]
    )
    final_diagnosis = propagation_response.content[0].text

    return {
        "evidence": evidence_nodes,
        "claims": claims,
        "final_diagnosis": final_diagnosis
    }


# Example usage
result = gol_medical_diagnosis(
    patient_symptoms="""
    65-year-old admitted with fever 39.5C, hypotensive (BP 85/50),
    tachycardic (HR 110), elevated WBC 15K, positive blood culture,
    altered mental status, severe malaise.
    """
)

print("GRAPH-OF-LOGIC DIAGNOSIS")
print("=" * 60)
print(result["final_diagnosis"])