Dr. Ilan Kreitmann · quantumpolycontextural.ai · readytogo@quantumpolycontextural.ai
QPC is ahead of its time. In the quantum computation world it stands as an outsider. The field is not willing to deal with it. Classic tools, algorithms and Hilbert space do not make it understandable that quantum computation needs quantum logic as the base for real quantum computation. This is new. It changes the classic computation rules. That has to be understood before anyone examines QPC, and before they see that it works for real quantum computation tasks.
Why one logic is not enough
Most real decisions are made under several logics at once. A drug candidate is judged for absorption, toxicity, metabolism and stability, and each of these is its own frame of evaluation with its own criteria. A photomask design is judged for printability, defect tolerance and process window. These frames do not reduce to one scale without losing what makes each of them meaningful.
Classical computation handles this by taking the frames one after another, fixing a true-or-false value at every step and joining the partial results afterwards. Most current quantum workflows follow the same pattern: a quantum circuit produces samples, a classical program evaluates them, adjusts the circuit and runs it again. The quantum processor becomes one stage inside a classical loop.
QPC puts those frames on the processor together. They compute inside one quantum state, act on each other while they compute, and are read out once.
From Günther's contextures to qubits
Gotthard Günther developed polycontextural logic from the 1950s onwards as a logic of many coexisting standpoints. Each standpoint, a contexture, is a complete two-valued logic in its own right. What is new is the relation between contextures: Günther introduced operators that act across contextures, and a rejection value that refuses the alternative offered inside one contexture instead of choosing a side of it. Rudolf Kaehr later gave these structures a formal calculus.
For decades this remained a theory without a machine. A classical computer settles every bit to 0 or 1 at every step, which is the forced single valuation polycontextural logic is defined against. A quantum processor holds the joint state until it is measured. That property makes it the physical carrier for coexisting logics, and QPC is the architecture that puts them there.
How a QPC computation runs
A QPC computation has three parts. First, each logic of the task becomes a contexture on the processor, carrying that logic's criteria. Second, contextures are coupled by transjunctions. Transjunctions operate between contextures while the computation runs. Third, the whole structure is measured once. There is no intermediate measurement and no optimiser feeding parameters back in. The application result, a ranking of candidates or a decision, is formed from the counts of that one job. The reported result is a measured property of the quantum state.
QPC is hardware-agnostic. Qiskit serves as the port through which the contexture structure enters the processor. We have run QPC tasks on IBM Fez, Torino, Kingston and Marrakesh, and on systems from IonQ, IQM, QuEra, Pasqal and Origin Quantum. The production compiler that constructs contextures and transjunctions and maps them onto a device is proprietary. The jobs it produces are public.
What ran, on which machine, at what size
A photomask decision desk on IBM Heron r2, ibm_kingston, evaluated six candidate masks under six manufacturing logics across four public ICCAD-2013 layouts, in one job on the 156-qubit register. The ranking of the six masks came out of the counts of that single job. The uncorrected mask led at 0.622 against the inverse-lithography mask at 0.460, against the pre-registered industry expectation. Job identifier: daas1burrl7c73860bd0.
A FLiBe desk on ibm_fez evaluated nine published molten-salt conformations under seventeen contextures, on the full 156-qubit register, in one job. Joint-structure gap +0.0095. Job identifier: d9a06m52su3c739l0eeg.
An ADMET lead desk on ibm_marrakesh evaluated nine drug compounds under seventeen pharmacological logics, absorption, distribution, metabolism, excretion and toxicity among them, in a 156-qubit run. Raw junction gap 0.185. Coupled jobs include d9qubi7pemts73crsa2g.
A 17-nucleotide RNA desk on ibm_kingston held four named helices together in one Sampler job. Nested fold H0+H3 at raw P = 0.241. Separable control reads competing stem H3. Job identifier: dbnj8ogqtr0c73ad6550.
In total the public record stands at 63 documented QPC tasks, each listed with its machine, its size and its job identifier on quantumpolycontextural.ai. Anyone with an IBM Quantum account can check that each of these jobs ran as recorded.
How we know the coupling works
Running many registers on one chip proves co-residence. The architecture test is whether the contextures act on each other. For that we compare every coupled structure against a matched control: the same contextures, on the same processor, at matched circuit depth, with the transjunctions switched off. If the coupling does real work, correlation between contextures appears in the coupled run and falls to background in the control.
We published this as the Joint Structure Challenge, a pre-registered test with its pass bars fixed before the runs: an inter-context correlation of at least 0.02 in the coupled structure, a gap of at least 0.05 over the uncoupled control, and an intracontext ratio of at least three. On IBM Fez, across three random seeds, the coupled structures cleared every bar. L5a raw ICC gaps: 0.289, 0.101 and 0.130. L5b depth-matched intracontext control: gaps 0.291, 0.101 and 0.145, ratios 22, 9 and 31 times. The correlation follows the coupling topology across three different circuit depths, so it is carried by the transjunctions. These figures come from raw counts.
A second test applies the architecture to human judgement data. In the question-order experiments of Wang and Busemeyer, people answer the same two questions differently depending on which comes first, a pattern that a single classical probability space does not reproduce. On IBM Fez, a structure of four coupled contextures matched the human response distribution more closely than a single contexture, with total variation distances of 0.251 against 0.302. Across 2,000 bootstrap replicates the ordering never reversed.
What QPC is
QPC is a computation architecture. It runs on the processors that exist today and lays a task out as many coexisting logics coupled inside one quantum state. A 100 percent quantum process runs on the processor from the first operation to the single measurement, with many contextures computing together and acting on each other through transjunctions. A matched control shows that the coupling carries the joint structure. Every one of these runs is on record with a job identifier.
An open invitation
I am sharing QPC here because it belongs in open scientific discussion. The paper describing the architecture and the 156-qubit runs is freely available on Zenodo, and the job record is public. I invite physicists, logicians and computer scientists in this community to examine the records, challenge the controls and propose tasks that test the architecture where it is hardest. Comments on this post are welcome.
Links
Paper, One-run polycontextural quantum computation on a 156-qubit processor (Zenodo): https://zenodo.org/records/22831221
QPC site and public job record: https://quantumpolycontextural.ai
Contact: readytogo@quantumpolycontextural.ai