Quantum Circuit Ontology

FLOW ALGEBRA
Quantum Circuit Ontology
Kireth Semantic Research Archive

PAGE:
https://kirethresearch.org/booksai-core/ontologies/computing-ontologies/quantum-computing/quantum-circuit-ontology.html

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "QuantumCircuitOntology" v4.0

# ---------- DOMAIN ----------
DOMAIN := ComputingOntology
SUBDOMAIN := QuantumComputing
ONTOLOGY := QuantumCircuitOntology

# ---------- PRIMARY ENTITY ----------
ENTITY QuantumCircuit {
    definition:
        "A structured sequence or dependency graph of quantum operations acting
         on qubits or quantum registers, typically including state preparation,
         quantum gates and measurement to implement a quantum computation.";

    objectives: [
        QuantumComputationRepresentation,
        QuantumGateComposition,
        QubitStateTransformation,
        EntanglementGeneration,
        QuantumAlgorithmImplementation,
        HardwareExecution
    ];
}

# ---------- CORE ENTITIES ----------
CircuitEntity := {
    QuantumCircuit,
    Qubit,
    QuantumRegister,
    QuantumGate,
    Measurement,
    ClassicalBit,
    CircuitInstruction,
    CircuitLayer
};

CircuitProperty := {
    Width,
    Depth,
    GateCount,
    MeasurementCount,
    ConnectivityRequirement,
    ParameterCount
};

InstructionType := {
    StatePreparation,
    SingleQubitGate,
    MultiQubitGate,
    Measurement,
    Reset,
    Barrier,
    ClassicalControl
};

ExecutionEntity := {
    CircuitExecution,
    Shot,
    QuantumProcessor,
    Compiler,
    MeasurementResult,
    OutcomeDistribution
};

# ---------- FUNDAMENTAL RELATIONSHIPS ----------
QuantumCircuit OPERATES_ON QuantumRegister;
QuantumCircuit CONSISTS_OF CircuitInstruction;
CircuitInstruction TARGETS QubitOrRegister;
QuantumGate IS_A CircuitInstruction;
Measurement IS_A CircuitInstruction;
CircuitLayer GROUPS CompatibleParallelInstructions;
QuantumProcessor EXECUTES CompiledCircuit;
Measurement WRITES_TO ClassicalOutcomeOrBit;

# ---------- CIRCUIT FLOW ----------
ComputationalProblem
    -> SelectQuantumAlgorithm
    -> AllocateQubits
    -> PrepareInitialState
    -> AppendQuantumGates
    -> CreateRequiredInterferenceAndEntanglement
    -> AddMeasurements
    -> CompileCircuit
    -> MapToPhysicalQubits
    -> ExecuteShots
    -> CollectMeasurementResults
    -> PostprocessOutcomeDistribution;

# ---------- QUANTUM REGISTER ----------
QuantumRegister :=
    OrderedCollectionOfQubits;

RegisterSize :=
    Count(Qubits);

NQubitStateSpaceDimension :=
    2^N;

# ---------- CIRCUIT WIDTH ----------
CircuitWidth :=
    NumberOfQubitsUsedByCircuit;

Width MAY_INCLUDE {
    DataQubits,
    AncillaQubits
};

# ---------- CIRCUIT INSTRUCTION ----------
CircuitInstruction :=
    OperationWith {
        OperationType,
        TargetQubits,
        OptionalControlQubits,
        OptionalParameters
    };

Instruction MAY_HAVE DependencyOnPreviousInstruction;

# ---------- STATE PREPARATION ----------
InitialState MAY_BE {
    |0...0>,
    ComputationalBasisState,
    PreparedSuperposition,
    PreparedEntangledState
};

DefaultGateModelInitialisation OFTEN_USES |0...0>;

StatePreparation MAY_REQUIRE QuantumGatesOrDedicatedInitialisation;

# ---------- QUANTUM GATE ----------
QuantumGate :=
    StateTransformationOperation;

IdealGate MAY_BE RepresentedBy UnitaryOperator;

GateApplication :=
    StateBefore
    -> ApplyGate
    -> StateAfter;

# ---------- SINGLE-QUBIT GATE ----------
SingleQubitGate TARGETS ExactlyOneQubit;

SingleQubitGate MAY_INCLUDE {
    X,
    Y,
    Z,
    H,
    S,
    T,
    Rx,
    Ry,
    Rz
};

