zcc-verify 0.1.0__py3-none-any.whl

zcc_verify/__init__.py

@@ -0,0 +1,416 @@
+"""Independent checker for ZCC-v0.1 / ZHF-v0.1 accuracy certificates.
+
+    from zcc_verify import fetch, verify
+    print(verify(fetch("fe529e21d7404ff3")))
+
+What this establishes, and what it does not, stated plainly because the
+distinction is the whole point of the format:
+
+**It checks that a certificate is well formed and internally consistent.** The
+declared error bound is recomputed from the measured quantity the certificate
+reports, and the two must agree. A certificate whose stated bound does not
+follow from its own stated inputs fails here, whoever issued it.
+
+**It does not establish that the measurement was honest.** The discarded weight
+in an MPS certificate, or the coefficient mass in a Pauli one, is produced by
+whoever ran the simulation. No amount of arithmetic on the record can confirm
+that the number reported is the number that was measured. Verifying a
+certificate is not the same as trusting the issuer.
+
+The specification is published at
+https://doi.org/10.5281/zenodo.21851381, and the protocol reference is
+https://github.com/official-dvl/zksf/blob/main/docs/CERTIFICATION.md.
+
+Standard library only, on purpose: a validator that a third party has to install
+a dependency tree to run is one they will not run. Vendor this file if it helps.
+"""
+from __future__ import annotations
+
+import json
+import math
+import re
+import urllib.request
+from dataclasses import dataclass, field
+from datetime import datetime
+
+__version__ = "0.1.0"
+
+DEFAULT_BASE_URL = "https://api.zksf.org"
+
+# Protocols this checker understands. An unknown protocol is reported rather
+# than assumed to be fine: a future ZCC-v0.2 may carry invariants this version
+# knows nothing about, and silently passing it would be the wrong answer.
+KNOWN_PROTOCOLS = {"ZCC-v0.1", "ZHF-v0.1", "ZCC-Estimate-v0.1"}
+
+REQUIRED_FIELDS = (
+    "cert_id",
+    "protocol",
+    "certificate_type",
+    "engine",
+    "method",
+    "circuit_sha256",
+    "created_at",
+    "verify_url",
+)
+
+# Fields that must never appear. A certificate is meant to be publishable
+# without exposing the account that produced it or the circuit that was run,
+# so a third party should be able to confirm that for themselves.
+FORBIDDEN_FIELDS = (
+    "user_sub",
+    "charged_micro",
+    "qasm2",
+    "email",
+    "balance_usd",
+    "braket_task_arn",
+    "runpod_job_id",
+)
+
+PASS, FAIL, SKIP = "pass", "fail", "skip"
+
+_SHA256_RE = re.compile(r"\A[0-9a-f]{64}\Z")
+
+
+@dataclass(frozen=True)
+class Check:
+    name: str
+    status: str
+    detail: str = ""
+
+    def __str__(self) -> str:
+        mark = {PASS: "ok  ", FAIL: "FAIL", SKIP: "  - "}[self.status]
+        return f"[{mark}] {self.name}" + (f": {self.detail}" if self.detail else "")
+
+
+@dataclass
+class Report:
+    cert_id: str
+    protocol: str
+    checks: list[Check] = field(default_factory=list)
+
+    @property
+    def ok(self) -> bool:
+        return all(c.status != FAIL for c in self.checks)
+
+    @property
+    def failures(self) -> list[Check]:
+        return [c for c in self.checks if c.status == FAIL]
+
+    def __str__(self) -> str:
+        head = f"certificate {self.cert_id} ({self.protocol})"
+        body = "\n".join(f"  {c}" for c in self.checks)
+        tail = (
+            "  consistent: the stated bound follows from the stated measurement"
+            if self.ok
+            else f"  INCONSISTENT: {len(self.failures)} check(s) failed"
+        )
+        return f"{head}\n{body}\n{tail}"
+
+
+def fetch(cert_id: str, base_url: str = DEFAULT_BASE_URL, timeout: float = 30.0) -> dict:
+    """Read a public certificate record. No authentication, no account."""
+    url = f"{base_url.rstrip('/')}/certify/{cert_id}/json"
+    with urllib.request.urlopen(url, timeout=timeout) as resp:  # noqa: S310
+        return json.load(resp)
+
+
+def _close(a: float, b: float) -> bool:
+    # Both sides come from the same float arithmetic, so exact agreement is the
+    # normal case; the tolerance is for records that made a round trip through
+    # a JSON encoder that shortened the representation.
+    return math.isclose(a, b, rel_tol=1e-9, abs_tol=1e-15)
+
+
+def verify(rec: dict) -> Report:
+    """Check a certificate record against the invariants of its own protocol."""
+    report = Report(
+        cert_id=str(rec.get("cert_id", "<missing>")),
+        protocol=str(rec.get("protocol", "<missing>")),
+    )
+    add = report.checks.append
+
+    missing = [f for f in REQUIRED_FIELDS if not rec.get(f)]
+    add(
+        Check("required fields present", FAIL, f"missing {', '.join(missing)}")
+        if missing
+        else Check("required fields present", PASS)
+    )
+
+    protocol = rec.get("protocol")
+    add(
+        Check("protocol recognised", PASS, str(protocol))
+        if protocol in KNOWN_PROTOCOLS
+        else Check(
+            "protocol recognised",
+            FAIL,
+            f"{protocol!r} is not one of {sorted(KNOWN_PROTOCOLS)}; this checker "
+            f"cannot confirm invariants it does not know",
+        )
+    )
+
+    leaked = [f for f in FORBIDDEN_FIELDS if f in rec]
+    add(
+        Check("carries no account or circuit data", FAIL, f"found {', '.join(leaked)}")
+        if leaked
+        else Check("carries no account or circuit data", PASS)
+    )
+
+    digest = rec.get("circuit_sha256", "")
+    add(
+        Check("circuit identified by SHA-256", PASS)
+        if _SHA256_RE.match(str(digest))
+        else Check("circuit identified by SHA-256", FAIL, f"not a SHA-256 digest: {digest!r}")
+    )
+
+    try:
+        datetime.fromisoformat(str(rec.get("created_at", "")))
+        add(Check("issued-at timestamp parses", PASS, str(rec.get("created_at"))))
+    except ValueError:
+        add(Check("issued-at timestamp parses", FAIL, repr(rec.get("created_at"))))
+
+    shots = rec.get("shots")
+    if shots is None:
+        add(Check("shot count", SKIP, "no shots recorded (expectation-value run)"))
+    elif isinstance(shots, int) and shots > 0:
+        add(Check("shot count", PASS, str(shots)))
+    else:
+        add(Check("shot count", FAIL, f"not a positive integer: {shots!r}"))
+
+    _check_outcomes(rec, add)
+
+    if protocol == "ZHF-v0.1":
+        _check_hardware(rec, add)
+    else:
+        _check_simulation(rec, add)
+
+    return report
+
+
+def _check_outcomes(rec: dict, add) -> None:
+    outcomes = rec.get("top_outcomes")
+    if not outcomes:
+        add(Check("measured outcomes", SKIP, "none recorded"))
+        return
+    try:
+        total = sum(int(count) for _, count in outcomes)
+        labels = [str(bits) for bits, _ in outcomes]
+    except (TypeError, ValueError):
+        add(Check("measured outcomes", FAIL, "malformed top_outcomes"))
+        return
+    if any(not set(b) <= {"0", "1"} for b in labels):
+        add(Check("measured outcomes", FAIL, "outcome labels are not bitstrings"))
+        return
+    shots = rec.get("shots")
+    # top_outcomes is a truncated list, so it can hold fewer shots than were
+    # taken, but never more.
+    if isinstance(shots, int) and total > shots:
+        add(
+            Check(
+                "measured outcomes",
+                FAIL,
+                f"reported outcomes total {total} shots but the run took {shots}",
+            )
+        )
+        return
+    add(Check("measured outcomes", PASS, f"{len(labels)} outcomes, {total} shots shown"))
+
+
+def _check_hardware(rec: dict, add) -> None:
+    """ZHF-v0.1: a fidelity against the exact ideal, or an explicit statement
+    that direct verification was not available. Never a silent absence."""
+    mode = rec.get("fidelity_mode")
+    if mode not in {"direct", "unavailable"}:
+        add(Check("fidelity mode declared", FAIL, f"unexpected mode {mode!r}"))
+        return
+    add(Check("fidelity mode declared", PASS, str(mode)))
+
+    fidelity = rec.get("fidelity")
+    if mode == "unavailable":
+        # The honest case: too large to verify classically. It must then decline
+        # to report a figure rather than produce one.
+        if fidelity is None:
+            add(Check("no fidelity claimed without a reference", PASS, str(rec.get("note", ""))[:80]))
+        else:
+            add(
+                Check(
+                    "no fidelity claimed without a reference",
+                    FAIL,
+                    f"mode is 'unavailable' yet a fidelity of {fidelity} is reported",
+                )
+            )
+        return
+
+    if not isinstance(fidelity, (int, float)):
+        add(Check("fidelity is a number", FAIL, repr(fidelity)))
+    elif 0.0 <= fidelity <= 1.0:
+        add(Check("fidelity within [0, 1]", PASS, f"{fidelity}"))
+    else:
+        add(Check("fidelity within [0, 1]", FAIL, f"{fidelity} is outside the valid range"))
+
+
+def _check_simulation(rec: dict, add) -> None:
+    """ZCC-v0.1: recompute the declared bound from the measured quantity.
+
+    This is the check that does real work. Everything else confirms the record
+    is well formed; this one confirms the arithmetic it asserts.
+    """
+    bound = rec.get("error_bound")
+
+    if rec.get("exact"):
+        # An exact engine approximates nothing, so a nonzero bound would
+        # contradict the claim being made.
+        if bound in (None, 0, 0.0):
+            add(Check("exact run declares no approximation error", PASS))
+        else:
+            add(
+                Check(
+                    "exact run declares no approximation error",
+                    FAIL,
+                    f"claims to be exact yet reports an error bound of {bound}",
+                )
+            )
+        return
+
+    if rec.get("estimated"):
+        # ZCC-Estimate: an extrapolated value with an uncertainty. There is no
+        # closed-form relation to recompute, by construction.
+        add(
+            Check(
+                "bound recomputed from the measurement",
+                SKIP,
+                "extrapolated estimate: an uncertainty, not a derived bound",
+            )
+        )
+        return
+
+    if bound is None:
+        add(Check("bound recomputed from the measurement", SKIP, "no bound reported"))
+    elif not isinstance(bound, (int, float)) or not 0.0 <= bound <= 1.0:
+        add(
+            Check(
+                "bound is a probability",
+                FAIL,
+                f"{bound!r} is not a value in [0, 1]; a bound on an outcome "
+                f"probability cannot exceed 1",
+            )
+        )
+        return
+    else:
+        add(Check("bound is a probability", PASS, f"{bound}"))
+
+    weight = rec.get("truncation_weight")
+    mass = rec.get("truncated_coefficient_mass")
+
+    if weight is not None:
+        # MPS: bound = min(1, sqrt(2*eps)), eps read off the unnormalized state.
+        expected = min(1.0, math.sqrt(2.0 * float(weight)))
+        if bound is not None and _close(float(bound), expected):
+            add(
+                Check(
+                    "bound recomputed from the measurement",
+                    PASS,
+                    f"sqrt(2 x {weight:g}) = {expected:g}",
+                )
+            )
+        else:
+            add(
+                Check(
+                    "bound recomputed from the measurement",
+                    FAIL,
+                    f"discarded weight {weight!r} implies a bound of {expected:g}, "
+                    f"but {bound!r} is reported",
+                )
+            )
+        _check_converged(rec, add, threshold=1e-6)
+
+    elif mass is not None:
+        # Pauli propagation: the bound is the discarded mass itself, by the
+        # triangle inequality over the truncated terms.
+        if bound is not None and _close(float(bound), float(mass)):
+            add(
+                Check(
+                    "bound recomputed from the measurement",
+                    PASS,
+                    f"discarded coefficient mass {mass:g}, additive",
+                )
+            )
+        else:
+            add(
+                Check(
+                    "bound recomputed from the measurement",
+                    FAIL,
+                    f"discarded mass is {mass!r} but the bound is reported as {bound!r}",
+                )
+            )
+        _check_converged(rec, add, threshold=1e-9)
+
+    elif rec.get("convergence_deviation") is not None:
+        add(
+            Check(
+                "bound recomputed from the measurement",
+                SKIP,
+                "convergence check, which is evidence of accuracy rather than a bound",
+            )
+        )
+    else:
+        add(
+            Check(
+                "bound recomputed from the measurement",
+                SKIP,
+                "no measured quantity published to recompute from",
+            )
+        )
+
+
+def _check_converged(rec: dict, add, threshold: float) -> None:
+    """The converged flag is derived, so it is checkable. The two engines use
+    different thresholds, which is why the caller passes one in."""
+    converged = rec.get("converged")
+    bound = rec.get("error_bound")
+    if converged is None or bound is None:
+        add(Check("converged flag consistent with the bound", SKIP))
+        return
+    expected = float(bound) < threshold
+    add(
+        Check("converged flag consistent with the bound", PASS, f"{converged}")
+        if bool(converged) is expected
+        else Check(
+            "converged flag consistent with the bound",
+            FAIL,
+            f"bound {bound:g} against a {threshold:g} threshold implies "
+            f"converged={expected}, but {converged} is recorded",
+        )
+    )
+
+
+def main(argv: list[str] | None = None) -> int:
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        prog="zcc-verify",
+        description="Check a ZCC-v0.1 / ZHF-v0.1 certificate for internal consistency.",
+        epilog=(
+            "Confirms that a certificate's stated bound follows from its own stated "
+            "measurement. Does not, and cannot, confirm that the measurement itself "
+            "was honestly made."
+        ),
+    )
+    parser.add_argument("target", help="a certificate id, or a path to a JSON record")
+    parser.add_argument("--base-url", default=DEFAULT_BASE_URL)
+    args = parser.parse_args(argv)
+
+    import pathlib
+
+    path = pathlib.Path(args.target)
+    if path.is_file():
+        rec = json.loads(path.read_text(encoding="utf-8"))
+    else:
+        rec = fetch(args.target, base_url=args.base_url)
+
+    report = verify(rec)
+    print(report)
+    return 0 if report.ok else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

