leio-decision 0.3.2__py3-none-any.whl

leio_decision-0.3.2.dist-info/METADATA

@@ -0,0 +1,438 @@
+Metadata-Version: 2.5
+Name: leio-decision
+Version: 0.3.2
+Summary: Ontology-Grounded System 1 Decision Model
+Author: Dionisio & Team
+Requires-Python: >=3.11
+Requires-Dist: numpy>=1.26.0
+Requires-Dist: onnxruntime>=1.17.0
+Requires-Dist: pydantic>=2.5.0
+Requires-Dist: torch>=2.2.0
+Requires-Dist: transformers>=4.40.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: rdflib>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.3.0; extra == 'dev'
+Provides-Extra: llm
+Requires-Dist: anthropic>=0.40; extra == 'llm'
+Description-Content-Type: text/markdown
+
+# O-Laya: Ontology-Grounded System 1 Decisions
+
+O-Laya turns a fast, non-autoregressive scorer into a decision engine whose output
+respects a formal ontology. Candidates come from an OWL / RDF class hierarchy and
+every output distribution is projected so that subsumption (`P(child) ≤ P(parent)`)
+and disjointness (`A ⊓ B = ⊥`) hold. Each answer carries a CURIE, its lineage, the
+per-concept probabilities, an entropy-based confidence, and a computed
+`axioms_verified` flag.
+
+It ships as three runtimes that share one ontology model, one axiom
+specification ([`spec/AXIOMS.md`](spec/AXIOMS.md)) and one set of golden vectors
+checked in CI, plus a TBox-bound workflow layer that records and replays
+decisions as JSON-LD provenance.
+
+## What is and is not here
+
+Read this before anything else.
+
+| Component | State |
+|---|---|
+| Ontology DAG, OWL 2 RL schema closure, axiom projection kernel | Implemented, deterministic, tested in Python, Rust and Node against shared golden vectors |
+| OWL / RDF / SKOS / OBO ingestion to Arrow IPC (`owl-fast-core`, `olaya-core`) | Implemented; 13 real ontologies tracked as fixtures and exercised in tests |
+| Formal Concept Analysis engine (`owl-fast-core::fca`) | Implemented and tested |
+| Lean 4 proof core (`lean/`) | Steps 3–4 of the axiom kernel and the verifier are formalised over integer scores; `project_verified` and 15 supporting theorems, no `sorry`, axioms audited in CI. Softmax, confidence, and the `K`-sweep convergence bound are **not** proven. See [`spec/AXIOMS.md`](spec/AXIOMS.md). |
+| TBox-bound workflow compiler, interpreter, JSON-LD traces, inference-free replay | Implemented and tested |
+| Lexical scoring (label / synonym / description overlap with IDF) | Implemented in every runtime. **This is what every shipped runtime uses to score.** |
+| Neural scoring head (Python, PyTorch) | Implemented and trainable. **No trained weights are committed.** `OLaya()` without a checkpoint is a randomly initialised encoder; its scores are not meaningful. |
+| ONNX path in Rust (`onnx` feature) | Compiles. No model to load, no end-to-end test. |
+| WebAssembly build | Builds in CI for `wasm32-unknown-unknown`; kernel unit-tested. |
+| Calibration | Temperature fitting (`calibration.py`) is implemented and used at inference when a checkpoint carries a fitted temperature. Without one, confidence is normalised entropy with a fixed cardinality temperature and is **not** an empirically calibrated probability. |
+| Published packages | `leio-decision` on PyPI and npm (part of the leio suite with `leio-code`), published by `release.yml` from the tagged commit; `olaya` 0.3.1 on PyPI is the same code under its previous name. Until the first `leio-decision` publish, install from a locally built wheel (see Installation). |
+| HTTP edge demo (`/api/systemone`) | Live, lexical only, no ontology DAG. See [the edge contract](spec/systemone-reliability.md). |
+
+No accuracy, ECE, or latency number in this repository applies to a trained
+neural model, because none is committed. The only external benchmark we report
+is the OAEI Conference track below, run with the lexical matcher on vendored
+upstream data, reproducible with one command.
+
+## OAEI Conference track (the one external benchmark)
+
+O-Laya's matchers are evaluated with the standard OAEI alignment protocol on
+the Conference track (OntoFarm, reference alignment ra1, 21 ontology pairs, 259
+class and 46 property correspondences): every cross pair is scored, mutual-best
+1:1 correspondences above a threshold fixed a priori (0.50) form the alignment,
+and precision / recall / F1 are computed against ra1 for classes (M1),
+properties (M2) and both (M3), micro-averaged over the 21 pairs as OAEI does.
+Three matchers are reported: a dependency-free lexical matcher, a hybrid that
+runs the lexical matcher first and lets a small local sentence encoder
+(`intfloat/e5-small-v2`, CSLS-calibrated cosine over the label, the description
+or the entity's path from the root) decide only the leftover
+entities, and the hybrid plus training-free structural propagation over the
+ontology graphs (Similarity Flooding, neighbour aggregation or embedding
+smoothing, `olaya.benchmarks.structural`). Reproduce with
+`.venv/bin/python scripts/benchmark_oaei.py` (about 10 min with the encoder, or
+`--no-embeddings` for the lexical and lexical + structure rows in about 20 s;
+vendored upstream data in `tests/fixtures/oaei/`).
+
+| System (OAEI 2023, ra1, micro) | M1 P / R / F1 | M3 P / R / F1 |
+| :--- | :---: | :---: |
+| GraphMatcher | 0.78 / 0.89 / **0.83** | 0.76 / 0.80 / **0.78** |
+| SORBETMtch | 0.78 / 0.75 / 0.76 | 0.78 / 0.64 / 0.70 |
+| LogMap | 0.84 / 0.63 / 0.72 | 0.81 / 0.58 / 0.68 |
+| Matcha | 0.76 / 0.68 / 0.72 | 0.70 / 0.64 / 0.67 |
+| **olaya-hybrid (this repo, leave-one-pair-out CV)** | 0.81 / 0.69 / 0.75 | 0.69 / 0.66 / 0.68 |
+| **olaya-hybrid + structure (this repo, leave-one-pair-out CV, union grid)** | 0.81 / 0.69 / 0.75 | 0.69 / 0.66 / 0.68 |
+| **olaya-lexical (this repo, threshold 0.50)** | 0.83 / 0.64 / 0.73 | 0.73 / 0.60 / 0.66 |
+| edna (baseline) | 0.88 / 0.54 / 0.67 | 0.79 / 0.47 / 0.59 |
+| StringEquiv (baseline) | 0.88 / 0.50 / 0.64 | 0.80 / 0.43 / 0.56 |
+
+Where we land: the hybrid's headline is cross-validated (threshold and fusion
+weight chosen on the other 20 pairs for each held-out pair), which makes it the
+honest number; the best configuration picked on the full set scores 0.76 / 0.69.
+It ranks third on both tables: below GraphMatcher by 0.08 (M1) and 0.10 (M3),
+below SORBETMtch by 0.01 and 0.02, tied with LogMap on M3 and above LogMap and
+Matcha on M1. The lexical matcher alone is 0.02 behind the hybrid on both. It is
+not state of the art. Structural propagation did not help: seeded by the hybrid, the
+best structural grid point scores 0.75 / 0.69 on ra1 (optimistic), but when the
+hybrid and structural grids are cross-validated together the selection never picks
+a structural config once the hybrid grid contains the path text, so the headline
+stays the hybrid. Structure does raise recall
+(Similarity Flooding reaches M1 recall 0.84, close to GraphMatcher's 0.89) but
+precision falls faster, because a training-free propagation cannot tell a matching
+sibling pair from a merely parallel one; GraphMatcher's recall comes from attention
+trained on these ontologies. The design choices (cascade fusion, CSLS, encoder,
+propagation rules) were made after seeing ra1; only the numeric knobs are protected
+by the CV. An error analysis of every missed and spurious correspondence
+([`benchmarks/results/oaei-error-analysis.md`](benchmarks/results/oaei-error-analysis.md))
+shows that recall is lost mostly at the threshold on compound labels and at the
+scoring of synonyms; of everything it motivated (richer texts, head nouns, fused
+scores, larger encoders and ensembles, Hungarian and margin decoders, adaptive
+thresholds) only encoding the entity's path from the root helps under
+cross-validation, and only on its own threshold sub-grid (+0.04 M3); on the
+full grid the headline is unchanged within noise. Applying the OWL 2
+RL coherence repair to the alignment *lowers* F1 on ra1 by about 0.02 (ra1 is the
+unrepaired reference; the repaired rar2 is not vendored), so it is opt-in and not
+part of the headline number. Full per-pair numbers, the threshold sweep, dataset
+hashes and the published sources are in
+[`benchmarks/results/oaei-conference-ra1.md`](benchmarks/results/oaei-conference-ra1.md)
+and [`oaei-conference-ra1.json`](benchmarks/results/oaei-conference-ra1.json).
+An LLM-judge stage (candidates from the hybrid, a language model asked with
+ontology context whether each pair is equivalent; `scripts/benchmark_oaei_llm.py`,
+category LLM-based) is built and validated offline with a reference-backed stub in
+[`benchmarks/results/oaei-llm.md`](benchmarks/results/oaei-llm.md); its real-judge
+numbers are pending an API key and are not part of the table above.
+Earlier versions of this README reported hits@k with the gold target guaranteed to be
+in the candidate set and a "100% violation elimination" figure computed on synthetic
+distributions; both were retracted because they were not benchmark results.
+
+## How it works
+
+```mermaid
+flowchart TD
+    subgraph "1. Candidate routing"
+        State["Input state (text / JSON)"] --> Router["Inverted index over labels, synonyms, descriptions<br/>(CamelCase-aware tokens, IDF weighting)"]
+        Onto[("Ontology<br/>classes, subClassOf, disjointWith")] --> Router
+        Router --> Sub["Active subgraph:<br/>top-K matches + full ancestor chain"]
+    end
+
+    subgraph "2. Scoring"
+        Sub --> Lex["Lexical overlap (all runtimes)"]
+        Sub --> Neural["Marker-pooling transformer head<br/>(Python; needs a trained checkpoint)"]
+    end
+
+    subgraph "3. Axiom projection (spec/AXIOMS.md)"
+        Lex & Neural --> Proj["Temperature softmax<br/>→ disjointness exclusion<br/>→ subsumption monotonicity<br/>→ normalised-entropy confidence"]
+    end
+
+    Proj --> Out["Grounded decision:<br/>CURIE + lineage, per-concept probabilities, confidence, axioms_verified"]
+```
+
+For `concept` questions the Python engine scores only the most specific routed
+concepts and derives each ancestor's probability as the sum of its descendants',
+so the hierarchy constraint holds by construction and the answer is never an
+ancestor of another candidate.
+
+## Runtimes
+
+| Runtime | Package | Scoring | Scope |
+|---|---|---|---|
+| **Rust** | `olaya-core` (`crates/olaya-core`) | Lexical; optional ONNX cross-encoder behind the `onnx` feature (no bundled model) | Arrow-native ontology batches, OWL/Turtle ingestion via `owl-fast-core`, constant-time routing per query |
+| **Python** | `olaya` (`src/olaya`) | Transformer marker-pooling head (untrained unless you supply a checkpoint) | Full `system_one` API: `concept`, `subsumes`, `choice`, `score`, `noul`; training, calibration, workflows, MCP server |
+| **Node / TypeScript** | `leio` (`packages/olaya-node`) | Lexical | Zero-dependency ESM + CJS; `systemOne`, `choice`, `score`, `noul`; MCP server |
+
+The `noul` primitive differs by design: Python returns `P(true)` for a yes/no
+statement, Node returns an out-of-domain rejection decision, and the edge demo
+returns a bounded negation-aware lexical score with explicit abstention.
+
+## Installation
+
+Until the first registry publish lands, install from a wheel built in this checkout. The
+Central M&A toolkit consumes O-Laya the same way (a hash-pinned vendored wheel).
+
+```bash
+uv build --wheel --out-dir dist                      # dist/leio_decision-0.3.2-py3-none-any.whl
+uvx --from dist/leio_decision-0.3.2-py3-none-any.whl leio-decision   # MCP server straight from the wheel
+uv pip install dist/leio_decision-0.3.2-py3-none-any.whl             # into a venv: provides `leio-decision`, `leio`, `leio-mcp`, `olaya-mcp`
+```
+
+The wheel's base dependencies include torch (about 2 GB); `olaya.pii` alone is standard library.
+
+Registry installs, live once the release workflow has published `leio-decision` to PyPI and
+`leio-decision` to npm (wired in `release.yml`; first publish pending):
+
+```bash
+uvx leio-decision            # Python MCP server, no install step
+npx leio-decision            # Node MCP server, zero dependencies
+pip install leio-decision    # Python SDK
+```
+
+From source (no pre-built artefacts are committed):
+
+### Python
+
+```bash
+uv venv
+uv pip install --index-url https://download.pytorch.org/whl/cpu torch   # or a CUDA/MPS build
+uv pip install -e ".[dev]"
+.venv/bin/python -m pytest -q
+```
+
+```python
+from olaya import OLaya
+
+olaya = OLaya()  # random-init encoder unless weights_path= points at a checkpoint
+
+result = olaya.system_one(
+    state={"service": "billing-worker", "error": "Deadlock detected in PostgreSQL cluster."},
+    questions={
+        "triage": {"type": "concept", "root": "INCIDENT:ROOT",
+                   "instructions": "Classify the operational incident."},
+        "is_data_issue": {"type": "subsumes", "concept": "INCIDENT:DATA"},
+        "urgency": {"type": "score", "criteria": ["low", "medium", "urgent", "critical"]},
+        "escalate": {"type": "noul", "instructions": "Should on-call be paged?"},
+    },
+)
+
+triage = result.answers["triage"]
+triage.curie                    # a leaf under INCIDENT:ROOT, never the root itself
+triage.lineage                  # ["INCIDENT:ROOT", "INCIDENT:DATA", "INCIDENT:DB_DEADLOCK"]-style path
+triage.candidate_probabilities  # distribution over the competing leaves, sums to 1
+triage.probabilities            # marginal P(C) for every concept in the active subgraph
+triage.axioms_verified          # True iff monotonicity and exclusion hold on the output
+result.model                    # provenance: checkpoint hash, or "untrained-random-init"
+```
+
+Unknown `root` / `subsumes` concepts and malformed `choice` criteria raise `ValueError`. `choice`
+accepts either a list of option names or a `{name: description}` dict.
+
+To train a head on your own ontology and get a checkpoint the engine will load:
+
+```bash
+.venv/bin/python scripts/train_real_ontologies.py --domain schemaorg \
+  --ontology-path docs/public/ontologies/schemaorg_ontology.json --epochs 5 --device cpu
+```
+
+Training splits source observations into disjoint train / validation /
+calibration / test groups before task expansion, selects the checkpoint on
+validation, fits temperature on calibration, and reports accuracy, NLL, ECE and
+Brier on test. See [evaluation integrity](spec/evaluation-integrity.md) for
+what those numbers can and cannot establish.
+
+### Rust
+
+```toml
+[dependencies]
+olaya-core = { path = "crates/olaya-core" }            # add features = ["onnx"] for the neural scorer
+```
+
+```rust
+use olaya_core::{OntologyBatchBuilder, OlayaEngine};
+
+let ttl = br#"
+    @prefix ex: <http://example.org/> .
+    @prefix owl: <http://www.w3.org/2002/07/owl#> .
+    @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+    ex:DBDeadlock a owl:Class ; rdfs:label "Database Deadlock" .
+"#;
+
+let batch = OntologyBatchBuilder::from_owl_bytes(ttl, owl_fast_core::RdfFormat::Turtle)?;
+let engine = OlayaEngine::new(batch)?;              // validates the schema, builds the index once
+let result = engine.system_one("Fatal deadlock detected on PostgreSQL", 8)?;
+println!("{} ({:.3})", result.selected_curie, result.confidence);
+```
+
+`cargo test --workspace` runs the suite. `cargo run --release -p olaya-core --bin bench_arrow`
+measures lexical routing latency on your machine; we do not publish numbers from
+other machines here.
+
+`owl-fast-core::fca` builds a concept lattice from an object/attribute context
+(Close-by-One over dense bitsets) and converts it into ontology entities the
+engine can load:
+
+```rust
+use owl_fast_core::fca::{ConceptLattice, FormalContext};
+
+let ctx = FormalContext::from_named_pairs(&[
+    ("item_1", "perishable"),
+    ("item_1", "cold_chain"),
+    ("item_2", "gtin_tagged"),
+]);
+let lattice = ConceptLattice::build(ctx);
+let entities = lattice.to_ontology_entities("FCA_PRODUCT");
+let batch = olaya_core::OntologyBatchBuilder::from_entities(&entities)?;
+```
+
+### Node / TypeScript
+
+```bash
+cd packages/olaya-node && bun install && bun test && bun run build
+```
+
+```typescript
+import { OntologyDAG, OLaya } from "leio-decision";
+
+const dag = new OntologyDAG([
+  { id: 0, curie: "INCIDENT:DATA", label: "Data & Storage Incident", parents: [], disjointWith: [1], synonyms: ["database"] },
+  { id: 1, curie: "INCIDENT:BILLING", label: "Billing Incident", parents: [], disjointWith: [0], synonyms: ["payment"] },
+]);
+
+const decision = await new OLaya(dag).systemOne("Payment webhook timeout on credit card charge");
+decision.selectedConcept.label; // "Billing Incident"
+decision.axiomsVerified;        // true
+```
+
+### MCP servers
+
+Both the Python and Node packages expose a Model Context Protocol server over
+stdio. Neither is published to a registry yet; run them from a checkout:
+
+```bash
+.venv/bin/olaya-mcp                       # Python runtime
+cd packages/olaya-node && bun run src/cli.ts   # Node runtime
+```
+
+Tools: `olaya_ground` (concept grounding with lineage and `axioms_verified`),
+`olaya_subsumes`, `olaya_choice`, `olaya_score`; the Python server also offers
+`olaya_extract_and_ground` (JSON-LD / GTIN extraction then grounding). Bundled ontologies are the JSON files under
+`src/olaya/data/` and `docs/public/ontologies/`; the resource descriptions state
+the actual class counts. Confidence is entropy-based, not calibrated, unless the
+Python server loads a checkpoint with a fitted temperature.
+
+## TBox-bound workflows
+
+The Python JSON workflow compiler and interpreter bind workflow and decision
+types, option classes, terminal intent properties, and declared
+infrastructure / application resources to a supplied ontology. It emits JSON-LD
+execution records with TBox identity and hash plus decision provenance, and
+`olaya.workflow_replay.replay_workflow` re-checks a recorded trace against the
+compiled policy without model inference. See the
+[version 1 contract](spec/workflow-dsl-proposal.md) and the
+[storage example](examples/workflows/storage.json):
+
+```bash
+python examples/workflows/run_storage.py
+```
+
+Terminal intents are records, not actions: the workflow layer never dispatches
+goods or calls infrastructure. Replay checks policy consistency; content hashes
+are not signatures.
+
+## HTTP edge demo
+
+`POST /api/systemone` at <https://public-nine-jade-58.vercel.app/api/systemone>
+runs [docs/public/api/systemone.js](docs/public/api/systemone.js): bounded
+lexical matching over `choice`, `score` and `noul` with explicit abstention.
+It does not load an ontology DAG, trained weights, or the projection kernel.
+The contract and its 34 regression cases are in
+[spec/systemone-reliability.md](spec/systemone-reliability.md) and
+`tests/systemone-edge.test.mjs`.
+
+## Claude Desktop extension
+
+`extensions/claude-desktop` packages the Python runtime, the workflow tools and
+three skills as an `.mcpb` for macOS Apple Silicon. The build script expects a
+checkpoint at `models/olaya_decision_model.pt`; none is committed, so you must
+train or supply one first. See
+[extensions/claude-desktop/README.md](extensions/claude-desktop/README.md).
+
+## OWL 2 RL coverage
+
+`src/olaya/owl2_rl.py` forward-chains the W3C OWL 2 RL rules over the TBox and an
+optional ABox of named individuals, to a fixpoint, counting every firing:
+
+- Schema: `scm-cls`, `scm-sco`, `scm-eqc1/2`, `scm-dco`, `scm-int`, `scm-uni`,
+  `owl:disjointUnionOf`, `scm-spo`, `scm-dom1/2`, `scm-rng1/2`, unsatisfiability.
+- Instance: `cax-sco`, `cax-eqc1/2`, `cax-dw`, `cls-int1`, `cls-nothing2`,
+  `prp-dom`, `prp-rng`, `prp-spo1`, `prp-spo2` (property chains), `prp-inv1/2`,
+  `prp-symp`, `prp-trp`, `prp-fp`, `prp-ifp`, `prp-pdw`, `prp-asyp`, `prp-irp`,
+  and the equality rules `eq-sym`, `eq-trans`, `eq-rep-s/o`, `eq-diff1`
+  (`owl:sameAs` is kept as an equivalence class of individuals).
+- Not supported: restrictions (`someValuesFrom`, `allValuesFrom`, `hasValue`,
+  cardinality), `complementOf`, `oneOf`, `hasKey`, n-ary `AllDisjoint*` /
+  `AllDifferent` lists, negative property assertions, datatypes and literals.
+
+Inconsistencies are returned as a list (`abox_consistency_report`), never raised.
+The per-rule status table, with reasons, is in [spec/OWL2RL.md](spec/OWL2RL.md).
+The closure feeds the projection kernel so that inferred subsumption and
+disjointness are enforced, not only asserted ones.
+
+## Repository layout
+
+```
+olaya/
+├── Cargo.toml                  # Rust workspace
+├── pyproject.toml              # Python package + ruff/pytest config
+├── spec/
+│   ├── AXIOMS.md               # The shared axiom-projection kernel, normative
+│   ├── axioms_golden.json      # Test vectors every runtime must reproduce
+│   ├── workflow-dsl-proposal.md, workflow-vocabulary.jsonld
+│   └── systemone-reliability.md, evaluation-integrity.md
+├── crates/
+│   ├── olaya-core/             # Arrow-native engine, router, axioms, optional ONNX scorer
+│   ├── olaya-wasm/             # Browser build of router + kernel
+│   ├── owl-fast-core/          # OWL / RDF / SKOS extraction on oxrdf, FCA engine
+│   └── mycelia-ort-utils/      # ONNX Runtime session helpers
+├── src/olaya/                  # Python engine, model, training, calibration, workflows, MCP
+├── packages/olaya-node/        # leio
+├── benchmarks/                 # OAEI runner, latency scripts, results/
+├── tests/fixtures/oaei/        # Vendored OAEI Conference ontologies + reference alignments
+├── models/*.arrow              # Compiled ontology fixtures (no model weights)
+└── extensions/claude-desktop/  # MCPB bundle and skills
+```
+
+## Development
+
+CI (`.github/workflows/ci.yml`) runs on every pull request: `cargo fmt --check`,
+`cargo clippy -D warnings` (with and without `onnx`), `cargo test`, a wasm32
+build, `ruff check` + `ruff format --check`, `pytest`, a check that the golden
+vectors are regenerated, `tsc --noEmit`, `bun test`, `bun run build`, and the
+edge regression suite.
+
+To change the axiom kernel, edit the Python reference, run
+`python scripts/gen_axiom_golden.py`, and bring the other runtimes to green
+against the regenerated file.
+
+## Roadmap
+
+1. **A labelled corpus.** The next accuracy gate is a frozen, human-labelled set
+   with full-ontology retrieval, no-answer cases, and source-document separation.
+   Until it exists, every quality claim here says "lexical".
+2. **A committed checkpoint.** Train the Python head on that corpus, commit the
+   checkpoint via a release asset, and report lexical versus neural on the same
+   split with the same latency budget.
+3. **OAEI beyond lexical.** Add structural and definition-based matching to the
+   Conference matcher and re-run the same harness.
+4. **Runtime convergence.** One scorer implementation generated for Rust, WASM
+   and TypeScript instead of parallel copies.
+
+## License
+
+MIT. Vendored OAEI data retains its upstream terms; see
+`tests/fixtures/oaei/README.md`.
+
+## Release builds
+
+Release builds are opt-in: include `[release]` in a commit pushed to `main`, or
+dispatch the Release workflow with `build_release=true`. See
+[release instructions](docs/release.md) for Python wheels, npm packages,
+complete Claude Desktop bundles, and Keychain signing.

leio_decision-0.3.2.dist-info/RECORD

@@ -0,0 +1,43 @@
+olaya/__init__.py,sha256=2ikwy60EVhkvR0K2vfZfZDGWvNZCsusRKkQDJjWlVZo,1958
+olaya/axioms.py,sha256=50MQW_f88RlL2e0Zhn8tqpp0qu7iwGNTCqpitVvgBb8,15632
+olaya/calibration.py,sha256=_r5qDXKfnn4kU7LkrIotlT-mHBwZfsH9T7-LjaaO6ok,6820
+olaya/candidate_router.py,sha256=K46F1hsNAm3UTrXDctRV3wizD7TcQlQXCURE05FOW3o,5064
+olaya/category_theory.py,sha256=7J4QWLYT7FSSrXBYIveFt2iMbDN3T5O4YH2df1dGviM,13275
+olaya/data_gen.py,sha256=XT0Fmm70pN3lZsFn3ydQ4p9BwcrpU-BAh1SB-dQHPI4,13564
+olaya/distilled_head.py,sha256=OjKSPQsgyQGU9WkQ3WKujuo9Id-ilYFzQdn01YKFQAs,19893
+olaya/embeddings.py,sha256=f1qe9ijX59nIOl38S-64LmV03cF4FyaDEdedd-YPDqU,12138
+olaya/engine.py,sha256=22eb2y2PNAKO5BatC542EnuJvn6-PTFnBJ1SBtoOUVo,24790
+olaya/evaluation.py,sha256=dRrU2XfXE4a4Ch0jE1-4Byze0-GyLdPM2VTTMPqRWeM,4719
+olaya/hard_negative_sampler.py,sha256=JrImFQhRcJuXnPw-DrrmkgwhMnNG0p-rCKU6bbXLBjk,4309
+olaya/model.py,sha256=c8Tu7fKZU7nSfADUQXnqUbAc27PPSjjH5zXsTyrmQbM,6172
+olaya/ontology.py,sha256=MO-OA6j6h0gnoe3DXDjxI96n4BpeDdP6431W7ZGCcV8,27953
+olaya/owl2_rl.py,sha256=GLjisHoYj-h16RUu9cRJPk8SsDmaRWGQuWOqdbBZiGw,27443
+olaya/pii.py,sha256=Pk6UKEPQQ534KeP530fmp47qQqXK--iKEcG8yHRma5A,15641
+olaya/real_abox.py,sha256=q2687bb1peW-5WGorlDAEDicdbHMbEQAW-RoJpOUL5s,8692
+olaya/real_ontology_train.py,sha256=GMHj8mgB5l8g1o2yj3O_Or35ByrALUnd6jD-d_uywBU,23411
+olaya/sequence.py,sha256=-aa_h1xDzH6KtqL-7ZkovoHA5a1PCE5imcnZo9vHajE,4546
+olaya/tokenizer.py,sha256=866G92zQ0UsfJCftAMQfP_LWVFHbcClk019wehrrPuo,976
+olaya/train.py,sha256=0Rk1g5gBqXduAyBsIzq567yXED2HS4wStdi_Nr6N1mo,24239
+olaya/webmcp.py,sha256=TUDug72wFXtU3GNWgLHYGGTLFKy-YBMOMlfa96Y0mKo,42152
+olaya/workflow.py,sha256=huchByjsWPLHRlyp2VcYr92L2URxROj-iOrT5I7b3tA,23016
+olaya/workflow_jsonld.py,sha256=1p0tuJHpjLu79Cn8CQrJUDZf3R0z-kSQtxF_NNr7EO0,11611
+olaya/workflow_replay.py,sha256=Xqe3Yzjzvwa6PL0FM8fxBklwb5EjJYBnvp5IagJ9ZXU,10407
+olaya/benchmarks/__init__.py,sha256=7EPMhnDJwnBgEut8TOH7X7hjqXWYzb4WyWioQkAAozs,1134
+olaya/benchmarks/analysis.py,sha256=595iCxenN28DGX8yDfSu354kMmhiGMlfb3Nks5RHxnY,14576
+olaya/benchmarks/features.py,sha256=BQR-cSwIMHDJZPRTOtLQBLLQbZtk7jxPtIkab-n6lxs,21218
+olaya/benchmarks/learned.py,sha256=jxU_KAsXWZHbrfvbMdjo8AtvLBEfU4kWd960PbRBv18,30543
+olaya/benchmarks/llm_judge.py,sha256=77fyGPbF3kC9p9-W86TMZyKWgPB2y5fJYb4oFp44tJI,34536
+olaya/benchmarks/oaei.py,sha256=8i6Ck1oCzA0xqftpKV4YJ7TqDNtdQxfqfcmoRxPYhzU,67264
+olaya/benchmarks/reranker.py,sha256=UUdhfqzd0G1t4yycAUpcthOVE22FIGNoU78IdmPG5uU,25443
+olaya/benchmarks/structural.py,sha256=ztr4eDovOY5OP7VgWzheJtR1BpH2nVdoxUxZOa9DgiI,21037
+olaya/data/bfo_ontology.json,sha256=zpiW8nTwMgBfhxzXPrfHxyj-RRGBK3UVRKP7eJBsKEs,12482
+olaya/data/doid_ontology.json,sha256=DSjvi96yOdSG_dGqa3FION_8KoTFlU62IMO8hbInfXY,314595
+olaya/data/gs1_ontology.json,sha256=3nbbOeuyMyRl1UQIh7X5Fn2sQ7f7ud26Pw9QRtKyQ_g,21596
+olaya/data/incident_ontology.json,sha256=wvwX8j0tThDDrL4saAH6IDagER4BR-MSK58BI853bpM,4505
+olaya/data/leio_ontology.json,sha256=RP1wqvBqPm68b_DdDJovD24tIyH9q2qDlk3xCrBxTsk,16401
+olaya/data/schemaorg_ontology.json,sha256=q8URLTErftg2I0V4m3EcCvh2p6BATEyEqztJIGClLxQ,313223
+olaya/data/skos_ontology.json,sha256=qN9-WSntrUjKAggjH_NsZhdu3eNwG91ZE6YhvE45FF0,1585
+leio_decision-0.3.2.dist-info/METADATA,sha256=A0SUZeB1aJ2NI44Er76Lmpf-3Z8IVlZ7bjf_0ujHbus,22884
+leio_decision-0.3.2.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+leio_decision-0.3.2.dist-info/entry_points.txt,sha256=afdmdCullFPdRhtl1FUJ8UTOaUEz_xN1nwm_Ta65DZo,162
+leio_decision-0.3.2.dist-info/RECORD,,

leio_decision-0.3.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

leio_decision-0.3.2.dist-info/entry_points.txt

@@ -0,0 +1,6 @@
+[console_scripts]
+leio = olaya.webmcp:main
+leio-decision = olaya.webmcp:main
+leio-mcp = olaya.webmcp:main
+olaya = olaya.webmcp:main
+olaya-mcp = olaya.webmcp:main

olaya/__init__.py

@@ -0,0 +1,65 @@
+"""O-Laya: Ontology-Grounded System 1 Decision Model."""
+
+from olaya.axioms import calibrate_and_project_distribution, enforce_subsumption_monotonicity
+from olaya.candidate_router import CandidateRouter
+from olaya.ontology import Concept, Individual, ObjectProperty, Ontology, create_incident_ontology
+from olaya.owl2_rl import OWL2RLReasoner, abox_consistency_report
+from olaya.pii import ObfuscationMode, ObfuscationResult, PIIEntity, PIIObfuscator
+from olaya.real_abox import RealABoxFact, load_atlas_real_abox
+from olaya.sequence import SequenceBundle, build_ontology_sequence
+from olaya.workflow import CompiledWorkflow, compile_workflow, run_workflow
+from olaya.workflow_replay import replay_workflow
+
+try:
+    from olaya.calibration import CalibrationMetrics, compute_ece, fit_temperature
+    from olaya.engine import (
+        ChoiceAnswer,
+        ConceptAnswer,
+        NoulAnswer,
+        OLaya,
+        ScoreAnswer,
+        SubsumesAnswer,
+        SystemOneResult,
+    )
+    from olaya.model import OntologyDecisionHead, OntologyDecisionModel
+    from olaya.train import train_olaya
+except ImportError:
+    pass
+
+__all__ = [
+    "ObfuscationMode",
+    "ObfuscationResult",
+    "PIIEntity",
+    "PIIObfuscator",
+    "CompiledWorkflow",
+    "compile_workflow",
+    "run_workflow",
+    "replay_workflow",
+    "Ontology",
+    "Concept",
+    "Individual",
+    "ObjectProperty",
+    "OWL2RLReasoner",
+    "abox_consistency_report",
+    "create_incident_ontology",
+    "CandidateRouter",
+    "OntologyDecisionModel",
+    "OntologyDecisionHead",
+    "OLaya",
+    "SystemOneResult",
+    "ConceptAnswer",
+    "SubsumesAnswer",
+    "ChoiceAnswer",
+    "ScoreAnswer",
+    "NoulAnswer",
+    "calibrate_and_project_distribution",
+    "enforce_subsumption_monotonicity",
+    "build_ontology_sequence",
+    "SequenceBundle",
+    "train_olaya",
+    "compute_ece",
+    "fit_temperature",
+    "CalibrationMetrics",
+    "RealABoxFact",
+    "load_atlas_real_abox",
+]