Quantum Bit Ontology

FLOW ALGEBRA
Quantum Bit Ontology
Kireth Semantic Research Archive

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

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "QuantumBitOntology" v4.0

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

# ---------- PRIMARY ENTITY ----------
ENTITY QuantumBit {
    definition:
        "A quantum bit, or qubit, is a two-level quantum information system
         whose state may be represented as a normalised complex linear
         combination of two orthogonal basis states and transformed by
         quantum operations before measurement produces a classical outcome.";

    aliases: [
        Qubit,
        QuantumBit
    ];

    objectives: [
        QuantumInformationRepresentation,
        Superposition,
        PhaseEncoding,
        QuantumStateTransformation,
        EntanglementParticipation,
        QuantumMeasurement
    ];
}

# ---------- CORE ENTITIES ----------
QubitEntity := {
    Qubit,
    QuantumState,
    BasisState,
    ProbabilityAmplitude,
    Phase,
    QuantumGate,
    Measurement
};

BasisType := {
    ComputationalBasis,
    AlternativeMeasurementBasis
};

QubitProperty := {
    Amplitude,
    RelativePhase,
    BlochVector,
    Coherence,
    Fidelity
};

PhysicalQubitPlatform := {
    SuperconductingQubit,
    TrappedIonQubit,
    NeutralAtomQubit,
    PhotonicQubit,
    SpinQubit
};

# ---------- FUNDAMENTAL RELATIONSHIPS ----------
Qubit HAS QuantumState;
QuantumState EXPRESSED_IN Basis;
Basis CONSISTS_OF OrthogonalBasisStates;
ProbabilityAmplitude ASSOCIATED_WITH BasisState;
QuantumGate TRANSFORMS QubitState;
Measurement MAPS QuantumState TO ClassicalOutcomeDistribution;
MultipleQubits MAY_FORM QuantumRegister;
Qubit MAY_BE_ENTANGLED_WITH OtherQubit;

# ---------- ABSTRACT QUBIT STATE ----------
ComputationalBasis := {
    |0>,
    |1>
};

GeneralPureQubitState :=
    alpha|0> + beta|1>;

alpha IN ComplexNumbers;
beta IN ComplexNumbers;

NormalisationConstraint :=
    |alpha|^2 + |beta|^2 = 1;

# ---------- GLOBAL PHASE ----------
GlobalPhaseEquivalentStates :=
    |psi>
    ~=
    exp(i*gamma)|psi>;

GlobalPhase DOES_NOT_CHANGE IdealMeasurementStatistics;

RelativePhase CAN_CHANGE InterferenceAndMeasurementStatisticsInOtherBases;

# ---------- PROBABILITY AMPLITUDE ----------
ProbabilityAmplitude :=
    ComplexCoefficientOfBasisComponent;

AmplitudeMagnitudeSquared :=
    MeasurementProbabilityInCorrespondingBasis;

P(0) :=
    |alpha|^2;

P(1) :=
    |beta|^2;

P(0) + P(1) = 1;

# ---------- SUPERPOSITION ----------
SuperpositionRelativeToBasis :=
    StateHasMultipleNonzeroBasisAmplitudes;

IF alpha != 0
AND beta != 0
THEN QubitState IS_IN SuperpositionRelativeToComputationalBasis;

Superposition IS_DEPENDENT_ON ChosenBasis;

# ---------- BASIS STATES ----------
|0> :=
    [1, 0]^T;

|1> :=
    [0, 1]^T;

InnerProduct(<0|1>) = 0;

BasisStates ARE Orthogonal;

# ---------- BLOCH SPHERE ----------
PureSingleQubitState MAY_BE_WRITTEN_AS:
    cos(theta/2)|0>
    + exp(i*phi)sin(theta/2)|1>;

BlochCoordinates :=
    {
        x = sin(theta)cos(phi),
        y = sin(theta)sin(phi),
        z = cos(theta)
    };

