stopping judgment

from pathlib import Path
import opensysml
from toaster.evidence import ReviewRecord, hash_content, validate_record
from toaster.query import find_allocations, perform_relationships
from toaster.report import format_diagnostics

conn = opensysml.connect(version="v0.9.0")
source = Path("../../models/ch06-cumulative.sysml").read_text()
lines = source.splitlines()
print("\n".join(lines[137:164] + lines[173:212]))
model = conn.load_from_content(source, strict=False)
assert model.ok, f"Model failed: {format_diagnostics(model.diagnostics)}"

from toaster.render import containment_subgraph, model_to_dot, render_dot
from IPython.display import SVG

dot = model_to_dot(
    model,
    title="Ch6",
    elements=containment_subgraph(
        model, "ToasterDemo::HeatingAssembly", relations=("composition", "typing"), depth=2
    ),
)
out_path = Path("../../figures/ch06-structure.svg")
out_path.parent.mkdir(exist_ok=True)
render_dot(dot, out_path)
SVG(filename=str(out_path))

# Negative control: an asserted_inference with empty premises fails validate_record().
# The Hawkins 3.1 schema requires at least one premise; no premises means a bare
# assertion, not an inference.
incomplete = ReviewRecord(
    identifier="AI-BAD",
    kind="asserted_inference",
    claim="The heat-generation branch is complete.",
    subject_ref="ToasterDemo::HeatingAssembly::heatGen",
    model_ref="ToasterDemo::HeatingAssembly::heatGen",
    content_hash=hash_content(source),
    scope="ToasterDemo",
    criteria="Every function allocated to HeatGenerator is realized and checked.",
    premises=[],
    assumption_refs=[],
    evidence_refs=[],
    rationale="ResistanceCoil realizes GenerateHeat.",
    counterevidence="No producer is wired to energyIn.",
    residual_uncertainties="HeatingAssembly is not composed into any Toaster candidate.",
    disposition="pending",
    dependency_freshness="current",
    engineering_conclusion="undetermined",
    record_kind="worked_example",
)
errors = validate_record(incomplete, model=model)
expected = ["asserted_inference requires at least one premise (Hawkins §3.1)"]
assert errors == expected, f"Expected exactly one premises error, got {errors}"
print(f"Validation errors for empty-premises record: {errors}")

performs = perform_relationships(model)
allocations = find_allocations(model)
rated_holds = model.eval("ToasterDemo::heatGenerationReq(ToasterDemo::rated)")
weak_holds = model.eval("ToasterDemo::heatGenerationReq(ToasterDemo::weak)")
print(f"Perform relationships: {performs}")
print(f"Allocations: {allocations}")
print(f"heatGenerationReq(rated) = {rated_holds}, heatGenerationReq(weak) = {weak_holds}")

from toaster.render import build_interconnection_intent, render_interconnection
intent = build_interconnection_intent(model, "ToasterDemo::HeatingAssembly", depth=1)
out_path = Path("../../figures/ch06-heatingassembly-interconnect.svg")
render_interconnection(intent, out_path)
from IPython.display import SVG
SVG(filename=str(out_path))

# what is being claimed, and what, specifically, it is about
subject_ref = "ToasterDemo::HeatingAssembly::heatGen"
AI_C06_TAG = """\
metadata aiC06Tag : ReviewRecordRef about HeatingAssembly::heatGen {
    identifier = "AI-C06";
}
"""
print(AI_C06_TAG)

TOASTER_INCREMENT = AI_C06_TAG

claim = (
    "GenerateHeat is a real, specified behavior: HeatGenerator performs it "
    "and is allocated the nested step, not merely declared syntax. energyIn "
    "is a declared, typed connection point on HeatGenerator, not yet wired "
    "to a producer. heatGenerationReq evaluates against two real "
    "candidates, rated (True) and weak (False), a genuine satisfaction "
    "check on an underived threshold, not an unevaluated assertion."
)
model_ref = "ToasterDemo::HeatingAssembly::heatGen"
print(claim)

