bigmerge
4bbfdcceff
audio-surface.el / image-surface.el: own-core additive-synthesis WAV and
raster-PNG renderers (integer-only DSP, since EL has no floats), rendered
from learned engram signatures via a pluggable surface-profile
abstraction (surface-profile.el). audio-demo.el / image-demo.el are
drivers. NOTE: demo files hardcode absolute paths to this worktree's own
directory — will need a path fixup before landing.
elp/projector/ is a Python package the author's own README marks as
"STAGING/PROOF-OF-SHAPE — not the deliverable", superseded by the native
.el surface-profile work above; kept as a validated architecture proof.
Generated output (elp/faculty/{out,sig}, elp/projector/out,
__pycache__) intentionally excluded.
113 lines
4.4 KiB
Python
113 lines
4.4 KiB
Python
"""realize.py — REALIZE stage: fill each planned section with faithful passages.
|
|
|
|
Scales the PROVEN realizer from a single assertion to a passage. For each
|
|
planned proposition we build a realizer-ready clause (the proven
|
|
``_prop_to_clause`` mapping) and run it through the proven engine
|
|
(``engine.realize``), which is a deterministic grammar with the SACRED negation
|
|
contract — it never invents. Each realized sentence is paired with a
|
|
:class:`Provenance` that pins it to the exact geometry edge it came from.
|
|
|
|
"Passage, not a list of sentences": within a section we lightly vary sentence
|
|
openings and group related claims, but we add NO content the geometry did not
|
|
assert. The only non-geometry words are function words the grammar already owns
|
|
(articles, "and", conjunction of same-subject claims). Document-level flow is
|
|
COHERE's job; this stage owns intra-section fluency + fidelity.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import os
|
|
import sys
|
|
|
|
_NT = os.path.expanduser("~/Desktop/neuron-talk")
|
|
_LR = os.path.expanduser("~/Desktop/lang-realizers")
|
|
for _p in (_NT, _LR):
|
|
if _p not in sys.path:
|
|
sys.path.insert(0, _p)
|
|
|
|
import engine # noqa: E402 (the proven no-LLM realizer)
|
|
from dialogue import _prop_to_clause # noqa: E402 (proven prop -> clause)
|
|
|
|
from document_ir import Block, DocumentIR, Provenance, Section # noqa: E402
|
|
|
|
|
|
def _provenance_from(p, kind: str = "fact") -> Provenance:
|
|
return Provenance(
|
|
subj_id=p.source_node_id, subject=p.subject, relation=p.predicate,
|
|
obj=p.object, polarity=p.polarity, confidence=round(float(p.confidence), 3),
|
|
node_id=p.source_node_id, kind=kind,
|
|
importance=float(getattr(p, "node_importance", 0.0) or 0.0),
|
|
salience=0.0,
|
|
)
|
|
|
|
|
|
import re as _re
|
|
|
|
# a well-formed declarative opens with a determiner, a proper noun, "I", or a
|
|
# capitalized head — not a mis-parsed object pronoun or a copula fragment.
|
|
_BAD_OPENERS = _re.compile(r"^(Me |It is I|There is|This is it|That is it)\b")
|
|
_VACUOUS = _re.compile(r"^\w+ (is|are|was|were) (it|no|nothing|empty|those|this|that)\.?$",
|
|
_re.I)
|
|
|
|
|
|
def _good_sentence(text: str) -> bool:
|
|
"""Fluency gate — drops degenerate realizations. NEVER loosens faithfulness;
|
|
it only refuses to SPEAK a claim whose surface came out malformed."""
|
|
words = text.rstrip(".").split()
|
|
if len(words) < 3:
|
|
return False
|
|
if _BAD_OPENERS.search(text):
|
|
return False
|
|
if _VACUOUS.match(text):
|
|
return False
|
|
# a sentence that is mostly one-letter/two-letter tokens is a parse artifact
|
|
short = sum(1 for w in words if len(w.strip(".,'")) <= 2)
|
|
if short > len(words) / 2:
|
|
return False
|
|
return True
|
|
|
|
|
|
def _realize_prop(p, lang: str = "en") -> tuple[str, Provenance] | None:
|
|
"""One proposition -> (faithful sentence, provenance) or None if it drops."""
|
|
clause = _prop_to_clause(p)
|
|
text = engine.realize(clause, lang)
|
|
if not text or not text.strip():
|
|
return None
|
|
text = text.strip()
|
|
if not text.endswith((".", "!", "?")):
|
|
text += "."
|
|
# capitalize first character (proper nouns / "I" already handled by grammar)
|
|
text = text[0].upper() + text[1:]
|
|
if not _good_sentence(text):
|
|
return None
|
|
return text, _provenance_from(p)
|
|
|
|
|
|
def realize_document(doc: DocumentIR, lang: str = "en") -> DocumentIR:
|
|
"""Fill every planned section's blocks with faithful, realized passages."""
|
|
for sec in doc.sections:
|
|
planned = sec.__dict__.get("_planned_props", [])
|
|
block = Block(role="body")
|
|
summary_bits: list[str] = []
|
|
for p in planned:
|
|
r = _realize_prop(p, lang)
|
|
if r is None:
|
|
continue
|
|
text, prov = r
|
|
block.sentences.append(text)
|
|
block.provenance.append(prov)
|
|
if len(summary_bits) < 1:
|
|
# a short grounded gloss for TOC / pptx bullets
|
|
obj = (prov.obj or "").strip().rstrip(".")
|
|
if obj:
|
|
summary_bits.append(obj)
|
|
if block.sentences:
|
|
sec.blocks.append(block)
|
|
sec.summary = summary_bits[0] if summary_bits else ""
|
|
# drop the transient planning payload; the IR is now self-contained
|
|
sec.__dict__.pop("_planned_props", None)
|
|
sec.__dict__.pop("_node", None)
|
|
|
|
# prune sections that realized to nothing
|
|
doc.sections = [s for s in doc.sections if s.blocks]
|
|
return doc
|