engineering-argument-language 3.2.3__py3-none-any.whl

eal/propositions.py

@@ -0,0 +1,231 @@
+"""EAL/3 scalar propositions and versioned method/input correspondence.
+
+Metadata asserts an engineering interpretation. Checks establish correspondence
+within that interpretation; they cannot authenticate a sensor or interpret prose.
+"""
+from __future__ import annotations
+
+from dataclasses import asdict, replace
+from copy import deepcopy
+from fractions import Fraction
+import hashlib
+import json
+import math
+import operator
+import re
+
+from .model import Proposition, Predicate
+from .expressions import expression_errors, predicate_paths, evaluate_expression, format_expression
+from .builtin_methods import BUILTIN_SPECS
+
+SCHEMA = 'EAL/typed-input/1'
+# Unit scales are exact rational multiples of the declared base unit. Absolute
+# temperatures and offset conversions are deliberately outside this fragment.
+UNITS = {
+    '1': ('dimensionless', '1'),
+    'Pa': ('pressure', '1'), 'kPa': ('pressure', '1000'), 'MPa': ('pressure', '1000000'),
+    's': ('time', '1'), 'ms': ('time', '0.001'), 'us': ('time', '0.000001'),
+    'ns': ('time', '0.000000001'), 'min': ('time', '60'), 'h': ('time', '3600'),
+    'm': ('length', '1'), 'mm': ('length', '0.001'), 'cm': ('length', '0.01'), 'km': ('length', '1000'),
+    'kg': ('mass', '1'), 'g': ('mass', '0.001'),
+    'K': ('temperature_difference', '1'), 'delta_degC': ('temperature_difference', '1'),
+    'm/s': ('velocity', '1'), 'km/h': ('velocity', '5/18'),
+    'm3/s': ('volumetric_flow', '1'), 'L/s': ('volumetric_flow', '0.001'),
+}
+QUANTITIES = {name: name for name in ('pressure', 'time', 'length', 'mass',
+                                     'temperature_difference', 'velocity', 'volumetric_flow', 'dimensionless')}
+QUANTITIES.update(probability='dimensionless', proposition='dimensionless')
+# Each path denotes a specified statistic, not an arbitrary result field. basis
+# means the unit of the measured quantity; boolean results have no numeric unit.
+# These read-only discovery views derive from the same versioned specifications
+# used to construct the registered MethodContracts.
+OUTPUTS = {mode: dict(spec.outputs) for mode, spec in BUILTIN_SPECS.items() if spec.outputs}
+QUERY_FIELDS = {mode: spec.query_fields for mode, spec in BUILTIN_SPECS.items() if spec.outputs}
+_COMPARISONS = {'==': operator.eq, '!=': operator.ne, '<': operator.lt,
+                '<=': operator.le, '>': operator.gt, '>=': operator.ge}
+
+
+def describe_bindings(registry=None):
+    """Machine-readable, versioned discovery of the implemented closed fragment."""
+    from .methods import default_registry
+    registry = registry or default_registry()
+    return {'schema': SCHEMA, 'registry_fingerprint': registry.fingerprint, 'quantities': dict(QUANTITIES),
+            'units': {name: {'dimension': dim, 'base_scale': scale} for name, (dim, scale) in UNITS.items()},
+            'methods': registry.describe(),
+            'envelope_fields': ['schema', 'method', 'subject', 'quantity', 'unit', 'scope',
+                                'valid_from', 'valid_until', 'payload'],
+            'interval': 'half-open [valid_from, valid_until); input must contain claim interval',
+            'interpretation': 'metadata correspondence; physical relevance and prose correspondence remain asserted'}
+
+
+def _contract(method, registry=None):
+    from .methods import default_registry
+    return (registry or default_registry()).get(method)
+
+
+def _output_type(method, path, registry=None):
+    contract = _contract(method, registry)
+    return contract.output_type(path) if contract else None
+
+
+def proposition_errors(proposition: Proposition, method: str | None = None, registry=None):
+    """Static shape/type errors without reading observations."""
+    from .semantics import parse_time, _check_json_resources
+    errors = []
+    for key in ('subject', 'scope'):
+        value = getattr(proposition, key)
+        if not value.strip() or len(value) > 4096:
+            errors.append(f'{key} must be nonblank and at most 4096 characters')
+    if proposition.quantity not in QUANTITIES:
+        errors.append(f'Unknown quantity {proposition.quantity!r}')
+    if proposition.unit not in UNITS:
+        errors.append(f'Unknown unit {proposition.unit!r}')
+    elif proposition.quantity in QUANTITIES and UNITS[proposition.unit][0] != QUANTITIES[proposition.quantity]:
+        errors.append(f'Unit {proposition.unit!r} does not measure quantity {proposition.quantity!r}')
+    try:
+        if parse_time(proposition.valid_from) >= parse_time(proposition.valid_until):
+            errors.append('Proposition valid_from must precede valid_until')
+    except (ValueError, TypeError):
+        errors.append('Proposition interval requires ISO-8601 timestamps with timezones')
+    expected = proposition.result.expected
+    if proposition.result.expression is None and (not isinstance(expected, (bool, int, float)) or isinstance(expected, float) and not math.isfinite(expected)):
+        errors.append('A scalar proposition result must compare a finite number or boolean')
+    if isinstance(expected, bool) and proposition.result.operator not in ('==', '!='):
+        errors.append('Boolean proposition results support only == and !=')
+    try:
+        _check_json_resources(proposition.query)
+        json.dumps(proposition.query, allow_nan=False).encode('utf-8')
+    except (ValueError, TypeError, UnicodeError, RecursionError):
+        errors.append('Proposition query must be finite JSON')
+    if method is not None:
+        from .methods import schema_errors
+        contract = _contract(method, registry)
+        if contract is None:
+            errors.append(f'Unknown registered method {method!r}')
+            return errors
+        errors.extend(schema_errors(proposition.query, contract.query_schema, 'query'))
+        if proposition.result.expression is not None:
+            errors.extend(expression_errors(proposition.result.expression, contract.output_schema))
+            paths = predicate_paths(proposition.result)
+            if not paths:
+                errors.append('A proposition result must depend on a declared method output')
+            for path in paths:
+                if contract.output_type(path) is None:
+                    errors.append(f'Method {method!r} has no typed result {path!r}')
+        else:
+            output = contract.output_type(proposition.result.path)
+            if output is None:
+                errors.append(f'Method {method!r} has no typed result {proposition.result.path!r}')
+            elif (output == 'boolean') != isinstance(expected, bool):
+                errors.append('Proposition result type does not match the method output type')
+        if proposition.quantity not in contract.quantities:
+            errors.append(f'Method {method!r} does not accept quantity {proposition.quantity!r}')
+    return errors
+
+
+def prepare_binding(proposition: Proposition, method: str, evidence_id: str, value, registry=None):
+    """Check complete input correspondence before passing a payload to a method."""
+    from .semantics import parse_time
+    contract = _contract(method, registry)
+    if contract is None:
+        return None, {"status": "unsupported", "reasons": [f"Unknown registered method {method!r}"]}
+    fields = {'schema', 'method', 'subject', 'quantity', 'unit', 'scope', 'valid_from', 'valid_until', 'payload'}
+    trace = {'evidence_id': evidence_id, 'method': contract.identifier, 'proposition': asdict(proposition),
+             'method_contract': contract.describe(),
+             'prose_verified': False, 'physical_interpretation_verified': False}
+    reasons = []
+    if not isinstance(value, dict) or set(value) != fields:
+        return None, {**trace, 'status': 'unsupported', 'reasons': ['Typed input requires exactly the declared envelope fields']}
+    for key, expected in (('schema', SCHEMA), ('method', contract.identifier), ('subject', proposition.subject),
+                          ('quantity', proposition.quantity), ('scope', proposition.scope)):
+        if value.get(key) != expected:
+            reasons.append(f'Typed input {key} does not match the proposition or method')
+    unit = value.get('unit')
+    if not isinstance(unit, str) or unit not in UNITS or UNITS[unit][0] != QUANTITIES[proposition.quantity]:
+        reasons.append('Typed input unit is incompatible with the proposition quantity')
+    if contract.exact_unit and unit != proposition.unit:
+        reasons.append('This method embeds dimensional query constants and requires the exact proposition unit')
+    try:
+        start, end = parse_time(value['valid_from']), parse_time(value['valid_until'])
+        if start >= end or start > parse_time(proposition.valid_from) or end < parse_time(proposition.valid_until):
+            reasons.append('Typed input interval does not contain the whole proposition interval')
+    except (ValueError, TypeError, OverflowError):
+        reasons.append('Typed input interval requires valid timezone-aware timestamps')
+    # Match the intended mathematical question independently of measured values.
+    # JSON canonicalisation distinguishes booleans from numbers and retains the
+    # whole formula/model, including unused premises and zero coefficients.
+    payload = value['payload']
+    if not isinstance(payload, dict):
+        reasons.append('Typed input payload must be an object')
+    else:
+        for key in contract.query_fields:
+            expected = json.dumps(proposition.query.get(key), sort_keys=True, separators=(',', ':'), allow_nan=False)
+            try:
+                actual = json.dumps(payload[key], sort_keys=True, separators=(',', ':'), allow_nan=False)
+            except (KeyError, ValueError, TypeError, RecursionError):
+                actual = None
+            if actual != expected:
+                reasons.append(f'Typed input query field {key!r} does not match the declared proposition query')
+    # Hash the entire formal problem, rather than only its numerical answer.
+    try:
+        encoded = json.dumps(value['payload'], sort_keys=True, separators=(',', ':'), ensure_ascii=False, allow_nan=False).encode('utf-8')
+        trace.update(input_payload_digest=hashlib.sha256(encoded).hexdigest(), formal_query=value['payload'], input_unit=unit)
+    except (ValueError, TypeError, UnicodeError, RecursionError):
+        reasons.append('Typed input payload must be finite JSON')
+    trace.update(status='unsupported' if reasons else 'bound', reasons=reasons)
+    return (None if reasons else value['payload']), trace
+
+
+def check_result(proposition: Proposition, method: str, details: dict, trace: dict, registry=None):
+    """Evaluate the formal result predicate, converting only physical statistics."""
+    if proposition.result.expression is not None:
+        converted = deepcopy(details)
+        observations = {}
+        for path in predicate_paths(proposition.result):
+            output = _output_type(method, path, registry)
+            check = check_result(replace(proposition, result=Predicate(path, '==', False if output == 'boolean' else 0)),
+                                 method, details, trace, registry)
+            if 'actual' not in check:
+                return check
+            observations[path] = check['actual']
+            destination = converted
+            parts = path.split('.')
+            for field in parts[:-1]:
+                destination = destination[field]
+            destination[parts[-1]] = check['actual']
+        checked = evaluate_expression(proposition.result.expression, converted)
+        if not checked.known or type(checked.value) is not bool:
+            return {**trace, 'status': 'unsupported', 'reasons': [checked.reason or 'Result requires a Boolean']}
+        return {**trace, 'status': 'supported' if checked.value else 'unsupported', 'holds': checked.value,
+                'actual': observations, 'output_unit': proposition.unit,
+                'reasons': [format_expression(proposition.result.expression) + (' holds' if checked.value else ' does not hold')]}
+    actual = details
+    for field in proposition.result.path.split('.'):
+        if not isinstance(actual, dict) or field not in actual:
+            return {**trace, 'status': 'unsupported', 'reasons': ['Bound method output is missing']}
+        actual = actual[field]
+    output = _output_type(method, proposition.result.path, registry)
+    if output is None:
+        return {**trace, 'status': 'unsupported', 'reasons': ['Bound method output is not declared by the method contract']}
+    is_numeric = type(actual) in (int, float) and (not isinstance(actual, float) or math.isfinite(actual))
+    if output == 'boolean' and type(actual) is not bool or output != 'boolean' and not is_numeric:
+        return {**trace, 'status': 'unsupported', 'reasons': ['Bound method output has an incompatible type']}
+    output_unit = None if output == 'boolean' else '1'
+    if output == 'basis':
+        ratio = Fraction(UNITS[trace['input_unit']][1]) / Fraction(UNITS[proposition.unit][1])
+        if ratio != 1:
+            exact = Fraction(str(actual)) * ratio
+            try:
+                actual = float(exact)
+            except OverflowError:
+                return {**trace, 'status': 'unsupported', 'reasons': ['Unit conversion exceeds the finite numeric range']}
+            if exact != 0 and actual == 0:
+                return {**trace, 'status': 'unsupported', 'reasons': ['Unit conversion underflow would erase a nonzero result']}
+        output_unit = proposition.unit
+        if type(actual) is float and not math.isfinite(actual):
+            return {**trace, 'status': 'unsupported', 'reasons': ['Converted result is not finite']}
+    holds = _COMPARISONS[proposition.result.operator](actual, proposition.result.expected)
+    return {**trace, 'status': 'supported' if holds else 'unsupported', 'holds': holds,
+            'actual': actual, 'output_unit': output_unit,
+            'reasons': [f'Bound result {proposition.result.path!r} {proposition.result.operator} '
+                        f'{proposition.result.expected!r} {"holds" if holds else "does not hold"}']}