PureStateBlochVectorLength := 1;

# ---------- DENSITY MATRIX ----------
QubitState MAY_BE RepresentedBy DensityOperator;

PureStateDensityMatrix :=
    |psi><psi|;

MixedState :=
    StatisticalMixtureOfQuantumStates;

DensityMatrixProperties MAY_INCLUDE {
    Hermitian,
    PositiveSemidefinite,
    TraceOne
};

# ---------- MIXED STATE ----------
MixedState CANNOT_IN_GENERAL_BE RepresentedBySingleStateVector;

BlochVectorLengthForMixedState MAY_BE < 1;

# ---------- QUANTUM GATE ----------
SingleQubitGate :=
    UnitaryTransformationOnQubitState;

StateTransition :=
    |psi_out> = U|psi_in>;

UnitaryCondition :=
    U_dagger U = I;

# ---------- PAULI X ----------
X :=
    [[0,1],
     [1,0]];

X|0> = |1>;
X|1> = |0>;

X MAY_BE_INTERPRETED_AS QuantumBitFlip;

# ---------- PAULI Y ----------
Y :=
    [[0,-i],
     [i,0]];

Y IS UnitaryAndHermitian;

# ---------- PAULI Z ----------
Z :=
    [[1,0],
     [0,-1]];

Z|0> = |0>;
Z|1> = -|1>;

Z CHANGES RelativePhaseOfComputationalBasisComponents;

# ---------- HADAMARD ----------
H :=
    (1/sqrt(2))
    *
    [[1,1],
     [1,-1]];

H|0> :=
    (|0> + |1>) / sqrt(2);

H|1> :=
    (|0> - |1>) / sqrt(2);

Hadamard MAPS BetweenComputationalAndXRelatedBases;

# ---------- PHASE ----------
PhaseGate MAY_CHANGE RelativePhase;

RelativePhase IS ComputationallyRelevantThroughInterference;

# ---------- ROTATION ----------
RotationGate MAY_INCLUDE {
    Rx(theta),
    Ry(theta),
    Rz(theta)
};

Rotation MAY_BE VisualisedAs RotationOfBlochVector;

# ---------- MEASUREMENT ----------
ComputationalBasisMeasurement :=
    MeasureQubitInBasis {|0>, |1>};

OutcomeSet := {0,1};

Probability(outcome=0) = |alpha|^2;
Probability(outcome=1) = |beta|^2;

# ---------- POST-MEASUREMENT STATE ----------
IdealProjectiveMeasurement:
    outcome 0 -> post_state |0>;
    outcome 1 -> post_state |1>;

Measurement CHANGES StateAccordingToMeasurementOutcomeAndMeasurementModel;

# ---------- ALTERNATIVE BASIS ----------
Qubit MAY_BE_MEASURED_IN AlternativeBasis;

XBasis := {
    |+> = (|0> + |1>)/sqrt(2),
    |-> = (|0> - |1>)/sqrt(2)
};

MeasurementStatistics DEPEND_ON Basis;

# ---------- EXPECTATION VALUE ----------
ExpectationValue(Observable A) :=
    <psi|A|psi>;

ForDensityMatrix:
    ExpectationValue(A) :=
        Tr(rho A);

# ---------- COMPOSITE SYSTEM ----------
TwoQubitSystem :=
    QubitA tensor_product QubitB;

CompositeBasis := {
    |00>,
    |01>,
    |10>,
    |11>
};

# ---------- PRODUCT STATE ----------
ProductState :=
    |psi_A> tensor_product |psi_B>;

ProductState HAS SeparableSubsystemDescription;

# ---------- ENTANGLEMENT ----------
EntangledTwoQubitState :=
    CompositeStateNotExpressibleAsProductOfSingleQubitStates;

BellState :=
    (|00> + |11>) / sqrt(2);

