---
title: "LogicVerifier proves false theorems because Python…"
description: "GHSA-w73j-4jjq-q53j: LogicVerifier proves false theorems because Python folds numeric literals before Z3… Affected and fixed versions of qwed."
url: https://qwedai.tech/security/advisories/ghsa-w73j-4jjq-q53j
---

[Security](https://qwedai.tech/security) · [Advisories](https://qwedai.tech/security/advisories) · GHSA-w73j-4jjq-q53j

# LogicVerifier proves false theorems because Python folds numeric literals before Z3 (1/3, 0.1 + 0.2, 7/2)

medium Fixed in 9.0.0 GHSA-w73j-4jjq-q53j · Published 6 November 2026

## Impact

`LogicVerifier.prove_theorem` returns `VERIFIED` ("theorem proved") for statements that are false. A true statement of the same kind is `BLOCKED`. The cause is that numeric literals are evaluated by Python before Z3 sees them:

-   `1/3` becomes the float `0.333...`;
-   `0.1 + 0.2` becomes `0.30000000000000004`;
-   `7/2` becomes `3.5`.

Meanwhile, the same operator applied to a Z3 variable stays exact (Real) or integer division (Int). The two sides of one formula therefore use different arithmetic.

| Call | 8.0.0 | Correct |
| --- | --- | --- |
| `prove_theorem({"x": "Real"}, ["x == 1/3"], "3 * x != 1")` | **VERIFIED** | false over the reals |
| `prove_theorem({"x": "Real"}, ["x == 0.1 + 0.2"], "x != 0.3")` | **VERIFIED** | false over the reals |
| `prove_theorem({"x": "Int"}, ["x == 7"], "x / 2 != 7 / 2")` | **VERIFIED** | false under any single definition of `/` |
| `prove_theorem({"x": "Real"}, ["3 * x == 1"], "x == 1/3")` | BLOCKED (counterexample `x = 1/3`) | true |

The DSL compiler used by `POST /verify/logic` has the same mismatch: `(AND (EQ x 7) (NEQ (DIV x 2) (DIV 7 2)))` compiles to `And(x == 7, ToReal(x/2) != 7/2)`, which is satisfiable, so a contradictory constraint set is reported as consistent.

This is the same class as GHSA-mfh5-3c8f-975p (Python semantics silently replacing Z3 semantics) with a different root cause.

The integer-division semantics themselves (Z3 is Euclidean, so `-7/2 == -4`) are a documented-behaviour question tracked publicly in #537. This advisory is about the inconsistency inside one formula, which proves false statements under any semantics.

## Affected

`qwed` (PyPI) through 8.0.0. Reproduced on `main` @ `10f5627` (unchanged since 8.0.0).

Reachable from:

-   the `LogicVerifier` Python API: `prove_theorem` returns the false `VERIFIED` results above;
-   the DSL path of `POST /verify/logic`;
-   consensus logic checks (`ConsensusVerifier` uses `LogicVerifier`).

The same mismatch makes `check_equivalence({"x": "Real"}, "3 * x == 1", "x == 1/3")` return BLOCKED (not equivalent) and `verify_logic({"x": "Real"}, ["x == 1/3", "3 * x == 1"])` return UNVERIFIABLE (unsatisfiable). Both answers are wrong, but they fail closed.

## Reproduction

```python
from qwed_new.core.logic_verifier import LogicVerifier

lv = LogicVerifier()
for variables, premises, conclusion in [
    ({"x": "Real"}, ["x == 1/3"], "3 * x != 1"),
    ({"x": "Real"}, ["x == 0.1 + 0.2"], "x != 0.3"),
    ({"x": "Int"}, ["x == 7"], "x / 2 != 7 / 2"),
    ({"x": "Real"}, ["3 * x == 1"], "x == 1/3"),
]:
    print(conclusion, lv.prove_theorem(variables, premises, conclusion).status.value)
# VERIFIED, VERIFIED, VERIFIED, BLOCKED
```

## Details

-   **`src/qwed_new/core/safe_evaluator.py`, line 176:** the validated AST is evaluated with Python `eval`. Sub-expressions made only of Python numbers are computed by Python (true division and binary floating point) before any Z3 object is involved. Only sub-expressions containing a Z3 variable become Z3 terms.
-   **`src/qwed_new/core/dsl/compiler.py`, around lines 298 and 410:** `DIV` on two numeric literals produces a Python or Z3 rational, while `DIV` on an `Int` variable produces Z3 integer division, which is then coerced with `ToReal`.

## Patches

Fixed in 9.0.0 ([`88b9330`](https://github.com/QWED-AI/qwed-verification/commit/88b9330424a22b5f0701bb0bc77827d9236a1fb1) ). Upgrade to 9.0.0 or later.

-   Number literals no longer go through Python floats. A decimal literal is the exact value written (`0.1` is `1/10`), and `/`, `%` and `**` on numbers are computed exactly.
-   Next to `Int` variables, a division of two numbers whose result is not whole is refused, since it is unclear whether integer or real division was meant. An `Int` term is never divided by a `Real` term or coerced with `ToReal`; the formula is refused instead. Arithmetic on a Boolean is refused.
-   In the DSL, `DIV` of two integer literals is integer division, like `DIV` of an `Int` variable.

On 9.0.0 the first two rows of the table are `BLOCKED`, the third is refused (`Division of two numbers is not whole next to Int variables`), and the true statement in the fourth row is `VERIFIED`. The DSL constraint set above compiles to an unsatisfiable formula.

Integer division and modulo keep Z3's Euclidean semantics (see #537).

## Source

Internal correctness audit (October 2026). Not previously disclosed.

[All advisories](https://qwedai.tech/security/advisories)

Affected and fixed

qwed

Affected <= 8.0.0 Fixed in 9.0.0

Weakness

CWE-681 Incorrect Conversion between Numeric Types CWE-697 Incorrect Comparison

[View on GitHub](https://github.com/QWED-AI/qwed-verification/security/advisories/GHSA-w73j-4jjq-q53j)