eal/reachability.py

@@ -0,0 +1,85 @@
+"""An optional, bounded finite-state model checker for EAL/3.
+
+The host installs this method explicitly. An EAL source cannot load Python code.
+It decides reachability in the *supplied graph*, not whether that graph describes
+an actual device. The path is a checkable counterexample when one exists.
+"""
+from __future__ import annotations
+
+from collections import deque
+
+from .methods import MethodContract, default_registry
+
+
+def finite_reachability(payload: dict) -> dict:
+    """Find a shortest path to a forbidden state within the inclusive horizon."""
+    count = payload["node_count"]
+    start = payload["start"]
+    forbidden = payload["forbidden"]
+    horizon = payload["horizon"]
+    edges = payload["edges"]
+    if start >= count or any(node >= count for node in forbidden):
+        raise ValueError("Start and forbidden states must belong to the graph")
+    if len(set(forbidden)) != len(forbidden) or len({tuple(edge) for edge in edges}) != len(edges):
+        raise ValueError("Duplicate forbidden states or transition edges")
+    if any(source >= count or target >= count for source, target in edges):
+        raise ValueError("A transition endpoint is outside the graph")
+    adjacency = [[] for _ in range(count)]
+    for source, target in edges:
+        adjacency[source].append(target)
+    for successors in adjacency:
+        successors.sort()
+    queue = deque([(start,)])
+    seen = {start}
+    forbidden_set = set(forbidden)
+    while queue:
+        path = queue.popleft()
+        if path[-1] in forbidden_set:
+            return {"reachable": True, "shortest_length": len(path) - 1,
+                    "counterexample": list(path), "visited": len(seen)}
+        if len(path) - 1 == horizon:
+            continue
+        for successor in adjacency[path[-1]]:
+            if successor not in seen:
+                seen.add(successor)
+                queue.append((*path, successor))
+    return {"reachable": False, "shortest_length": -1,
+            "counterexample": [], "visited": len(seen)}
+
+
+NODE = {"type": "integer", "minimum": 0, "maximum": 7}
+COUNT = {"type": "integer", "minimum": 1, "maximum": 8}
+HORIZON = {"type": "integer", "minimum": 0, "maximum": 8}
+FORBIDDEN = {"type": "array", "items": NODE, "minItems": 1, "maxItems": 8}
+EDGES = {"type": "array", "items": {"type": "array", "items": NODE,
+                                      "minItems": 2, "maxItems": 2}, "maxItems": 64}
+
+REACHABILITY_CONTRACT = MethodContract(
+    identifier="engineering/reachability/1", evidence_kind="finite_graph",
+    input_schema={"type": "object", "properties": {
+        "node_count": COUNT, "edges": EDGES, "start": NODE,
+        "forbidden": FORBIDDEN, "horizon": HORIZON},
+        "required": ["node_count", "edges", "start", "forbidden", "horizon"],
+        "additionalProperties": False},
+    query_schema={"type": "object", "properties": {
+        "start": NODE, "forbidden": FORBIDDEN, "horizon": HORIZON},
+        "required": ["start", "forbidden", "horizon"],
+        "additionalProperties": False},
+    output_schema={"type": "object", "properties": {
+        "reachable": {"type": "boolean"},
+        "shortest_length": {"type": "integer", "minimum": -1, "maximum": 8},
+        "counterexample": {"type": "array", "items": NODE, "maxItems": 9},
+        "visited": {"type": "integer", "minimum": 1, "maximum": 8}},
+        "required": ["reachable", "shortest_length", "counterexample", "visited"],
+        "additionalProperties": False},
+    outputs={"reachable": "boolean", "shortest_length": "dimensionless",
+             "visited": "dimensionless"},
+    quantities=("proposition",), exact_unit=True,
+    implementation=finite_reachability, implementation_version="finite-graph-bfs-1",
+    timeout_seconds=2.0,
+)
+
+
+def reachability_registry():
+    """Operator factory: ``--methods eal.reachability:reachability_registry``."""
+    return default_registry().with_method(REACHABILITY_CONTRACT)

