cpu-llm 1.7.0__py3-none-any.whl

cpu_llm/__init__.py

@@ -0,0 +1,3 @@
+"""cpu-llm vertical slice. CPU-only; this package never imports torch."""
+
+__version__ = "1.7.0"

cpu_llm/agents/__init__.py

@@ -0,0 +1,5 @@
+from cpu_llm.agents.discovery import run_discovery
+from cpu_llm.agents.imagine import compose_imagination
+from cpu_llm.agents.reply import compose_reply
+
+__all__ = ["compose_imagination", "compose_reply", "run_discovery"]

cpu_llm/agents/deep_search.py

@@ -0,0 +1,67 @@
+"""Every chunk a deep-search prompt can reach, with none removed.
+
+The seeds are the prompt's content words, not the words that asked for the
+search. A seed keeps every paragraph stored under it, in every article. The
+relation walk then keeps every paragraph of the words one, two, and three
+edges further. The checked sentence is not replaced.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from cpu_llm.catalog import article_slug
+from cpu_llm.channels import _content_words
+from cpu_llm.relations import relation_hands
+
+_NOT_SEEDS = frozenset(
+    "deep search deeply everywhere possible possibilities dive look all".split()
+)
+
+
+def collect_possibilities(
+    message: str,
+    word_tags: dict[str, dict[str, list[str]]],
+    edges: list[Any] | None = None,
+) -> dict[str, Any]:
+    """Return every paragraph the seeds and their relation hands name."""
+    seeds = [word for word in _content_words(message) if word not in _NOT_SEEDS]
+    found: dict[str, dict[str, Any]] = {}
+    for seed in seeds:
+        _add_word(found, word_tags, seed, "word")
+    hands = {1: [], 2: [], 3: []}
+    if edges and seeds:
+        hands = relation_hands(edges, seeds, limit=100_000)
+        for hand, words in hands.items():
+            for word in words:
+                _add_word(found, word_tags, word, f"hand-{hand}")
+    possibilities = [found[document_id] for document_id in sorted(found)]
+    return {
+        "seeds": seeds,
+        "count": len(possibilities),
+        "hands": {str(hand): list(words) for hand, words in hands.items()},
+        "possibilities": possibilities,
+    }
+
+
+def _add_word(
+    found: dict[str, dict[str, Any]],
+    word_tags: dict[str, dict[str, list[str]]],
+    word: str,
+    via: str,
+) -> None:
+    for document_ids in (word_tags.get(word) or {}).values():
+        for document_id in document_ids:
+            item = found.setdefault(
+                document_id,
+                {
+                    "document_id": document_id,
+                    "article": article_slug(document_id),
+                    "matched_words": [],
+                    "via": [],
+                },
+            )
+            if word not in item["matched_words"]:
+                item["matched_words"].append(word)
+            if via not in item["via"]:
+                item["via"].append(via)

cpu_llm/agents/discovery.py

@@ -0,0 +1,138 @@
+"""Discovery Loop, stages 1 through 4.
+
+The agent records what the turn already established. It does not add a
+conclusion, and it does not call a model. Stage 5 was not in the protocol
+text that defined this agent, so the loop stops before scale shifting.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+PROTOCOL_VERSION = "1.0"
+INVARIANT = "Reality and evidence have the final veto."
+
+_PERSPECTIVES: dict[str, tuple[str, ...]] = {
+    "individual_humans": ("human", "person", "patient", "individual"),
+    "groups": ("society", "group", "community"),
+    "institutions": ("institution", "government", "agency"),
+    "artificial_agents": ("agent",),
+    "animals": ("animal", "species"),
+    "ecosystems": ("ecosystem", "ecology"),
+    "engineered_systems": ("machine", "engine", "device"),
+    "planetary": ("planet", "cosmic", "climate"),
+}
+
+
+def run_discovery(state: dict[str, Any]) -> dict[str, Any]:
+    claim = state.get("message") or ""
+    related = list(state.get("related") or [])
+    questions = [str(item) for item in state.get("gather_questions") or []]
+    evidence_text = " ".join(item.get("chunk_text") or "" for item in related)
+    return {
+        "protocol": "discovery-loop",
+        "version": PROTOCOL_VERSION,
+        "invariant": INVARIANT,
+        "stages_completed": [1, 2, 3, 4],
+        "stopped_before": "Stage 5: Scale Shifting",
+        "claim": _claim(claim, related, state),
+        "assumptions": _assumptions(state),
+        "information": _information(claim, related, questions, state),
+        "perspectives": _perspectives(f"{claim} {evidence_text}"),
+    }
+
+
+def _claim(claim: str, related: list[dict[str, Any]], state: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "text": claim,
+        "true_if": [
+            "A proposition paired with the retrieved tensor is realized and the auditor accepts the sentence.",
+            "Every number in that sentence matches a PrismManifest evidence span.",
+        ],
+        "false_if": [
+            "The prompt is blocked.",
+            "Deliberation reports a contradiction.",
+            "The sentence contains a number that is not an evidence span.",
+            "PrismThinker returns refuse.",
+        ],
+        "scope": {
+            "tenant_id": state.get("tenant_id") or "cpu-llm",
+            "evidence_ids": [item.get("chunk_id") for item in related],
+        },
+    }
+
+
+def _assumptions(state: dict[str, Any]) -> list[dict[str, str]]:
+    items = [
+        {
+            "kind": "technical",
+            "text": "Retrieval rank is topical relevance. It is not authority.",
+        }
+    ]
+    if state.get("cognition_status") == "needs_evidence_propositions":
+        items.append(
+            {
+                "kind": "logical",
+                "text": "A retrieved chunk is not a proposition, and it is not treated as one.",
+            }
+        )
+    if state.get("grammar_span_ids"):
+        items.append(
+            {
+                "kind": "mathematical",
+                "text": "A number in the sentence is allowed only when its canonical value matches an evidence span.",
+            }
+        )
+    if state.get("thinker_directive") == "gather":
+        items.append(
+            {
+                "kind": "empirical",
+                "text": "An unresolved gather question is missing information, not an observation.",
+            }
+        )
+    return items
+
+
+def _information(
+    claim: str,
+    related: list[dict[str, Any]],
+    questions: list[str],
+    state: dict[str, Any],
+) -> list[dict[str, str]]:
+    rows: list[dict[str, str]] = [
+        {"kind": "hypothesis", "text": claim, "provenance": "user"},
+    ]
+    for item in related:
+        rows.append(
+            {
+                "kind": "reported",
+                "text": item.get("chunk_text") or "",
+                "provenance": str(item.get("chunk_id") or "vectorprism"),
+            }
+        )
+    status = state.get("cognition_status")
+    if status == "deliberated" and state.get("abstention_triggered"):
+        rows.append(
+            {
+                "kind": "unknown",
+                "text": state.get("answer") or "",
+                "provenance": "deliberation",
+            }
+        )
+    elif status == "deliberated" and state.get("answer"):
+        kind = "interpretation" if float(state.get("ruin_distance") or 0) == 0 else "unknown"
+        rows.append({"kind": kind, "text": state.get("answer") or "", "provenance": "realizer"})
+    for question in questions:
+        rows.append({"kind": "unknown", "text": question, "provenance": "prismthinker"})
+    return rows
+
+
+def _perspectives(text: str) -> list[dict[str, str]]:
+    folded = text.casefold()
+    selected: list[dict[str, str]] = []
+    for name, words in _PERSPECTIVES.items():
+        hits = [word for word in words if re.search(rf"\b{re.escape(word)}\b", folded)]
+        if hits:
+            selected.append({"perspective": name, "named_in_evidence": ", ".join(hits)})
+    return selected