QubitInEntangledPair MAY_NOT_HAVE IndependentPureStateDescription;

# ---------- REDUCED STATE ----------
SubsystemState MAY_BE ObtainedByPartialTraceOfCompositeDensityMatrix;

EntangledCompositePureState MAY_GIVE MixedReducedStateForIndividualQubit;

# ---------- CNOT RELATIONSHIP ----------
CNOT :=
    ControlledTwoQubitOperation;

H on ControlQubit
    -> CNOT
    MAY_CREATE BellEntanglementFrom |00>;

# ---------- NO-CLONING ----------
NoCloningTheorem :=
    ArbitraryUnknownQubitStateCannotBePerfectlyCopiedByUniversalUnitaryOperation;

ClassicalBitCopyOperation DOES_NOT_GENERALISE_TO ArbitraryQuantumState;

# ---------- DISTINGUISHABILITY ----------
NonOrthogonalQuantumStates CANNOT_BE PerfectlyDistinguishedWithSingleMeasurementInGeneral;

OrthogonalStates MAY_BE PerfectlyDistinguishedBySuitableMeasurement;

# ---------- COHERENCE ----------
Coherence :=
    PreservationOfPhaseRelationshipsRequiredForQuantumInterference;

Coherence MAY_BE_DEGRADED_BY EnvironmentalInteraction;

# ---------- DECOHERENCE ----------
Decoherence :=
    EvolutionFromCoherentQuantumBehaviourTowardMixedOrClassicallyCorrelatedBehaviourDueToEnvironment;

Decoherence MAY_REDUCE BlochVectorLengthForEffectiveSingleQubitState;

# ---------- RELAXATION ----------
EnergyRelaxation :=
    PopulationDecayTowardLowerEnergyState;

T1 :=
    CharacteristicEnergyRelaxationTime;

# ---------- DEPHASING ----------
Dephasing :=
    LossOfRelativePhaseInformation;

T2 :=
    CharacteristicPhaseCoherenceTime;

Typically:
    T2 <= 2*T1
UNDER common_markovian_models;

# ---------- NOISE CHANNEL ----------
QubitNoise MAY_BE_MODELLED_AS QuantumChannel;

NoiseChannel MAY_INCLUDE {
    BitFlipChannel,
    PhaseFlipChannel,
    DepolarisingChannel,
    AmplitudeDampingChannel,
    DephasingChannel
};

# ---------- BIT FLIP ERROR ----------
BitFlipError :=
    X AppliedUnintentionally;

# ---------- PHASE FLIP ERROR ----------
PhaseFlipError :=
    Z AppliedUnintentionally;

# ---------- READOUT ERROR ----------
ReadoutError :=
    MeasuredClassicalOutcomeDiffersFromIdealUnderlyingMeasurementOutcome;

ReadoutCalibration MAY_ESTIMATE ConfusionProbabilities;

# ---------- FIDELITY ----------
StateFidelity :=
    MeasureOfClosenessBetweenQuantumStates;

ForPureStates:
    Fidelity(|psi>,|phi>) :=
        |<psi|phi>|^2;

HigherFidelity INDICATES GreaterStateSimilarity;

# ---------- PHYSICAL QUBIT ----------
PhysicalQubit :=
    PhysicalTwoLevelOrEffectiveTwoLevelQuantumSystemUsedToEncodeQuantumInformation;

PhysicalImplementation HAS {
    ControlMechanism,
    ReadoutMechanism,
    NoiseCharacteristics,
    CoherenceCharacteristics
};

# ---------- SUPERCONDUCTING QUBIT ----------
SuperconductingQubit :=
    EngineeredQuantumCircuitUsingSuperconductingElements;

Control MAY_USE MicrowavePulses;
Readout MAY_USE ResonatorBasedMeasurement;

# ---------- TRAPPED ION QUBIT ----------
TrappedIonQubit :=
    QubitEncodedInInternalOrMotionalStatesOfTrappedIon;