eal/reasoning/__init__.py

@@ -0,0 +1,25 @@
+"""Select the stateless built-in strategies; algorithms live in their modules."""
+from __future__ import annotations
+
+from .structured import STRATEGY as STRUCTURED
+from .deductive import STRATEGY as DEDUCTIVE
+from .inductive import STRATEGY as INDUCTIVE
+from .abductive import STRATEGY as ABDUCTIVE
+from .causal import STRATEGY as CAUSAL
+from .counterfactual import STRATEGY as COUNTERFACTUAL
+from .analogical import STRATEGY as ANALOGICAL
+from .temporal import STRATEGY as TEMPORAL
+
+
+BUILTIN_STRATEGIES = {
+    strategy.mode: strategy for strategy in (
+        STRUCTURED,
+        DEDUCTIVE,
+        INDUCTIVE,
+        ABDUCTIVE,
+        CAUSAL,
+        COUNTERFACTUAL,
+        ANALOGICAL,
+        TEMPORAL,
+    )
+}

eal/reasoning/abductive.py

@@ -0,0 +1,45 @@
+"""Condition a supplied finite hypothesis distribution on its likelihoods."""
+from __future__ import annotations
+
+import math
+
+from .strategy import BuiltinStrategy
+from .validation import _list, _name, _object, _probability, _result, _text
+
+
+def _abductive(value):
+    _object(value, ("observed", "candidates"), "hypotheses")
+    _text(value["observed"], "observed evidence description")
+    candidates = _list(value["candidates"], "candidates", minimum=2, maximum=128)
+    priors, log_weights = {}, {}
+    for item in candidates:
+        _object(item, ("name", "prior", "likelihood"), "hypothesis")
+        name = _name(item["name"], "hypothesis name")
+        if name in priors:
+            raise ValueError("Hypothesis names must be unique")
+        prior = _probability(item["prior"], "prior")
+        likelihood = _probability(item["likelihood"], "likelihood")
+        priors[name] = prior
+        log_weights[name] = (math.log(prior) + math.log(likelihood)
+                             if prior > 0 and likelihood > 0 else -math.inf)
+    total_prior = math.fsum(priors.values())
+    if not math.isclose(total_prior, 1.0, rel_tol=0.0, abs_tol=1e-9):
+        raise ValueError("Prior probabilities must sum to 1 within absolute tolerance 1e-9")
+    maximum = max(log_weights.values())
+    if maximum == -math.inf:
+        return _result(False, "The supplied hypotheses assign zero probability to the observed evidence",
+                       posterior={}, best=None, ties=[], assumptions_verified=False)
+    weights = {name: math.exp(weight - maximum) for name, weight in log_weights.items()}
+    normaliser = math.fsum(weights.values())
+    posterior = {name: weight / normaliser for name, weight in weights.items()}
+    best_probability = max(posterior.values())
+    ties = sorted(name for name, probability in posterior.items()
+                  if math.isclose(probability, best_probability, rel_tol=0.0, abs_tol=1e-12))
+    return _result(True, "Posterior probabilities computed within the supplied finite hypothesis model",
+                   posterior=posterior, best=ties[0] if len(ties) == 1 else None,
+                   best_posterior=best_probability, ties=ties if len(ties) > 1 else [],
+                   log_evidence_probability=maximum + math.log(normaliser) - math.log(total_prior),
+                   assumptions_verified=False)
+
+
+STRATEGY = BuiltinStrategy("abductive", _abductive)