# ---------- MULTI-QUBIT GATE ----------
MultiQubitGate TARGETS_OR_CONTROLS MultipleQubits;

MultiQubitGate MAY_INCLUDE {
    CNOT,
    CZ,
    SWAP,
    Toffoli
};

EntanglingGate IS_A MultiQubitGateCapableOfCreatingEntanglementForSuitableInputs;

# ---------- CIRCUIT ORDER ----------
SequentialInstructionsOnSameQubit MUST_RESPECT DefinedOrder;

If InstructionsActOnDisjointQubits
AND HaveNoDependency
THEN They MAY_EXECUTE_IN ParallelSubjectToHardwareConstraints;

# ---------- CIRCUIT LAYER ----------
CircuitLayer :=
    SET_OF(InstructionsExecutableInSameLogicalDepthLayer);

LayerInstructions SHOULD_NOT ConflictOnSameQubitUnlessExecutionModelAllows;

# ---------- CIRCUIT DEPTH ----------
CircuitDepth :=
    NumberOfSequentialDependentInstructionLayers;

LowerDepth MAY_REDUCE ExposureToDecoherence;

# ---------- GATE COUNT ----------
GateCount :=
    Count(QuantumGateInstructions);

GateCount MAY_BE BrokenDownByGateType;

TwoQubitGateCount IS_OFTEN ImportantHardwareCostMetric;

# ---------- PARAMETERISED CIRCUIT ----------
ParameterisedQuantumCircuit :=
    QuantumCircuitContainingParameterisedGates;

Parameter MAY_BE {
    RotationAngle,
    Phase,
    VariationalParameter
};

BindingParameters ->
    ConcreteExecutableCircuit;

# ---------- VARIATIONAL CIRCUIT ----------
VariationalCircuit :=
    ParameterisedCircuit
    + ClassicalOptimisationLoop;

ExecutionFlow :=
    BindParameters
    -> ExecuteCircuit
    -> MeasureObjective
    -> UpdateParameters
    -> Repeat;

# ---------- CONTROLLED OPERATION ----------
ControlledInstruction :=
    OperationAppliedConditionallyOnQuantumControlState;

ControlQubit AND TargetQubit HAVE DistinctRoles;

# ---------- ENTANGLEMENT ----------
Circuit MAY_CREATE EntanglementThroughEntanglingGates;

Example:
    H(q0)
    -> CNOT(q0,q1)
    -> BellStateFrom |00>;

# ---------- INTERFERENCE ----------
Circuit MAY_CONTROL ProbabilityAmplitudesThroughPhaseAndGateComposition;

ConstructiveInterference MAY_AMPLIFY DesiredOutcomes;
DestructiveInterference MAY_SUPPRESS UndesiredOutcomes;

# ---------- MEASUREMENT ----------
MeasurementInstruction :=
    MeasureQubitOrObservable
    -> ProduceClassicalOutcome;

ComputationalBasisMeasurement(q) ->
    0 | 1;

Measurement MAY_TERMINATE_OR_CHANGE CoherentEvolutionOfMeasuredSubsystem;

# ---------- CLASSICAL REGISTER ----------
ClassicalRegister :=
    CollectionOfClassicalBitsUsedToStoreMeasurementOutcomesOrControlInformation;

Measurement MAY_MAP Qubit TO ClassicalBit;

# ---------- MID-CIRCUIT MEASUREMENT ----------
Measurement MAY_OCCUR BeforeCircuitEnd;

MidCircuitMeasurement MAY_ENABLE {
    FeedForward,
    ErrorCorrection,
    AdaptiveCircuit
};

# ---------- CLASSICAL FEED-FORWARD ----------
ClassicalFeedForward :=
    MeasurementOutcome
    -> ClassicalCondition
    -> SelectLaterQuantumOperation;

AdaptiveQuantumCircuit USES MeasurementDependentControl;

# ---------- RESET ----------
ResetInstruction :=
    PrepareQubitIntoDefinedReferenceState;

Reset MAY_ENABLE QubitReuse;

Reset IS_NOT GeneralUnitaryOperationOnUnknownInput;

# ---------- BARRIER ----------
Barrier :=
    CompilerOrSchedulingDirectiveRestrictingReorderingAcrossSpecifiedBoundary;