cpu_llm/agents/gather.py

@@ -0,0 +1,184 @@
+"""Gather every paragraph of the creative article and rank its words.
+
+The shortlist names the article. This node loads the rest of that article,
+not only the lead paragraph. It collects the content words of those
+paragraphs and ranks them by how often they sit in a paragraph that shares
+the prompt's words. The checked sentence is not written here.
+"""
+
+from __future__ import annotations
+
+import random
+from typing import Any
+
+import numpy as np
+
+from cpu_llm.catalog import article_slug
+from cpu_llm.channels import _content_words, _cosine, _slice
+from cpu_llm.word_taxonomy import category_number
+from vectorprism.tensor_contract import PSMTensorContract
+
+_MOST = 32
+
+
+def realize_ranked_paragraphs(
+    message: str,
+    rows: list[dict[str, Any]],
+    pool: dict[str, Any],
+    proposition_for,
+    realizer,
+    auditor,
+    *,
+    numbers_allowed=None,
+    vary: bool = False,
+    rng: random.Random | None = None,
+    avoid: set[str] | None = None,
+) -> dict[str, Any]:
+    """Realize the ranked paragraphs with the sentence function, then check each one.
+
+    A paragraph is skipped when it has no proposition the realizer can repeat,
+    when the auditor rejects the sentence, or when a number in it is not in
+    the gathered paragraphs. The checked answer is left alone. With ``vary``,
+    each call draws a different order and a different subset of the sentences
+    that passed those checks.
+    """
+    by_id = {str(row["document_id"]): row for row in rows}
+    chosen = [item for item in pool.get("paragraphs") or [] if item.get("relevance", 0) > 0]
+    if not chosen:
+        chosen = list(pool.get("paragraphs") or [])[:1]
+    links: list[dict[str, Any]] = []
+    sentences: list[str] = []
+    for item in chosen:
+        document_id = str(item["document_id"])
+        row = by_id.get(document_id)
+        if row is None:
+            continue
+        text = str(row.get("chunk_text") or "")
+        proposition = proposition_for(document_id, text, row.get("tensor_1024d"))
+        if proposition is None:
+            continue
+        sentence, delivered = realizer.synthesize([proposition], [])
+        if not sentence or not auditor.audit_delivered_output(delivered, [proposition]):
+            continue
+        if numbers_allowed is not None and not numbers_allowed(sentence):
+            continue
+        prompt = set(_content_words(message))
+        keywords = [word for word in _content_words(sentence) if word in prompt]
+        links.append(
+            {
+                "chunk_id": document_id,
+                "sentence": sentence,
+                "keywords": keywords,
+                "relevance": item.get("relevance", 0),
+            }
+        )
+    if vary:
+        links = _varied_passage(links, rng or random.SystemRandom(), set(avoid or ()))
+    sentences = [item["sentence"] for item in links]
+    return {
+        "text": " ".join(sentences),
+        "links": links,
+        "realized": len(sentences),
+        "varied": vary,
+    }
+
+
+def _varied_passage(
+    links: list[dict[str, Any]],
+    rng: random.Random,
+    avoid: set[str],
+) -> list[dict[str, Any]]:
+    """Pick an arrangement that is not one already returned for this prompt."""
+    if len(links) < 2:
+        return links
+    limit = min(len(links), 3)
+    for _ in range(48):
+        count = rng.randint(1, limit)
+        picks = rng.sample(list(links), count)
+        if _passage(picks) not in avoid:
+            return picks
+    for shift in range(len(links)):
+        rotated = links[shift:] + links[:shift]
+        for count in range(1, limit + 1):
+            picks = rotated[:count]
+            if _passage(picks) not in avoid:
+                return picks
+    return links
+
+
+def _passage(links: list[dict[str, Any]]) -> str:
+    return " ".join(item["sentence"] for item in links)
+
+
+def gather_article(
+    message: str,
+    chunks: list[dict[str, Any]],
+    query: np.ndarray | None = None,
+) -> dict[str, Any]:
+    """Rank the words and paragraphs in ``chunks`` against ``message``.
+
+    ``chunks`` carry ``document_id`` and ``chunk_text``. A ``tensor`` is used
+    only as a dense-core tie break. Every chunk stays in the group.
+    """
+    prompt = list(dict.fromkeys(_content_words(message)))
+    prompt_set = set(prompt)
+    articles: list[str] = []
+    paragraphs: list[dict[str, Any]] = []
+    locations: dict[str, list[str]] = {}
+    for chunk in chunks:
+        document_id = str(chunk["document_id"])
+        slug = article_slug(document_id)
+        if slug not in articles:
+            articles.append(slug)
+        words = list(dict.fromkeys(_content_words(str(chunk.get("chunk_text") or ""))))
+        present = set(words)
+        shared = [word for word in prompt if word in present]
+        cosine = _dense_cosine(query, chunk.get("tensor") or chunk.get("tensor_1024d"))
+        paragraphs.append(
+            {
+                "document_id": document_id,
+                "article": slug,
+                "relevance": len(shared),
+                "prompt_words": shared,
+                "cosine": cosine,
+            }
+        )
+        for word in words:
+            locations.setdefault(word, [])
+            if document_id not in locations[word]:
+                locations[word].append(document_id)
+    supporting = {item["document_id"] for item in paragraphs if item["relevance"] > 0}
+    if not supporting:
+        supporting = {item["document_id"] for item in paragraphs}
+    ranked_words = []
+    for word, document_ids in locations.items():
+        support = sum(1 for document_id in document_ids if document_id in supporting)
+        score = support + (2 if word in prompt_set else 0)
+        ranked_words.append((score, word, document_ids))
+    ranked_words.sort(key=lambda item: (-item[0], item[1]))
+    paragraphs.sort(
+        key=lambda item: (
+            -item["relevance"],
+            -(item["cosine"] if item["cosine"] is not None else -2.0),
+            item["document_id"],
+        )
+    )
+    return {
+        "articles": articles,
+        "categories": {slug: category_number(slug) for slug in articles},
+        "paragraph_count": len(paragraphs),
+        "word_count": len(ranked_words),
+        "paragraphs": paragraphs,
+        "most_relevant": [
+            {"word": word, "score": score, "paragraphs": len(document_ids)}
+            for score, word, document_ids in ranked_words[:_MOST]
+        ],
+    }
+
+
+def _dense_cosine(query: np.ndarray | None, tensor: Any) -> float | None:
+    if query is None or tensor is None:
+        return None
+    left = _slice(np.asarray(query, dtype=np.float64).reshape(-1), PSMTensorContract.DENSE_CORE)
+    right = _slice(np.asarray(tensor, dtype=np.float64).reshape(-1), PSMTensorContract.DENSE_CORE)
+    return _cosine(left, right)

