Unicode Logic Kit

Parse OWL 2 Manchester Syntax text, three ways. ``kind="concept"`` (default): a class expression via ``dl.parse_manchester`` — returns the parsed concept's unicode rendering plus a ``to_manchester`` round-trip (``dl.to_manchester(dl.parse_manchester(text))``), so a caller can confirm ``text`` normalises the way it expects. ``kind="axiom"``: a ``SubClassOf``/``EquivalentTo`` axiom via ``dl.parse_manchester_axiom``. ``kind="role_axiom"``: a ``SubPropertyOf``/``Characteristics: Transitive`` RBox axiom via ``dl.parse_manchester_role_axiom`` (see :mod:`unicode_logic_kit.dl.tableau`'s "Role hierarc…

Does ``tbox`` entail ``sub ⊑ sup`` (every model puts ``sub`` in ``sup``)? Returns ``{"ok": True, "subsumes": bool, "sub_unicode": str, "sup_unicode": str}``.

Translate a discourse representation structure into provable FOL. ``format="box"`` parses the compact box notation (``[x, y | Farmer(x), Donkey(y), Owns(x, y)] -> [ | Beats(x, y)]``), ``format="sbn"`` the documented Parallel-Meaning-Bank SBN subset. ``resolve_pronouns=True`` runs accessibility-respecting anaphora resolution first (PRONOUN-marked referents; ambiguity/no-candidate failures surface as structured errors) and reports each resolution. The result is the standard translation — donkey-sentence universals come out right — as a formula ``prove``/``check_formula`` accept.

The full counterexample-explanation view for ONE molecule — the piece a bare classifier does not give you (a plain model checker returns only proved/not-proved, never a witness). Runs the identical check :func:`check_molecule` does (same holds/ exhausted/steps/witness/failing_conjunct), plus the molecule's own structure rendered for a human/LLM to read at a glance: every atom grouped by element type, every other fact about each atom (hydrogen count, charge, chirality, and — when ``include_computed=True`` — ring/aromaticity/connectivity), and the full bond list. Reading the failing conjunct ag…

A countermodel to premises |= formula, with an English explanation.

Extract the inferred vocabulary (Signature) of a formula set. The result dict is ``fol.Signature.from_formulas(...)``'s rich form — predicates/functions with arities and inferred sorts, constants, sort names — ready to pass back as ``check_formula``'s / ``diagnose``'s ``signature`` argument to hold FURTHER generations to this vocabulary: the whole result, ``{"ok": True, "signature": {...}}``, or just its ``signature`` value are both accepted.

Retrieve the kit's syntax specification — look up the rule you broke. Topics: ``overview`` (dialects and the mistake everyone makes), ``naming`` (what makes a symbol a variable / constant / predicate / function, and how TPTP inverts the convention), ``dialects``, ``operators`` (precedence table), ``quantifiers`` (scope rules), ``counting`` (the cardinality quantifier and why it replaces long existential chains), ``chemistry`` (molecule-as-structure signature), ``description-logic`` (the ALC glyph and OWL Manchester concept syntaxes the ``dl_*`` tools accept, plus their TBox/ABox JSON row shap…

Registry introspection: what can decide, and what runs by default.

Enumerate the logic-to-logic edges the translate tool can follow. The kit's own comorphism registry (BFS-composable); after a Hets bridge refresh the dynamic ``hets:<Name>`` edges appear here too. ``logics`` is every label ``translate`` accepts as ``from_logic`` / ``to_logic``. ``lossy`` edges do not preserve the full source semantics; ``note`` carries the conventions a consumer must know. ``guarantee`` is what the edge preserves (``faithful`` / ``validity`` / ``satisfiability`` / ``lossy``, or ``null`` when the edge declares none — not the same as faithful). ``options`` are the ``translate``…