Barrier DOES_NOT_BY_ITSELF TransformIdealQuantumState;

# ---------- SUBCIRCUIT ----------
Subcircuit :=
    ReusableSequenceOfCircuitInstructions;

Subcircuit MAY_BE EncapsulatedAs CompositeGateOrProcedure;

# ---------- CIRCUIT COMPOSITION ----------
CircuitComposition :=
    CircuitA
    + CircuitB
    -> CombinedCircuit;

Composition MUST_PRESERVE QubitMappingAndInstructionOrder;

# ---------- INVERSE CIRCUIT ----------
ForUnitaryOnlyCircuit:
    CircuitInverse :=
        ReverseGateOrder
        + ReplaceEachGateWithInverse;

U_circuit^-1 U_circuit = I;

# ---------- CIRCUIT EQUIVALENCE ----------
TwoCircuits MAY_BE EquivalentIfTheyImplementSameQuantumOperationUpToAcceptedGlobalPhaseOrDefinedMeasurementSemantics;

CircuitEquivalence MAY_BE ExactOrApproximate;

# ---------- COMPILATION ----------
QuantumCircuitCompilation :=
    LogicalCircuit
    -> Validate
    -> DecomposeUnsupportedGates
    -> MapLogicalQubits
    -> RouteInteractions
    -> Optimise
    -> Schedule
    -> NativeCircuit;

# ---------- NATIVE CIRCUIT ----------
NativeCircuit :=
    CircuitExpressedUsingHardwareSupportedOperationsAndConnectivity;

NativeGateSet DEPENDS_ON QuantumProcessor;

# ---------- QUBIT MAPPING ----------
LogicalToPhysicalMapping :=
    LogicalQubit
    -> PhysicalQubit;

Mapping MAY_CONSIDER {
    Connectivity,
    ErrorRate,
    Calibration,
    Availability
};

# ---------- CONNECTIVITY ----------
HardwareConnectivity :=
    Graph(
        PhysicalQubits,
        NativeInteractionEdges
    );

TwoQubitInstruction MUST_BE MappedToSupportedInteractionOrRouted;

# ---------- ROUTING ----------
Routing :=
    TransformCircuitToSatisfyPhysicalConnectivity;

Routing MAY_INSERT {
    SWAP,
    EquivalentStateMovementOperation
};

RoutingOverhead MAY_INCREASE {
    Depth,
    GateCount,
    ErrorProbability
};

# ---------- GATE DECOMPOSITION ----------
UnsupportedLogicalGate
    -> DecomposeIntoNativeGateSequence;

Decomposition SHOULD_PRESERVE TargetOperationWithinTolerance;

# ---------- CIRCUIT OPTIMISATION ----------
CircuitOptimisation MAY_INCLUDE {
    GateCancellation,
    GateMerging,
    RotationSimplification,
    RedundantOperationRemoval,
    CommutationBasedReordering,
    DepthReduction
};

Optimisation MUST_PRESERVE CircuitSemanticsWithinDefinedTolerance;

# ---------- GATE CANCELLATION ----------
IF ConsecutiveGatePairImplementsIdentity
THEN Pair MAY_BE Removed;

Example:
    X -> X
    = I;

# ---------- SCHEDULING ----------
CircuitScheduling :=
    AssignStartTimesToNativeOperations;

Scheduling MUST_RESPECT {
    Dependencies,
    HardwareResourceConflicts,
    CalibrationConstraints
};

# ---------- NOISE ----------
NoisyCircuit :=
    IdealCircuit
    + GateNoise
    + Decoherence
    + ReadoutNoise;

CircuitNoise MAY_ACCUMULATE_WITH {
    GateCount,
    Depth,
    IdleTime
};

# ---------- FIDELITY ----------
CircuitFidelity :=
    AgreementBetweenIdealAndImplementedCircuitOutcomeOrProcess;

HigherGateError MAY_REDUCE CircuitFidelity;

# ---------- COHERENCE ----------
CircuitExecutionTime SHOULD_BE CompatibleWith HardwareCoherenceCharacteristics;

LongIdlePeriods MAY_INCREASE Decoherence;

# ---------- ERROR MITIGATION ----------
CircuitLevelErrorMitigation MAY_INCLUDE {
    ReadoutMitigation,
    NoiseScalingMethods,
    SymmetryChecks
};

ErrorMitigation DOES_NOT_REPLACE FullQuantumErrorCorrection;