eal/reasoning/analogical.py

@@ -0,0 +1,41 @@
+"""Compare exactly the declared scalar feature correspondences."""
+from __future__ import annotations
+
+
+from .strategy import BuiltinStrategy
+from .validation import _list, _name, _object, _result
+
+
+def _analogical(value):
+    _object(value, ("relevant_features", "source", "target"), "analogy")
+    features = [_name(feature, "feature") for feature in
+                _list(value["relevant_features"], "relevant_features", maximum=256)]
+    if len(set(features)) != len(features):
+        raise ValueError("Relevant feature names must be unique")
+    source, target = value["source"], value["target"]
+    if not isinstance(source, dict) or not isinstance(target, dict):
+        raise ValueError("Source and target must be feature maps")
+    missing = sorted(feature for feature in features if feature not in source or feature not in target)
+    if missing:
+        return _result(False, "The relevant-feature mapping is incomplete", complete=False,
+                       missing=missing, match_fraction=None, mismatches=[], assumptions_verified=False)
+
+    def scalar(item):
+        if isinstance(item, (dict, list)):
+            raise ValueError("Mapped feature values must be JSON scalars")
+        return item
+
+    def equal(left, right):
+        scalar(left)
+        scalar(right)
+        numeric = lambda x: isinstance(x, (float, int)) and not isinstance(x, bool)
+        return (type(left) is type(right) or numeric(left) and numeric(right)) and left == right
+
+    mismatches = [feature for feature in features if not equal(source[feature], target[feature])]
+    return _result(True, "Declared features compared exactly; feature relevance and conclusion transfer remain authored reasoning",
+                   complete=True, feature_count=len(features), matched=len(features) - len(mismatches),
+                   match_fraction=(len(features) - len(mismatches)) / len(features), mismatches=mismatches,
+                   missing=[], interpretation="feature_correspondence", assumptions_verified=False)
+
+
+STRATEGY = BuiltinStrategy("analogical", _analogical)