Control MAY_USE LaserOrMicrowaveInteraction;

# ---------- PHOTONIC QUBIT ----------
PhotonicQubit MAY_ENCODE QuantumInformationIn {
    Polarisation,
    Path,
    TimeBin,
    OtherOpticalDegreeOfFreedom
};

# ---------- SPIN QUBIT ----------
SpinQubit :=
    QubitEncodedInSpinOrSpinLikeDegreeOfFreedom;

# ---------- LOGICAL QUBIT ----------
LogicalQubit :=
    ErrorProtectedQuantumInformationEncodedAcrossMultiplePhysicalQubits;

LogicalQubit MAY_HAVE LowerEffectiveErrorRateThanConstituentPhysicalOperationsWhenFaultToleranceConditionsSatisfied;

# ---------- QUANTUM ERROR CORRECTION ----------
QuantumErrorCorrection :=
    Encode
    -> DetectSyndrome
    -> InferError
    -> CorrectOrTrack
    -> PreserveLogicalState;

MeasurementOfSyndrome SHOULD_AVOID DirectMeasurementOfUnknownLogicalInformation;

# ---------- INITIALISATION ----------
QubitInitialisation :=
    PrepareKnownReferenceState;

CommonInitialState :=
    |0>;

InitialisationError MAY_AFFECT CircuitOutcome;

# ---------- RESET ----------
ResetOperation :=
    PrepareQubitIntoDefinedStateDuringOrBetweenComputations;

# ---------- CONTROL ----------
QubitControl :=
    ApplyPhysicalSignal
    -> ImplementTargetQuantumOperation;

ControlPulse MAY_HAVE {
    Amplitude,
    Frequency,
    Phase,
    Duration
};

# ---------- CALIBRATION ----------
QubitCalibration :=
    EstimateAndTuneControlAndReadoutParameters;

Calibration MAY_TARGET {
    GateFidelity,
    ReadoutFidelity,
    Frequency,
    PulseShape
};

# ---------- CONNECTIVITY ----------
PhysicalQubit MAY_HAVE NativeInteractionWith SelectedOtherQubits;

ConnectivityGraph :=
    PhysicalQubits
    + NativeTwoQubitLinks;

# ---------- RESOURCE ROLE ----------
Qubit MAY_SERVE_AS {
    DataQubit,
    AncillaQubit,
    CommunicationQubit,
    LogicalCodeComponent
};

# ---------- ANCILLA ----------
AncillaQubit :=
    AuxiliaryQubitUsedForComputationMeasurementOrErrorCorrection;

Ancilla MAY_BE InitialisedAndMeasuredWithoutRepresentingPrimaryLogicalData;

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

NQubitRegister HAS HilbertSpaceDimension 2^N;

# ---------- CLASSICAL BIT COMPARISON ----------
ClassicalBit HAS DefiniteStateIn {0,1}UnderIdealClassicalModel;

Qubit MAY_HAVE CoherentSuperpositionRelativeToChosenBasis;

QubitMeasurement PRODUCES ClassicalOutcome;

Qubit != ClassicalBitWithUnknownValue;

# ---------- INFORMATION EXTRACTION ----------
UnknownQubitState CANNOT_BE FullyDeterminedFromSingleCopy;

QuantumStateTomography REQUIRES MeasurementsAcrossManyIdenticallyPreparedSystems;

# ---------- QUANTUM STATE TOMOGRAPHY ----------
StateTomography :=
    PrepareManyEquivalentStates
    -> MeasureInMultipleBases
    -> EstimateDensityMatrix;

TomographyCost GROWS_WITH SystemDimension;

# ---------- SEMANTIC REASONING ----------
IF SystemHasTwoDimensionalQuantumStateSpaceUsedForInformation
THEN QubitClassification := supported;

IF |alpha|^2 + |beta|^2 != 1
THEN PureQubitStateRepresentation := unnormalised;