scope = "ToasterDemo::HeatingAssembly::heatGen and its realizations"
criteria = (
    "Per the recursion's own stopping rule, a leaf performs its specified "
    "behavior, connects through its specified interfaces, and has "
    "verification evidence. At this level: GenerateHeat is a specified "
    "behavior, allocated to HeatGenerator (met). energyIn is a declared, "
    "typed connection point, not yet connected to any producer "
    "(partially met, not complete). heatGenerationReq evaluates on two "
    "real candidates against a threshold that is itself not yet derived "
    "(partial evidence, not full verification)."
)
print(criteria)

premises = ["AC-C06", "AS-C06", "AS-C03", "AI-C04"]
assumption_refs = [
    "GenerateHeat's own energy input is bound to ApplyHeat::energy, "
    "printed as part of APPLY_HEAT_INCREMENT and loaded successfully in "
    "notebook 01; this does not by itself mean energyIn is wired to any "
    "producer."
]
print(assumption_refs)

evidence_refs = [
    f"perform_relationships(model): {performs}",
    f"find_allocations(model): {allocations}",
    f"heatGenerationReq(rated) = {rated_holds}, heatGenerationReq(weak) = "
    f"{weak_holds}, evaluated directly against the loaded model above.",
]
rationale = (
    "Performs: real, not merely declared. HeatGenerator performing "
    "GenerateHeat and heatGenAllocation both appear directly in "
    "perform_relationships and find_allocations above, not just in the "
    "source text, the same performer-and-allocation split Chapter 5 "
    "established one level up. Connects: energyIn is declared and typed, "
    "the interface point the stopping rule names, but it is not wired to "
    "any producer, so this condition is only partially met. Verified: "
    "heatGenerationReq is genuinely evaluated, not left as an unevaluated "
    "assertion, on two real candidates, one passing and one deliberately "
    "failing for a reason about the design; but its own threshold is not "
    "yet derived from any stated measure of effectiveness (AC-C06), so "
    "this is partial verification evidence, not a completed check."
)
print(rationale)

counterevidence = (
    "energyIn has no producer wired to it: no supply or wire component "
    "exists in this model, so the interface point is declared, not yet "
    "connected end to end, the same partial state Chapter 5 left "
    "ApplyHeat::duration in before that chapter built its own port "
    "connection. HeatingAssembly is not yet composed into any Toaster "
    "candidate: Toaster::heating is still typed by the abstract "
    "HeatingSystem, so no full toaster candidate contains a resistance "
    "coil yet. The 600 W threshold is not derived from any stated "
    "measure of effectiveness (AC-C06); it is a free-standing "
    "engineering figure. This branch addresses only GenerateHeat's own "
    "energy-to-heat conversion: ApplyHeat's other flows (bread, "
    "duration, toast, delivered, loss) are not decomposed or accounted "
    "for at this level. This is a deliberate one-branch worked example "
    "of one of ApplyHeat's own flows, the same kind of honestly scoped "
    "choice Chapter 4 made for ApplyHeat itself out of Douglas's roughly "
    "fifteen functions, not a claim that Chapter 6 finishes ApplyHeat's "
    "full decomposition."
)
residual_uncertainties = (
    "Whether GenerateHeat needs further decomposition of its own, "
    "whether HeatingAssembly is ever composed into a real Toaster "
    "candidate, and whether ApplyHeat's other flows (duration, bread, "
    "toast) get their own level-2 branches, are open for whichever "
    "chapter takes them up."
)
print(counterevidence)
print(residual_uncertainties)

from toaster.query import get_review_record_refs
from toaster.judgment_store import save_record

stopping_judgment = ReviewRecord(
    identifier="AI-C06",
    kind="asserted_inference",
    claim=claim,
    subject_ref=subject_ref,
    model_ref=model_ref,
    content_hash=hash_content(source),
    scope=scope,
    criteria=criteria,
    premises=premises,
    assumption_refs=assumption_refs,
    evidence_refs=evidence_refs,
    rationale=rationale,
    counterevidence=counterevidence,
    residual_uncertainties=residual_uncertainties,
    disposition="pending",
    dependency_freshness="current",
    engineering_conclusion="undetermined",
    record_kind="worked_example",
)

errors = validate_record(stopping_judgment, model=model)
save_record(stopping_judgment)
tag = next((t for t in get_review_record_refs(model) if t["identifier"] == stopping_judgment.identifier), None)
print(f"Model tag: {tag}")
print(f"Validation errors: {errors}")
print(f"Premises: {stopping_judgment.premises}")
conn.close()