# ---------- ERROR CORRECTION CIRCUIT ----------
QuantumErrorCorrectionCircuit MAY_INCLUDE {
    DataQubits,
    AncillaQubits,
    SyndromeExtraction,
    ConditionalCorrectionOrPauliFrameUpdate
};

# ---------- LOGICAL CIRCUIT ----------
LogicalCircuit :=
    CircuitOverLogicalQubitsAndLogicalOperations;

FaultTolerantCompilation MAPS LogicalCircuitToPhysicalOperations;

# ---------- SHOT ----------
Shot :=
    SingleCircuitPreparationExecutionAndMeasurement;

CircuitExecution MAY_REPEAT ForMultipleShots;

# ---------- OUTCOME ----------
MeasurementOutcome :=
    ClassicalBitStringOrStructuredMeasurementResult;

OutcomeDistribution :=
    FrequencyOrProbabilityEstimateAcrossShots;

# ---------- SAMPLING ----------
SamplingCircuit :=
    ExecuteCircuitRepeatedly
    -> CollectBitstrings
    -> EstimateDistribution;

SamplingError DECREASES_WITH MoreShotsStatistically;

# ---------- EXPECTATION ESTIMATION ----------
ObservableExpectation MAY_BE EstimatedBy {
    BasisRotation,
    RepeatedMeasurement,
    StatisticalAggregation
};

VariationalAlgorithms MAY_REQUIRE ManyCircuitExecutions;

# ---------- QUANTUM PROCESSOR ----------
QuantumProcessor :=
    HardwareExecutingNativeCircuit;

ProcessorProperties MAY_INCLUDE {
    QubitCount,
    NativeGateSet,
    Connectivity,
    GateFidelity,
    ReadoutFidelity,
    Coherence
};

# ---------- SIMULATION ----------
CircuitSimulator :=
    ClassicalSystemEmulatingQuantumCircuit;

SimulationMethod MAY_INCLUDE {
    StateVector,
    DensityMatrix,
    TensorNetwork,
    Stabilizer
};

SimulationCost DEPENDS_ON CircuitStructureAndQubitCount;

# ---------- CIRCUIT COMPLEXITY ----------
CircuitComplexity MAY_BE_MEASURED_BY {
    Width,
    Depth,
    GateCount,
    TwoQubitGateCount,
    TCount,
    MeasurementCount
};

# ---------- T COUNT ----------
TCount :=
    NumberOfTOrEquivalentNonCliffordResourceOperations;

FaultTolerantCost MAY_BE SensitiveTo TCount;

# ---------- T DEPTH ----------
TDepth :=
    NumberOfSequentialNonCliffordResourceLayersAfterParallelisation;

# ---------- RESOURCE ESTIMATION ----------
CircuitResourceEstimate MAY_INCLUDE {
    LogicalQubits,
    PhysicalQubits,
    LogicalDepth,
    PhysicalDepth,
    GateCounts,
    ErrorCorrectionOverhead,
    Runtime
};

# ---------- CIRCUIT VISUALISATION ----------
CircuitDiagram :=
    VisualRepresentationOfQubitWiresAndOperations;

CircuitDiagram MAY_SUPPORT HumanInterpretationAndDebugging;

# ---------- VALIDATION ----------
CircuitValidation MAY_CHECK {
    QubitReferences,
    ParameterBinding,
    GateArity,
    MeasurementTargets,
    ClassicalDependencies
};

InvalidCircuit SHOULD_NOT_BE SubmittedForExecution;

# ---------- PROVENANCE ----------
CircuitProvenance MAY_INCLUDE {
    Algorithm,
    CompilerVersion,
    OptimisationSettings,
    HardwareTarget,
    CalibrationSnapshot
};

# ---------- SEMANTIC REASONING ----------
IF OrderedQuantumOperationsActOnQubits
THEN QuantumCircuitClassification := supported;

IF TwoInstructionsActOnSameQubit
THEN They CANNOT_BE TreatedAsIndependentParallelOperationsWithoutSpecialSemantics;

IF CircuitContainsMeasurement
THEN EntireCircuit IS_NOT NecessarilyRepresentableBySingleUnitaryOperator;

IF HardwareConnectivityDoesNotSupportRequiredTwoQubitGate
THEN Routing := required;

