QuantumComputinglib learn · inspect · formalize
Checked on this commit 2,822 public declarations commit 07559c3d051f Build record

Block encoding · exact finite logical reversible circuit

BE Case 1: isolated cold reconstruction

Reconstruct the same finite transfer contract in an isolated run that cannot retrieve the warm-route candidate implementation.

Lean certifiedAn isolated route closes the same mathematical contract with its own exact permutation and score (5,5,1,0).

Read this before the proof dashboard

Separate reproducible proof construction from claims about an agent rediscovering an answer.

A benchmark can accidentally become easy if the solver retrieves its previous answer. This case freezes the same E1 contract but reconstructs a different exact reversible completion in an isolated route.

The mathematics is the same block-encoding problem as BE Case 1. The scientific question is different: does an independent construction still reach a valid certificate?

Read the circuit

What the wires and stages are doing

1
Freeze

The target, ancilla convention, and alpha=1 are fixed before construction.

2
Construct

A five-gate reversible circuit implements a different full-space completion.

3
Verify

Lean checks bijectivity and the same clean 8 by 8 block.

4
Do not overclaim

There is one scored candidate, so the page does not call it a resource winner or a fresh model discovery.

The detailed circuit diagrams generated from the case record appear below this tutorial.

Statement → proof → optional Lean

The mathematical claims, in the order a human would prove them

Case theorem

An isolated permutation also block-encodes E1

\[\langle0|_aU_{\mathrm{cold}}|0\rangle_a=E_1,\qquad c(U_{\mathrm{cold}})=(5,5,1,0)\]

The isolated basis map is bijective, its clean block is E1, and its resource record is exact for the declared logical circuit.

Proof story

  1. Build the image tableDefine where every finite basis state goes.
  2. Prove it is a bijectionNo two inputs collide and every output is reached.
  3. Check the clean rows and columnsThe signal-zero submatrix is exactly E1.
  4. Package the costThe score is attached to this route without comparing it to a different semantic tier.
Show the Lean proof checkpoints

The mathematical explanation above is the reading layer. These compiled declarations are the proof authority.

Mathematical target

The equation being studied

\[E_1=|0\rangle\!\langle1|_{\mathrm{time}}\otimes|0\rangle\!\langle1|_{\mathrm{type}}\otimes I_2,\qquad \langle0|_aU_{\mathrm{cold}}|0\rangle_a=E_1.\]

Lean separately proves that the cold image table is bijective, that its clean projection is E_1, and that the packaged candidate has score (5,5,1,0). This page does not call replay a new rediscovery.

U_cold
the isolated finite permutation completion
a
the clean signal qubit

Circuit anatomy

How the candidate acts

These blocks show logical stages and register responsibilities. They do not pretend an unresolved logical oracle is already a primitive hardware gate.

Register ordersignal a | time t | type y | passive state s
01

Contract

freeze E_1 and the clean embedding

target
02

Cold construction

five logical reversible gates

XXcontrolledcontrolledcontrolled
03

Promotion

bijection plus exact clean block

Lean certificate

Auditable evolution

Candidate and proof progression

This is a proof-completion trace. There is one scored candidate, so no lexicographic dominance claim is made.

iteration0

Target fixed

Proof obligations opened

Register order, alpha=1, and the clean block are fixed before construction.

Target fixeda:ket0U_ cold ?t,y,s
Grouped-register circuit. Open the source or workbench to adapt notation.
Lean rootQuantumBlockEncoding.mainCaseColdPartialPerm_clean_eq_target Edit and preview this stage →
Copy this stage as quantikz
\begin{quantikz}[row sep=.4cm, column sep=.65cm]
\lstick{$a:\ket0$} & \gate[wires=2]{U_{\rm cold}\;?} & \meter{} \\
\lstick{$t,y,s$}    &                                  & \qw
\end{quantikz}
not ranked at this tier
iteration1

Cold permutation

Lean certified

The exact finite candidate closes bijectivity, projection, and resource fields.

Cold permutationa:ket0P_ coldket0 or garbaget,y,sE_1|t,y,s> on clean branch
Grouped-register circuit. Open the source or workbench to adapt notation.
Lean rootQuantumBlockEncoding.mainCaseColdPartialPermVerified Edit and preview this stage →
Copy this stage as quantikz
\begin{quantikz}[row sep=.4cm, column sep=.55cm]
\lstick{$a:\ket0$} & \gate[wires=2]{P_{\rm cold}} & \rstick{$\ket0$ or garbage} \qw \\
\lstick{$t,y,s$}    &                               & \rstick{$E_1\ket{t,y,s}$ on clean branch} \qw
\end{quantikz}
5gates5depth1aux0oracles