Translate a SMILES string into the finite structure a definition is checked against — lets the caller SEE what it is generating formulas for. Args: smiles: a SMILES string (e.g. ``"CCO"`` for ethanol). naming: ``"chemlog"`` (default — ``c``, ``bSINGLE``, ``has_1_hs``, ...; what :func:`check_molecule` and friends require) or ``"paper"`` (the human-readable prose spelling — ``c``, ``singleBond``, ``has1H``, ...; use this only to reproduce a worked example written that way, never to feed a ``dialect="tptp_bare"`` formula, which always comes back …

Rewrite a formula into a normal form. ``form``: ``nnf`` / ``pnf`` / ``cnf`` / ``dnf`` (equivalence-preserving), ``canonical`` (the eval layer's comparison normal form: alpha-renaming, commutativity/associativity, duplication, double negation quotiented out), ``tseitin_cnf`` (EQUISATISFIABLE only — fresh definitional atoms), ``skolemize`` (satisfiability-preserving — existentials become Skolem terms). The ``semantics`` key states which of those relations the result bears to the input, and ``is_horn`` reports whether the input's clausal form is Horn (``None`` where that computation is not appli…

Parse formula text (dialect auto-detected) to the kit's JSON AST.

Nilsson-style probabilistic entailment: tightest bounds on P(conclusion). Each constraint dict: ``{"formula": <text>}`` plus either ``"probability"`` (pins the value exactly) or ``"lower"``/``"upper"`` (interval; missing ends default to 0/1), plus optional ``"given"`` (formula text — makes it the conditional ``P(formula | given)``). Probabilities travel as ``"7/10"`` / ``"0.7"`` strings, ints, or JSON numbers (read decimally). Propositional only; the answer is the EXACT ``[lower, upper]`` interval (fraction strings, with float shadows for convenience) entailed by the constraint polytope — ``l…

Exact ProbLog-style query under Sato's distribution semantics. ``facts``: ``{"atom": <ground atom text>, "prob": <"3/10" | 0.3 | …>}`` — independent Bernoulli facts. ``rules``/``hard_facts``: definite clauses (a ground atom, or ``∀``-quantified ``body → head`` with a positive conjunctive body and a single positive head atom — anything else is refused loudly). The goal may use ∧/∨/¬ and ∀/∃ over the program's finite constants; negation reads closed-world against each total choice's least model (the ProbLog convention). The result is the exact probability as a fraction string (float shadow incl…

Decide premises |= conclusion; the Verdict dict carries provenance.

Render a formula in another concrete syntax. ``to``: ``unicode`` / ``tptp`` / ``prover9`` / ``latex`` / ``smtlib`` (a standalone SMT-LIB2 problem: ``(set-logic ...)``, the declaration preamble, and one ``(assert ...)`` — no premises through this tool; use ``unicode_logic_kit.atp.z3_input.to_smtlib`` directly for an entailment with premises) / ``casl`` (a bare CASL formula via ``formula_to_casl``) / ``json`` (the versioned ``serialize`` envelope — the only target whose ``rendered`` is a dict, not a string) / ``english`` (deterministic verbalization). A family without the requested rendering su…

Mechanically repair what CAN be repaired; report the rest. The counterpart to ``diagnose`` (where you are the fixer): this fixes the two failure shapes that have one right answer, so they cost you no attempt. A name no symbol class of this dialect accepts (a chemical name with digits, commas or hyphens) is renamed to a legal predicate, with the original kept in ``names`` — nothing is lost. A free variable is reported and, with ``close_free_variables=True``, closed. What it deliberately does NOT do is bracket a formula that mixes ∧ and ∨ at the same level: the readings differ and choosing one…

Corpus-level NL->FOL metrics over aligned prediction/reference lists. The six-key dict of ``eval.compute_fol_metrics``: ``exact_match``, ``equivalence_accuracy`` (honest — undecided pairs are NOT counted as refuted), ``mean_partial_credit``, ``parse_failure_rate``, ``solver_unknown_rate``, ``n``. ``converses`` (same JSON shape as ``compare_formulas``'s own parameter — see its docstring) is forwarded to every pair; when non-empty the dict gains a seventh key, ``converse_matched_rate`` — the fraction of pairs the solver proved equivalent USING the declared axioms, separately visible from (and s…

Shrink a class definition for model checking, and report exactly what changed — the fix for the standard timeout cause (a redundant O(n²) pairwise-inequality chain, e.g. 780 literals for "at least 40 carbons"). Two independent, differently-scoped rewrites are applied (see :mod:`unicode_logic_kit.fol.simplify_check`'s own module docstring for the full soundness argument of each): 1. :func:`~unicode_logic_kit.fol.simplify_check.simplify_for_checking` (``all_different=True`` by default here — see the module docstring) — a conservative, EVERYWHERE-applicable pass: drops trivial ``t=t`` …

Translate between logics over the comorphism registry — and pass every entry of the returned ``axioms`` as a SEPARATE premise next to ``result`` (never conjoined onto it, never dropped), or the translated formula answers a different question and a valid formula comes back refuted. The result is ``{result, unicode, axioms, axioms_unicode, guarantee, source, target, path, lossy, note}``. ``result`` is the translated term (JSON AST) and ``unicode`` its text; ``axioms`` are the side conditions of the translation, already in the TARGET logic (``axioms_unicode`` is the same list as text, entry for …

Decide a propositional formula by full enumeration. ``logic``: ``classical`` (values {0,1}), ``K3`` (strong Kleene) or ``LP`` (Priest, paraconsistent designation). Quantified formulas and tables beyond 4096 rows are refused as structured errors. ``rows`` aligns each assignment with ``atoms``; ``markdown`` is the rendered table for direct display.

Render a formula as deterministic English (fol.to_english).