eal/reasoning/causal.py

@@ -0,0 +1,46 @@
+"""Calculate the independent-group mean contrast and standard error."""
+from __future__ import annotations
+
+import math
+from fractions import Fraction
+from statistics import stdev
+
+from .strategy import BuiltinStrategy
+from .validation import _list, _number, _object, _result
+
+
+def _causal(value):
+    _object(value, ("assignment", "treatment", "control"), "experiment")
+    if value["assignment"] != "randomised":
+        raise ValueError("This causal calculation requires declared randomised assignment")
+    groups = []
+    for name in ("treatment", "control"):
+        groups.append([_number(item, name) for item in _list(value[name], name, minimum=2)])
+    treatment, control = groups
+    # Subtract the represented means before rounding: two large, neighbouring
+    # integer means must not collapse to the same binary64 value and erase an
+    # observed treatment effect. Fraction also retains each supplied float's
+    # exact binary value; it does not infer additional measurement precision.
+    mt = sum(map(Fraction, treatment), Fraction()) / len(treatment)
+    mc = sum(map(Fraction, control), Fraction()) / len(control)
+    def numeric(value):
+        rounded = value.numerator if value.denominator == 1 else float(value)
+        if value and rounded == 0:
+            raise ValueError("Computed mean or contrast underflows the representable number range")
+        return rounded
+
+    # Compute standard deviations before combining their contributions. Forming
+    # floating variances first can underflow even when the final square root is
+    # representable (for example, a standard error of 1e-200).
+    se = math.hypot(stdev(treatment) / math.sqrt(len(treatment)),
+                    stdev(control) / math.sqrt(len(control)))
+    if se == 0 and any(any(item != group[0] for item in group) for group in groups):
+        raise ValueError("Computed standard error underflows the representable number range")
+    return _result(True, "Randomised two-group mean contrast computed; assignment and causal assumptions require evidence",
+                   estimate=numeric(mt - mc), standard_error=se,
+                   treatment_mean=numeric(mt), control_mean=numeric(mc),
+                   treatment_size=len(treatment), control_size=len(control),
+                   sample_size=len(treatment) + len(control), assumptions_verified=False)
+
+
+STRATEGY = BuiltinStrategy("causal", _causal)