Reader workbench

Edit, preview, then copy

Change symbols, language, proof steps, or the grouped-register circuit locally in your browser. The preview is explanatory; the linked Lean declaration remains the certificate.

Mathematical construction

Proof steps

One step per line. Natural language and inline mathematics are both accepted.

    Quantum circuit

    Complete packet

    Copy the reviewed construction and proof

    The packet below is generated from the reviewed case record. The exact primitive authority is the linked Lean source and executable artifact.

    Construction and circuit LaTeX
    % Requires: \usepackage{quantikz}
    \paragraph{Construction.}
    \[
    E_1=|0\rangle\!\langle1|_{\mathrm{time}}\otimes|0\rangle\!\langle1|_{\mathrm{type}}\otimes I_2,\qquad \langle0|_aU_{\mathrm{cold}}|0\rangle_a=E_1.
    \]
    
    % Target fixed
    \begin{quantikz}[row sep=.4cm, column sep=.65cm]
    \lstick{$a:\ket0$} & \gate[wires=2]{U_{\rm cold}\;?} & \meter{} \\
    \lstick{$t,y,s$}    &                                  & \qw
    \end{quantikz}
    
    % Cold permutation
    \begin{quantikz}[row sep=.4cm, column sep=.55cm]
    \lstick{$a:\ket0$} & \gate[wires=2]{P_{\rm cold}} & \rstick{$\ket0$ or garbage} \qw \\
    \lstick{$t,y,s$}    &                               & \rstick{$E_1\ket{t,y,s}$ on clean branch} \qw
    \end{quantikz}
    English proof LaTeX
    \paragraph{Proof.}
    Lean separately proves that the cold image table is bijective, that its clean projection is E_1, and that the packaged candidate has score (5,5,1,0). This page does not call replay a new rediscovery.
    \begin{enumerate}
      \item Register order, alpha=1, and the clean block are fixed before construction.
      \item The exact finite candidate closes bijectivity, projection, and resource fields.
    \end{enumerate}
    Each advertised certificate is the named Lean declaration linked on this page.
    Lean declaration retrieval block
    import QuantumBlockEncoding
    
    #check QuantumBlockEncoding.mainCaseColdPartialPermImage_bijective
    #check QuantumBlockEncoding.mainCaseColdPartialPerm_clean_eq_target
    #check QuantumBlockEncoding.mainCaseColdPartialPermVerified
    #check QuantumBlockEncoding.mainCaseColdPartialPermCandidate_cost
    Show the complete Lean certificate list

    Open this when you want to inspect every declaration linked to the case.

    Proof authority

    Named Lean certificates

    These declarations, compiled by the current Lean gate, support the mathematical and resource claims above.

    Optional executable checks and outputs

    Executable verification and exports

    Checking and artifact selection are independent. A user may screen with Qiskit, OpenQASM round-trip, both, or neither, then request a different set of output files.

    Backend / artifactRoleStatusEvidence
    Internal canonical evaluatorReference semantics for primitive canonical IRopenmetrics manifest
    Qiskit OperatorGate-by-gate numerical screeningartifact availableexecutable-exports/QBE-MAIN-CASE-HIER-COLD-001/qiskit/export.py
    OpenQASM 3 round-tripStrict serialization, import, and semantic replaynot recordedQASM and report when generated
    Lean certificateExact proof authority at the page's stated semantic tierpassed4 named root(s)

    Exports the already certified permutation. Its finite matrix check does not establish the Lean theorem or a cold-start discovery claim.

    Current runnable artifact
    executable-exports/QBE-MAIN-CASE-HIER-COLD-001/qiskit/export.py
    Command
    python3 executable-exports/QBE-MAIN-CASE-HIER-COLD-001/qiskit/export.py --json
    Trust boundary. Fast executable checks may reject, rank, or queue a route for formalization. Floating-point tolerances do not replace the exact Lean roots above; an external exact certificate contributes only after a Lean checker verifies it.
    Source
    ASPBE BE Case 1 isolated replay
    Contributor
    ASPBE authors
    Current boundary
    The certificate is reproducible; replay alone is not evidence of fresh model discovery or global optimality.