| """Small deterministic knowledge operators used by the included source-derived demo.""" |
| from __future__ import annotations |
|
|
| import math |
| from dataclasses import dataclass |
| from typing import Any |
|
|
|
|
| def active_bit_positions(value: int) -> list[int]: |
| if value < 0: |
| raise ValueError("active-bit projection expects a non-negative integer") |
| return [k for k in range(value.bit_length()) if (value >> k) & 1] |
|
|
|
|
| def popcount(value: int) -> int: |
| return len(active_bit_positions(value)) |
|
|
|
|
| def regular_pulse_geometry(count: int, radius: float = 1.0, phase: float = 0.0) -> dict[str, Any]: |
| if count < 0: |
| raise ValueError("pulse count must be non-negative") |
| if count == 0: |
| return {"kind": "empty", "points": []} |
| if count == 1: |
| return {"kind": "point", "points": [[radius * math.cos(phase), radius * math.sin(phase)]]} |
| if count == 2: |
| return { |
| "kind": "segment", |
| "points": [[radius * math.cos(phase), radius * math.sin(phase)], |
| [-radius * math.cos(phase), -radius * math.sin(phase)]], |
| } |
| points = [ |
| [radius * math.cos(phase + 2.0 * math.pi * j / count), |
| radius * math.sin(phase + 2.0 * math.pi * j / count)] |
| for j in range(count) |
| ] |
| return {"kind": "triangle" if count == 3 else "regular_polygon", "points": points} |
|
|
|
|
| @dataclass(slots=True) |
| class KnowledgeResult: |
| output: dict[str, Any] |
| trace: list[dict[str, Any]] |
|
|
|
|
| def nineteen_demo() -> KnowledgeResult: |
| value = 19 |
| segments = ["ne", "gen", "tien"] |
| active = active_bit_positions(value) |
| trace: list[dict[str, Any]] = [ |
| {"operator": "TOM.ACTIVE", "input": value, "output": active}, |
| {"operator": "TOM.POPCOUNT", "input": active, "output": len(active)}, |
| {"operator": "TOM.PULSE", "input": segments, "output": len(segments)}, |
| ] |
| equal = len(active) == len(segments) |
| trace.append({"operator": "TOM.EQ", "left": len(active), "right": len(segments), "output": equal}) |
| geometry = regular_pulse_geometry(len(segments)) |
| trace.append({"operator": "TOM.PROJECT", "input": len(segments), "output": geometry["kind"]}) |
| output = { |
| "value": value, |
| "binary": format(value, "b"), |
| "active_bit_positions": active, |
| "active_bit_count": len(active), |
| "profile_segments": segments, |
| "pulse_count": len(segments), |
| "equal_feature_counts": equal, |
| "projection": geometry, |
| } |
| return KnowledgeResult(output=output, trace=trace) |
|
|