eal/reasoning/counterfactual.py

@@ -0,0 +1,64 @@
+"""Evaluate a single intervention in an acyclic affine causal model."""
+from __future__ import annotations
+
+import math
+
+from .strategy import BuiltinStrategy
+from .validation import _name, _number, _object, _result
+
+
+def _counterfactual(value):
+    _object(value, ("variables", "intervention", "outcome"), "causal_model")
+    variables = value["variables"]
+    if not isinstance(variables, dict) or not 1 <= len(variables) <= 32:
+        raise ValueError("variables must contain 1..32 structural equations")
+    equations = {}
+    for name, equation in variables.items():
+        _name(name, "variable name")
+        _object(equation, ("intercept", "coefficients", "noise"), "structural equation")
+        coefficients = equation["coefficients"]
+        if not isinstance(coefficients, dict) or len(coefficients) > 32:
+            raise ValueError("coefficients must map at most 32 variables to numbers")
+        if any(parent not in variables for parent in coefficients):
+            raise ValueError("Structural equation references an unknown parent variable")
+        equations[name] = (_number(equation["intercept"], "intercept"),
+                           {parent: _number(c, "coefficient") for parent, c in coefficients.items()},
+                           _number(equation["noise"], "noise"))
+    _object(value["intervention"], ("variable", "value"), "intervention")
+    changed = _name(value["intervention"]["variable"], "intervention variable")
+    outcome = _name(value["outcome"], "outcome")
+    if changed not in equations or outcome not in equations:
+        raise ValueError("Intervention and outcome must name declared variables")
+    setting = _number(value["intervention"]["value"], "intervention value")
+    order = []
+    remaining = dict(equations)
+    while remaining:
+        ready = sorted(name for name, (_, parents, _) in remaining.items()
+                       if all(parent in order for parent in parents))
+        if not ready:
+            raise ValueError("Structural equations must be acyclic, including zero-coefficient references")
+        for name in ready:
+            order.append(name)
+            del remaining[name]
+
+    def solve(intervene):
+        result = {}
+        for name in order:
+            intercept, parents, noise = equations[name]
+            if intervene and name == changed:
+                result[name] = setting
+            else:
+                terms = [intercept, noise, *(c * result[parent] for parent, c in parents.items())]
+                result[name] = sum(terms) if all(type(term) is int for term in terms) else math.fsum(terms)
+            _number(result[name], "Computed structural value")
+        return result
+
+    factual, counterfactual = solve(False), solve(True)
+    return _result(True, "Intervention evaluated in an acyclic affine model with the same supplied exogenous values",
+                   factual=factual[outcome], counterfactual=counterfactual[outcome],
+                   difference=counterfactual[outcome] - factual[outcome],
+                   factual_values=factual, counterfactual_values=counterfactual,
+                   outcome=outcome, evaluation_order=order, assumptions_verified=False)
+
+
+STRATEGY = BuiltinStrategy("counterfactual", _counterfactual)