cpu_llm/agents/imagine.py

@@ -0,0 +1,149 @@
+"""An imagined passage from one article's stored tensors.
+
+The shortlist names the articles. Every paragraph of those articles is loaded.
+PrismResonance scores each paragraph against the question. A paragraph whose
+interference is not positive is left out. The paragraphs that stay are ordered
+by a walk along their dense cores: each step is the nearest unused paragraph.
+The sentence copied from a paragraph is one already written there. The words
+named on a step are the question's content words that occur in that sentence.
+
+This is not a cause, a measurement, or a proposition, and it is not the
+checked sentence.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+from vectorprism.tensor_contract import PSMTensorContract
+
+from cpu_llm.catalog import article_slug
+from cpu_llm.channels import _best_sentence, _content_words, _cosine, _slice
+
+_NOTE = (
+    "Each sentence is copied from a paragraph of an article the shortlist already named. "
+    "PrismResonance keeps a paragraph whose interference with the question is positive. "
+    "Dense-core cosine orders those paragraphs. The link is that the tensors sit near each other."
+)
+_EMPTY = "The shortlist named no article, so there is nothing to connect."
+_SILENT = "None of the loaded paragraphs interfered with the question."
+
+
+def compose_imagination(
+    message: str,
+    chunks: list[dict[str, Any]],
+    resonance: dict[str, float],
+) -> dict[str, Any]:
+    """Walk ``chunks`` whose resonance scores are positive.
+
+    ``chunks`` carry ``document_id``, ``chunk_text``, and ``tensor``.
+    ``resonance`` maps a document id to the PrismResonance score.
+    """
+    if not chunks:
+        return _result([], [], _EMPTY)
+    kept: list[dict[str, Any]] = []
+    for chunk in chunks:
+        document_id = str(chunk["document_id"])
+        score = resonance.get(document_id)
+        if score is None or not np.isfinite(score) or float(score) <= 0.0:
+            continue
+        tensor = np.asarray(chunk["tensor"], dtype=np.float64).reshape(-1)
+        kept.append(
+            {
+                "document_id": document_id,
+                "chunk_text": str(chunk["chunk_text"]),
+                "tensor": tensor,
+                "resonance": float(score),
+            }
+        )
+    if not kept:
+        return _result(_articles(chunks), [], _SILENT, loaded=len(chunks))
+    ordered = _walk(kept)
+    links: list[dict[str, Any]] = []
+    keywords: list[str] = []
+    sentences: list[str] = []
+    for item in ordered:
+        sentence = _best_sentence(item["chunk_text"], message)
+        words = _shared_keywords(message, sentence)
+        for word in words:
+            if word not in keywords:
+                keywords.append(word)
+        cosine = item["cosine_to_previous"]
+        links.append(
+            {
+                "chunk_id": item["document_id"],
+                "resonance": item["resonance"],
+                "cosine_to_previous": None if cosine is None else float(cosine),
+                "sentence": sentence,
+                "keywords": words,
+            }
+        )
+        if sentence:
+            sentences.append(sentence)
+    return _result(_articles(chunks), links, _NOTE, loaded=len(chunks), keywords=keywords, text=" ".join(sentences))
+
+
+def _result(
+    articles: list[str],
+    links: list[dict[str, Any]],
+    note: str,
+    *,
+    loaded: int = 0,
+    keywords: list[str] | None = None,
+    text: str = "",
+) -> dict[str, Any]:
+    return {
+        "triggered": True,
+        "articles": articles,
+        "loaded": loaded,
+        "links": links,
+        "keywords": list(keywords or []),
+        "text": text,
+        "note": note,
+    }
+
+
+def _articles(chunks: list[dict[str, Any]]) -> list[str]:
+    slugs: list[str] = []
+    for chunk in chunks:
+        slug = article_slug(str(chunk["document_id"]))
+        if slug not in slugs:
+            slugs.append(slug)
+    return slugs
+
+
+def _shared_keywords(message: str, sentence: str) -> list[str]:
+    present = set(_content_words(sentence))
+    words: list[str] = []
+    for word in _content_words(message):
+        if word in present and word not in words:
+            words.append(word)
+    return words
+
+
+def _dense(tensor: np.ndarray) -> np.ndarray:
+    return _slice(tensor, PSMTensorContract.DENSE_CORE)
+
+
+def _walk(kept: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    remaining = sorted(kept, key=lambda item: (-item["resonance"], item["document_id"]))
+    start = remaining.pop(0)
+    start["cosine_to_previous"] = None
+    ordered = [start]
+    while remaining:
+        current = _dense(ordered[-1]["tensor"])
+        best_at = 0
+        best_rank: tuple[float, str] | None = None
+        best_cosine = None
+        for index, item in enumerate(remaining):
+            cosine = _cosine(current, _dense(item["tensor"]))
+            rank = (-(cosine if cosine is not None else -2.0), item["document_id"])
+            if best_rank is None or rank < best_rank:
+                best_rank = rank
+                best_at = index
+                best_cosine = cosine
+        chosen = remaining.pop(best_at)
+        chosen["cosine_to_previous"] = best_cosine
+        ordered.append(chosen)
+    return ordered