zcc_verify/__main__.py

@@ -0,0 +1,4 @@
+"""Entry point for `python -m zcc_verify`."""
+from zcc_verify import main
+
+raise SystemExit(main())

zcc_verify-0.1.0.dist-info/METADATA

@@ -0,0 +1,179 @@
+Metadata-Version: 2.4
+Name: zcc-verify
+Version: 0.1.0
+Summary: Independent consistency checker for ZCC-v0.1 / ZHF-v0.1 quantum simulation accuracy certificates
+Author-email: ZKSF <info@zksf.org>
+License: MIT
+Project-URL: Homepage, https://zksf.org
+Project-URL: Source, https://github.com/official-dvl/zksf-zcc-verify
+Project-URL: Issues, https://github.com/official-dvl/zksf-zcc-verify/issues
+Project-URL: Specification, https://doi.org/10.5281/zenodo.21851381
+Project-URL: Protocol, https://github.com/official-dvl/zksf/blob/main/docs/CERTIFICATION.md
+Project-URL: SDK, https://pypi.org/project/qsim-sdk/
+Keywords: quantum,quantum computing,quantum circuit simulator,certification,verification,error bounds,reproducibility,ZCC,ZHF
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# zcc-verify
+
+[![CI](https://github.com/official-dvl/zksf-zcc-verify/actions/workflows/ci.yml/badge.svg)](https://github.com/official-dvl/zksf-zcc-verify/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/zcc-verify.svg)](https://pypi.org/project/zcc-verify/)
+[![Python](https://img.shields.io/pypi/pyversions/zcc-verify.svg)](https://pypi.org/project/zcc-verify/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.21851381.svg)](https://doi.org/10.5281/zenodo.21851381)
+
+Independent consistency checker for **ZCC-v0.1** and **ZHF-v0.1** quantum simulation
+accuracy certificates.
+
+No dependencies. Python 3.10+.
+
+```bash
+pip install zcc-verify
+zcc-verify fe529e21d7404ff3
+```
+
+```
+certificate fe529e21d7404ff3 (ZCC-v0.1)
+  [ok  ] required fields present
+  [ok  ] protocol recognised: ZCC-v0.1
+  [ok  ] carries no account or circuit data
+  [ok  ] circuit identified by SHA-256
+  [ok  ] issued-at timestamp parses: 2026-07-09T13:20:03+00:00
+  [ok  ] shot count: 512
+  [ok  ] measured outcomes: 2 outcomes, 512 shots shown
+  [ok  ] bound is a probability: 2.1073424255447017e-08
+  [ok  ] bound recomputed from the measurement: sqrt(2 x 2.22045e-16) = 2.10734e-08
+  [ok  ] converged flag consistent with the bound: True
+  consistent: the stated bound follows from the stated measurement
+```
+
+Exit status is 0 when every check passes and 1 when any fails, so it drops into CI.
+
+## Why this exists
+
+Classical simulation of quantum circuits is exact only in a narrow regime. Exact
+statevector methods terminate near 30 to 32 qubits, because state size grows as `2^n`.
+Beyond that every practical method is approximate: tensor networks truncate the bond
+dimension, Pauli propagation truncates operator weight, and real hardware substitutes
+device noise for the ideal distribution.
+
+An approximate result without an error statement is not a measurement, it is an
+assertion. **ZCC-v0.1** and **ZHF-v0.1** are small versioned protocols that attach a
+machine-checkable accuracy statement to a result. This tool is the checker: it takes a
+certificate and confirms the claim it makes follows from the measurement it reports.
+
+The protocols are specified in a citable paper:
+
+> Reporting the Accuracy of Approximate Quantum Circuit Simulation: A Machine-Checkable
+> Certificate Format. [doi.org/10.5281/zenodo.21851381](https://doi.org/10.5281/zenodo.21851381)
+
+## What this establishes
+
+The load-bearing check recomputes the declared bound from the measured quantity the
+certificate itself reports, and requires the two to agree:
+
+| Method | Reported quantity | Bound must equal |
+|---|---|---|
+| Matrix product state | discarded SVD weight `eps` | `min(1, sqrt(2 * eps))` |
+| Pauli propagation | discarded coefficient mass | the mass itself (additive) |
+| Exact / stabilizer | nothing discarded | zero |
+| Hardware (ZHF-v0.1) | Hellinger fidelity vs. the exact ideal | within `[0, 1]`, or explicitly declined |
+
+It also checks that the record is well formed, that the `converged` flag agrees with the
+bound (the two methods use different thresholds), that outcome counts do not exceed the
+shot count, and that no account data or circuit source is present.
+
+A certificate whose stated bound does not follow from its own stated inputs fails here,
+whoever issued it.
+
+## What this does not establish
+
+**It does not establish that the measurement was honest.** The discarded weight in a
+tensor-network certificate, and the coefficient mass in a Pauli one, are produced by
+whoever ran the simulation. No arithmetic on the record can confirm that the number
+reported is the number that was measured.
+
+Verifying a certificate is not the same as trusting the issuer. What it gives you is
+narrower and still worth having: the claim is well formed, self-consistent, and stated
+in a form somebody else can check.
+
+## Use as a library
+
+```python
+from zcc_verify import fetch, verify
+
+report = verify(fetch("df1d4c698a954051"))
+print(report.ok)                          # True
+print([c.name for c in report.failures])  # []
+```
+
+`fetch()` reads the public record at `https://api.zksf.org/certify/<id>/json`. It needs
+no authentication and no account. `verify()` takes a plain dict, so a record from any
+source, including a local file or a different issuer, can be checked:
+
+```bash
+zcc-verify ./certificate.json
+```
+
+Four live certificates to try, covering every accuracy regime the protocols describe:
+
+| Certificate | Run |
+|---|---|
+| `d904e28af0b441e0` | 3-qubit GHZ, exact stabilizer simulation |
+| `fe529e21d7404ff3` | 12-qubit GHZ, tensor network, measured bound of 2.11e-08 |
+| `5b8b2c4309d44d41` | 192-qubit GHZ, Pauli propagation |
+| `df1d4c698a954051` | Bell state on IonQ Forte-1 hardware, 0.977 fidelity |
+
+## On the limits of the bound
+
+The certified bound is an empirical result rather than a theorem. It held across 334
+runs at sizes where the exact answer is computable, 290 of them constructed specifically
+to break it, approaching at closest 49 percent of its value. Above 20 qubits it cannot
+be checked by direct comparison and no such evidence exists. Where a hard ceiling is
+required, use an exact or stabilizer engine.
+
+The paper is explicit about the case in which the motivating derivation does not extend:
+in deep sequential circuits the accumulated truncation weight has been measured
+understating the true infidelity by up to a factor of seven. It also shows, by explicit
+counterexample, that a natural tightening of the bound is unsound.
+
+## Where these certificates come from
+
+[ZKSF (Zero Kelvin Simulation Foundry)](https://zksf.org) runs quantum circuits on
+classical simulators, GPU accelerators, or real quantum processors, and attaches one of
+these accuracy statements to every approximate result.
+
+- **Python SDK** — [`qsim-sdk`](https://pypi.org/project/qsim-sdk/) on PyPI, source at
+  [official-dvl/zksf](https://github.com/official-dvl/zksf), DOI
+  [10.5281/zenodo.21836619](https://doi.org/10.5281/zenodo.21836619). Accepts Qiskit
+  circuits directly, and Cirq, PennyLane, pyQuil or Braket circuits via an optional
+  transpiler.
+- **Try it without an account** — the
+  [Colab quickstart](https://colab.research.google.com/github/official-dvl/zksf/blob/main/examples/quickstart.ipynb)
+  reads real completed certificates from the public API before it asks you for anything.
+- **Android app** — submit a circuit and read the result from a phone, including runs on
+  real quantum hardware:
+  [Google Play](https://play.google.com/store/apps/details?id=com.quantumcomputing.app).
+- **Protocol reference** —
+  [CERTIFICATION.md](https://github.com/official-dvl/zksf/blob/main/docs/CERTIFICATION.md)
+- **Documentation** — [zksf.org/docs](https://zksf.org/docs)
+
+This checker is deliberately independent of all of the above: it has no dependency on
+the SDK, needs no account, and will check a certificate issued by anyone who emits the
+format.
+
+## Licence
+
+MIT.

zcc_verify-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+zcc_verify/__init__.py,sha256=H-4pZfzSD1XzSJ1serK_Ra5__yLnh0KSJXzOA2lKjHU,14356
+zcc_verify/__main__.py,sha256=egqAJxQgU-h2yxcfHxQBkTQCiyXJFcGM2OIU0PZsWh8,100
+zcc_verify-0.1.0.dist-info/licenses/LICENSE,sha256=41brFj4dDCxsWVo3XaQEAJpA6QHm0Ev3o3ZaeqOxfjw,1142
+zcc_verify-0.1.0.dist-info/METADATA,sha256=q2PVGlx4I0hLMImLKpldBHOLVDhz0VhsmA_mUx5mMOk,8306
+zcc_verify-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+zcc_verify-0.1.0.dist-info/entry_points.txt,sha256=6VIPqHzfpKahIbKlsjCYlFRPRcg4XADbwF3EuWuZ610,47
+zcc_verify-0.1.0.dist-info/top_level.txt,sha256=E-KiKfLhZpVhS2sjAsICY5wIKKyTlDxLMrdPAOJBXKk,11
+zcc_verify-0.1.0.dist-info/RECORD,,

zcc_verify-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

zcc_verify-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+zcc-verify = zcc_verify:main

zcc_verify-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 ZKSF.org (Zero Kelvin Simulation Foundry)
+Copyright (c) 2026 Digital Venture Labs LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

zcc_verify-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+zcc_verify