eal/reasoning/deductive.py

@@ -0,0 +1,72 @@
+"""Check bounded propositional entailment and retain counterexamples."""
+from __future__ import annotations
+
+import itertools
+
+MAX_ATOMS = 12
+MAX_FORMULA_NODES = 512
+
+from .strategy import BuiltinStrategy
+from .validation import _list, _name, _object, _result
+
+
+def _deductive(value):
+    _object(value, ("premises", "conclusion"), "logical_case")
+    premises = _list(value["premises"], "Logical premises", minimum=0, maximum=128)
+    atoms, budget = set(), [MAX_FORMULA_NODES]
+
+    def check(formula, depth=0):
+        budget[0] -= 1
+        if budget[0] < 0 or depth > 32:
+            raise ValueError("Logical formulas exceed 512 total nodes or depth 32")
+        if isinstance(formula, str):
+            atoms.add(_name(formula, "Propositional atom"))
+            return
+        if not isinstance(formula, dict) or len(formula) != 1:
+            raise ValueError("A formula is an atom or one not/and/or/implies object")
+        op, operand = next(iter(formula.items()))
+        if op == "not":
+            check(operand, depth + 1)
+        elif op in ("and", "or", "implies"):
+            _list(operand, f"{op} operands", minimum=2, maximum=2 if op == "implies" else 128)
+            for child in operand:
+                check(child, depth + 1)
+        else:
+            raise ValueError(f"Unsupported logical operator {op!r}")
+
+    for formula in [*premises, value["conclusion"]]:
+        check(formula)
+    if len(atoms) > MAX_ATOMS:
+        raise ValueError("Finite deduction supports at most 12 distinct atoms")
+
+    def truth(formula, assignment):
+        if isinstance(formula, str):
+            return assignment[formula]
+        op, operand = next(iter(formula.items()))
+        if op == "not":
+            return not truth(operand, assignment)
+        if op == "and":
+            return all(truth(item, assignment) for item in operand)
+        if op == "or":
+            return any(truth(item, assignment) for item in operand)
+        return not truth(operand[0], assignment) or truth(operand[1], assignment)
+
+    atoms = sorted(atoms)
+    satisfying = 0
+    counterexample = None
+    for values in itertools.product((False, True), repeat=len(atoms)):
+        assignment = dict(zip(atoms, values))
+        if all(truth(formula, assignment) for formula in premises):
+            satisfying += 1
+            if counterexample is None and not truth(value["conclusion"], assignment):
+                counterexample = assignment
+    consistent = satisfying > 0
+    entailed = counterexample is None
+    return _result(consistent,
+                   "Finite entailment established with satisfiable premises" if consistent and entailed
+                   else "Premises are inconsistent" if not consistent else "A counterexample refutes entailment",
+                   entailed=entailed, consistent_premises=consistent, counterexample=counterexample,
+                   atoms=atoms, valuations=2 ** len(atoms), satisfying_premise_valuations=satisfying)
+
+
+STRATEGY = BuiltinStrategy("deductive", _deductive)