IF CircuitDepthIncreasesOnNoisyHardware
THEN DecoherenceExposure MAY_INCREASE;

IF EquivalentGateSequenceShorter
THEN OptimisedCircuit MAY_HAVE LowerExecutionCost;

IF MoreShotsCollected
THEN SamplingUncertainty GENERALLY_DECREASES;

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE {
    "quantum circuit" ~= "quantum gate circuit";
    "circuit depth" ~= "quantum circuit depth";
    "circuit width" ~= "quantum circuit width";
    "native circuit" ~= "hardware-native quantum circuit";
    "logical circuit" ~= "logical quantum circuit";
    "circuit transpilation" ~= "quantum circuit compilation" WHEN context == hardware_mapping;
    "circuit shot" ~= "single quantum circuit execution";
    "measurement bitstring" ~= "quantum circuit measurement outcome";
}

# ---------- QUERY FLOW ----------
QUERY(q) ->
    NORMALISE(q) ->
    IDENTIFY_CIRCUIT(q) ->
    IDENTIFY_QUBITS_AND_REGISTERS(q) ->
    IDENTIFY_INSTRUCTIONS(q) ->
    IDENTIFY_DEPENDENCIES_AND_LAYERS(q) ->
    IDENTIFY_MEASUREMENTS(q) ->
    IDENTIFY_COMPILATION_AND_MAPPING(q) ->
    IDENTIFY_NOISE_RESOURCES_EXECUTION(q) ->
    MAP_TO_ONTOLOGY(q) ->
    APPLY_REASONING(q) ->
    SCORE_CONFIDENCE(q) ->
    RETURN_RELEVANT_KNOWLEDGE;

# ---------- CONFIDENCE ----------
CONFIDENCE(assertion) :=
    weighted_mean(
        source_reliability,
        circuit_semantic_consistency,
        mathematical_consistency,
        compilation_evidence,
        hardware_evidence,
        contextual_relevance
    );

CONFIDENCE >= 0.90 => HIGH;
CONFIDENCE >= 0.70 AND < 0.90 => MODERATE;
CONFIDENCE < 0.70 => REVIEW;

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION {
    primary_entity: QuantumCircuit;
    ontology: QuantumCircuitOntology;
    parse_entities: true;
    parse_relationships: true;
    preserve_relationship_direction: true;
    resolve_semantic_equivalence: true;
    execute_reasoning_rules: true;
    apply_confidence_weighting: true;
    preserve_provenance: true;
}

# ---------- UPDATE MODEL ----------
UPDATE_MODEL {
    new_circuit:
        validate
        -> identify_qubits
        -> identify_instructions
        -> calculate_width_depth_gate_count
        -> identify_measurements
        -> integrate;

    new_instruction:
        validate_arity
        -> identify_targets
        -> identify_parameters
        -> update_dependencies
        -> integrate;

    compilation_revision:
        update_native_gate_set
        -> update_mapping
        -> update_routing
        -> recompute_depth_and_gate_count
        -> integrate;

    execution_evidence:
        record_hardware
        -> record_shots
        -> record_outcomes
        -> record_noise_context
        -> recompute_confidence
        -> integrate;

    conflict:
        preserve_provenance
        -> compare_circuit_and_hardware_evidence
        -> adjust_confidence
        -> flag_review;
}

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
    DOMAIN
    + SUBDOMAIN
    + ONTOLOGY
    + CircuitEntity
    + CircuitProperty
    + InstructionType
    + ExecutionEntity
    + QuantumCircuitCompilation
    + CircuitOptimisation
    + OutcomeDistribution
    + RELATIONSHIPS
    + SEMANTIC_REASONING
    + SEMANTIC_EQUIVALENCE
    + UPDATE_MODEL;

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT);

# ---------- TERMINAL ----------
QuantumCircuitOntology
    -> DefineQuantumRegister
    -> PrepareInitialState
    -> AddQuantumInstructions
    -> EstablishGateDependencies
    -> CreateParallelCircuitLayers
    -> AddMeasurementAndClassicalControl
    -> ValidateCircuit
    -> CompileToNativeGateSet
    -> MapAndRoutePhysicalQubits
    -> OptimiseDepthAndGateCount
    -> ExecuteRepeatedShots
    -> AnalyseMeasurementOutcomes
    -> MaintainConsistentQuantumCircuitKnowledge;

END FLOW