IF alphaAndBetaBothNonzero
THEN ComputationalBasisSuperposition := true;

IF TwoQubitPureStateCannotFactor
THEN Entanglement := true;

IF MeasurementPerformedInComputationalBasis
THEN OutcomeProbabilityDerivedFromSquaredBasisAmplitudes;

IF QubitInteractsUncontrollablyWithEnvironment
THEN Coherence MAY_DECREASE;

IF PhysicalErrorRateTooHigh
THEN ReliableLogicalQubitConstruction MAY_BE Impractical;

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE {
    "quantum bit" ~= "qubit";
    "qubit state" ~= "single-qubit quantum state";
    "computational basis" ~= "standard qubit basis";
    "Bloch sphere" ~= "single-qubit Bloch representation";
    "bit-flip error" ~= "Pauli-X error";
    "phase-flip error" ~= "Pauli-Z error";
    "physical qubit" ~= "hardware qubit";
    "logical qubit" ~= "error-corrected encoded qubit";
}

# ---------- QUERY FLOW ----------
QUERY(q) ->
    NORMALISE(q) ->
    IDENTIFY_QUBIT(q) ->
    IDENTIFY_STATE_REPRESENTATION(q) ->
    IDENTIFY_BASIS(q) ->
    IDENTIFY_AMPLITUDE_AND_PHASE(q) ->
    IDENTIFY_GATE_OR_MEASUREMENT(q) ->
    IDENTIFY_ENTANGLEMENT(q) ->
    IDENTIFY_PHYSICAL_NOISE_AND_CONTROL(q) ->
    MAP_TO_ONTOLOGY(q) ->
    APPLY_REASONING(q) ->
    SCORE_CONFIDENCE(q) ->
    RETURN_RELEVANT_KNOWLEDGE;

# ---------- CONFIDENCE ----------
CONFIDENCE(assertion) :=
    weighted_mean(
        source_reliability,
        quantum_state_consistency,
        mathematical_consistency,
        physical_evidence,
        experimental_evidence,
        contextual_relevance
    );

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

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION {
    primary_entity: QuantumBit;
    ontology: QuantumBitOntology;
    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_qubit_state:
        validate_normalisation
        -> identify_basis
        -> identify_amplitudes
        -> identify_phase
        -> derive_measurement_probabilities
        -> integrate;

    new_gate:
        validate_unitarity_where_applicable
        -> identify_target_qubit
        -> calculate_state_transformation
        -> update_relationships
        -> integrate;

    new_physical_evidence:
        identify_platform
        -> record_coherence
        -> record_gate_fidelity
        -> record_readout_fidelity
        -> integrate;

    ontology_revision:
        update_state_relationships
        -> update_noise_model
        -> update_physical_constraints
        -> recompute_confidence
        -> regenerate_flow_hash;

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

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
    DOMAIN
    + SUBDOMAIN
    + ONTOLOGY
    + QubitEntity
    + BasisType
    + QubitProperty
    + PhysicalQubitPlatform
    + QuantumGate
    + Measurement
    + QuantumErrorCorrection
    + RELATIONSHIPS
    + SEMANTIC_REASONING
    + SEMANTIC_EQUIVALENCE
    + UPDATE_MODEL;

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT);

# ---------- TERMINAL ----------
QuantumBitOntology
    -> IdentifyQubit
    -> DefineQuantumState
    -> NormaliseAmplitudes
    -> RepresentPhaseAndBasis
    -> ApplyQuantumGate
    -> ComposeWithOtherQubits
    -> DetermineEntanglementRelationships
    -> ModelNoiseAndCoherence
    -> PerformMeasurement
    -> ProduceClassicalOutcomeDistribution
    -> EvaluatePhysicalImplementation
    -> SupportLogicalEncodingWhereRequired
    -> MaintainConsistentQubitKnowledge;

END FLOW