eal/reasoning/inductive.py

@@ -0,0 +1,29 @@
+"""Estimate a binomial proportion using the Wilson score interval."""
+from __future__ import annotations
+
+import math
+from statistics import NormalDist
+
+from .strategy import BuiltinStrategy
+from .validation import _integer, _number, _object, _result
+
+
+def _inductive(value):
+    _object(value, ("successes", "trials", "confidence"), "sample")
+    n = _integer(value["trials"], "trials", minimum=1)
+    k = _integer(value["successes"], "successes", maximum=n)
+    confidence = _number(value["confidence"], "confidence")
+    if not 0.001 <= confidence <= 0.999999:
+        raise ValueError("confidence must be in [0.001, 0.999999]")
+    z = NormalDist().inv_cdf((1 + confidence) / 2)
+    p = k / n
+    denominator = 1 + z * z / n
+    centre = (p + z * z / (2 * n)) / denominator
+    half = z * math.sqrt(p * (1 - p) / n + z * z / (4 * n * n)) / denominator
+    return _result(True, "Wilson interval computed under the stated binomial sampling model",
+                   estimate=p, lower=max(0.0, centre - half), upper=min(1.0, centre + half),
+                   sample_size=n, successes=k, confidence=confidence, method="wilson_score",
+                   interpretation="approximate_frequentist", assumptions_verified=False)
+
+
+STRATEGY = BuiltinStrategy("inductive", _inductive)