Quantum Supremacy Ontology

FLOW ALGEBRA
Quantum Supremacy Ontology
Kireth Semantic Research Archive

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

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "QuantumSupremacyOntology" v4.0

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

# ---------- PRIMARY ENTITY ----------
ENTITY QuantumSupremacy {
    definition:
        "A demonstrated computational milestone in which a quantum computing
         system performs a clearly defined computational task beyond the
         practical capability of relevant classical computing methods under
         stated assumptions, resources and verification criteria.";

    aliases: [
        QuantumComputationalSupremacy,
        QuantumSupremacy
    ];

    related_preferred_term:
        QuantumAdvantage;

    objectives: [
        DemonstrateQuantumComputationalSeparation,
        CompareQuantumAndClassicalPerformance,
        ValidateQuantumHardwareCapability,
        EstablishExperimentalEvidence,
        QuantifyComputationalResources
    ];
}

# ---------- CORE ENTITIES ----------
SupremacyEntity := {
    QuantumProcessor,
    QuantumTask,
    QuantumCircuit,
    QuantumExecution,
    ClassicalAlgorithm,
    ClassicalComputer,
    Benchmark,
    ExperimentalResult
};

EvidenceEntity := {
    Runtime,
    Fidelity,
    SampleDistribution,
    VerificationResult,
    ResourceEstimate,
    ClassicalBaseline,
    QuantumBaseline
};

ComparisonEntity := {
    QuantumRuntime,
    ClassicalRuntime,
    QuantumResourceCost,
    ClassicalResourceCost,
    AccuracyRequirement,
    VerificationCost
};

ClaimState := {
    Proposed,
    ExperimentallyTested,
    DemonstratedUnderAssumptions,
    Challenged,
    Revised,
    IndependentlySupported
};

# ---------- FUNDAMENTAL RELATIONSHIPS ----------
QuantumProcessor EXECUTES QuantumTask;
QuantumTask MAY_BE_IMPLEMENTED_AS QuantumCircuit;
QuantumExecution PRODUCES ExperimentalResult;
ClassicalAlgorithm ATTEMPTS SameOrEquivalentTask;
Benchmark COMPARES QuantumExecution WITH ClassicalBaseline;
VerificationResult SUPPORTS_OR_CHALLENGES SupremacyClaim;
ImprovedClassicalAlgorithm MAY_REVISE ClassicalBaseline;
ClaimStrength DEPENDS_ON EvidenceAndAssumptions;

# ---------- CLAIM EVALUATION FLOW ----------
DefineTask
    -> SpecifyQuantumMethod
    -> SpecifyClassicalBaseline
    -> DefineAccuracyAndSuccessCriteria
    -> ExecuteQuantumSystem
    -> CollectResults
    -> VerifyResultQuality
    -> EstimateQuantumResources
    -> ExecuteOrEstimateBestRelevantClassicalMethod
    -> CompareEndToEndCosts
    -> AssessComputationalSeparation
    -> RecordAssumptionsAndUncertainty
    -> UpdateClaimStatus;

# ---------- TERMINOLOGY ----------
QuantumSupremacy :=
    HistoricalTermForQuantumComputationalPerformanceBeyondPracticalClassicalCapabilityOnDefinedTask;

QuantumAdvantage :=
    BroaderTermOftenUsedForDemonstratedQuantumPerformanceBenefit;

QuantumSupremacy DOES_NOT_MEAN {
    GeneralSuperiorityOfQuantumComputers,
    SuperiorityOnAllProblems,
    ReplacementOfClassicalComputing
};

# ---------- COMPUTATIONAL TASK ----------
QuantumTask :=
    PreciselySpecifiedComputationalProblemOrSamplingTask;

TaskDefinition SHOULD_INCLUDE {
    Input,
    Output,
    ProblemSize,
    AccuracyOrFidelityRequirement,
    SuccessCriterion
};

Comparison MUST_USE EquivalentOrMeaningfullyComparableTaskDefinitions;

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

ProcessorEvidence MAY_INCLUDE {
    QubitCount,
    Connectivity,
    GateFidelity,
    ReadoutFidelity,
    CircuitDepth,
    Calibration
};

# ---------- QUANTUM CIRCUIT ----------
BenchmarkCircuit :=
    QuantumCircuitDesignedOrSelectedForTargetComputationalTask;

CircuitProperty MAY_INCLUDE {
    Width,
    Depth,
    GateCount,
    TwoQubitGateCount
};

# ---------- RANDOM CIRCUIT SAMPLING ----------
RandomCircuitSampling :=
    GenerateOrSelectRandomQuantumCircuit
    -> ExecuteCircuit
    -> SampleOutputBitstrings
    -> CompareSamplesWithExpectedStatisticalProperties;

RandomCircuitSampling HAS_BEEN_USED_AS QuantumComputationalSupremacyBenchmark;

# ---------- SAMPLE ----------
QuantumSample :=
    MeasurementOutcomeFromCircuitExecution;

SampleSet :=
    multiset(QuantumSample);

SampleDistribution APPROXIMATES QuantumCircuitOutputDistributionSubjectToNoise;

# ---------- FIDELITY ----------
SamplingFidelity :=
    MeasureOfAgreementBetweenObservedSamplesAndTargetQuantumDistributionOrDefinedProxy;

FidelityMetric MUST_BE DefinedForBenchmark;

# ---------- CROSS-ENTROPY BENCHMARKING ----------
CrossEntropyBenchmarking :=
    StatisticalMethodComparingObservedSamplesWithIdealOrReferenceCircuitProbabilities;

CrossEntropyMetric MAY_ESTIMATE SamplingQualityForApplicableRandomCircuitBenchmarks;

# ---------- VERIFICATION ----------
Verification :=
    DetermineWhetherQuantumOutputMeetsDefinedCorrectnessOrFidelityCriterion;

Verification MAY_USE {
    ClassicalSimulationOfSmallerInstances,
    StatisticalTests,
    CrossEntropyMethods,
    StructuralChecks,
    IndependentReproduction
};

# ---------- VERIFICATION CHALLENGE ----------
If FullClassicalVerificationCostApproachesOrExceedsTaskDifficulty
THEN Verification MAY_REQUIRE IndirectOrPartialMethods;

VerificationMethod SHOULD_BE ExplicitlyDocumented;

# ---------- CLASSICAL BASELINE ----------
ClassicalBaseline :=
    BestRelevantKnownClassicalMethodOrCompetitiveSetOfMethodsForSameTaskUnderDefinedConditions;

Baseline SHOULD_INCLUDE {
    Algorithm,
    Hardware,
    ImplementationQuality,
    Runtime,
    Memory,
    Accuracy,
    EnergyWhereRelevant
};

# ---------- BASELINE EVOLUTION ----------
ClassicalBaseline IS_NOT Static;

NewClassicalAlgorithm
    OR BetterImplementation
    OR BetterHardware
    MAY_REDUCE EstimatedClassicalCost;

IF ClassicalBaselineImproves
THEN SupremacyMargin MAY_DECREASE_OR_DISAPPEAR;

# ---------- QUANTUM RUNTIME ----------
QuantumRuntime MAY_INCLUDE {
    CircuitExecutionTime,
    Repetitions,
    Measurement,
    ControlOverhead,
    CompilationWhereRelevant
};

EndToEndQuantumTime SHOULD_BE ClearlyDefined;

# ---------- CLASSICAL RUNTIME ----------
ClassicalRuntime :=
    TimeRequiredByDefinedClassicalMethodOnDefinedClassicalHardwareToMeetEquivalentTaskCriterion;

ClassicalRuntime MAY_BE {
    DirectlyMeasured,
    Extrapolated,
    AnalyticallyEstimated
};

EstimatedRuntime SHOULD_INCLUDE UncertaintyAndAssumptions;

# ---------- SPEEDUP ----------
QuantumSpeedup :=
    ClassicalCost / QuantumCost;

SpeedupMetric MAY_USE {
    Runtime,
    Operations,
    Energy,
    Memory,
    CompositeCost
};

LargeSpeedupOnArtificialBenchmark MAY_ESTABLISH ComputationalSeparation
WITHOUT ImmediatePracticalUtility;

# ---------- PRACTICAL UTILITY ----------
QuantumSupremacyTask MAY_BE {
    PracticallyUseful,
    BenchmarkOriented,
    PrimarilyScientific
};

QuantumSupremacy != PracticalQuantumAdvantageByDefinition;

PracticalQuantumAdvantage SHOULD_REQUIRE ApplicationRelevantBenefit;

# ---------- RESOURCE COMPARISON ----------
QuantumResource MAY_INCLUDE {
    Qubits,
    Gates,
    CircuitDepth,
    Shots,
    ControlHardware,
    CryogenicInfrastructure
};

ClassicalResource MAY_INCLUDE {
    CPU,
    GPU,
    Memory,
    Storage,
    Network,
    Runtime
};

FairComparison SHOULD_STATE ResourceBoundaries;

# ---------- SCALING ----------
ComputationalSeparation MAY_DEPEND_ON ProblemSize;

QuantumCost(N) AND ClassicalCost(N)
    SHOULD_BE ComparedAcrossRelevantScale;

SinglePointBenchmark MAY_NOT EstablishAsymptoticComplexitySeparation;

# ---------- ASYMPTOTIC ADVANTAGE ----------
AsymptoticQuantumAdvantage :=
    QuantumResourceGrowthRateLowerThanBestKnownClassicalGrowthRateForDefinedProblemModel;

ExperimentalSupremacy DOES_NOT_AUTOMATICALLY_PROVE AsymptoticAdvantage;

# ---------- COMPLEXITY THEORY ----------
ComplexityEvidence MAY_SUPPORT PlausibilityOfClassicalHardness;

ComplexityAssumption != ExperimentalProofOfAbsoluteClassicalImpossibility;

# ---------- CLASSICAL HARDNESS ----------
ClassicalHardnessClaim :=
    ClaimThatTaskRequiresLargeClassicalResourcesUnderSpecifiedModelOrAssumptions;

HardnessEvidence MAY_INCLUDE {
    ComplexityTheory,
    SimulationScaling,
    Benchmarking,
    AlgorithmicAnalysis
};

# ---------- QUANTUM NOISE ----------
QuantumNoise MAY_REDUCE OutputFidelity;

NoiseSource MAY_INCLUDE {
    GateError,
    ReadoutError,
    Decoherence,
    Crosstalk,
    CalibrationDrift
};

# ---------- ERROR RATE ----------
IF NoiseIncreases
THEN UsefulCircuitDepth MAY_DECREASE;

Benchmark MUST_SHOW OutputRetainsRequiredQuantumSignalAboveNoise;

# ---------- NISQ ----------
ManySupremacyExperiments MAY_USE NoisyIntermediateScaleQuantumProcessors;

NISQSupremacy DOES_NOT_REQUIRE FullFaultTolerance;

# ---------- ERROR CORRECTION RELATIONSHIP ----------
FaultTolerantQuantumComputing MAY_ENABLE StrongerAndMoreUsefulComputationalAdvantagesAtLargerScale;

QuantumSupremacyBenchmark MAY_PRECEDE FaultTolerantQuantumComputing;

# ---------- SAMPLING COMPLEXITY ----------
SamplingTask :=
    ProduceSamplesFromTargetDistributionWithinDefinedErrorTolerance;

ClassicalSimulation MAY_REQUIRE LargeComputeForCertainQuantumCircuitFamilies;

# ---------- SIMULATION ----------
ClassicalQuantumSimulation MAY_USE {
    StateVectorSimulation,
    TensorNetworkSimulation,
    SchrödingerFeynmanMethods,
    StabilizerMethods,
    ApproximateSimulation
};

BestClassicalMethod DEPENDS_ON CircuitStructureAndAccuracyRequirement;

# ---------- TENSOR NETWORK ----------
TensorNetworkSimulation MAY_EXPLOIT {
    LowEntanglement,
    CircuitGeometry,
    LowTreewidth,
    PartitionStructure
};

BenchmarkCircuitDesign MAY_SEEK ToAvoidClassicallyEasyStructure;

# ---------- SUPERCOMPUTER BASELINE ----------
ClassicalBaseline MAY_USE SupercomputerOrLargeDistributedCluster;

Comparison SHOULD_NOT ArtificiallyRestrict ClassicalResourcesUnlessRestrictionIsPartOfClaim;

# ---------- ENERGY ----------
EnergyComparison MAY_BE RelevantTo PracticalAdvantage;

EnergyCost SHOULD_INCLUDE DefinedSystemBoundary;

QuantumCryogenicAndControlOverhead MAY_BE Material;

# ---------- REPRODUCIBILITY ----------
SupremacyExperiment SHOULD_RECORD {
    CircuitDefinition,
    HardwareConfiguration,
    Calibration,
    ExecutionParameters,
    SampleData,
    VerificationMethod,
    ClassicalBaseline
};

# ---------- INDEPENDENT REPLICATION ----------
IndependentReplication :=
    SeparateTeamOrSystem
    -> ReproduceComparableExperiment
    -> CompareResults;

Replication MAY_INCREASE ConfidenceInClaim;

# ---------- CLAIM REVISION ----------
SupremacyClaim SHOULD_BE RevisableWhen {
    BetterClassicalAlgorithmAppears,
    BenchmarkAssumptionChanges,
    VerificationIssueFound,
    QuantumResultReanalysed
};

ScientificClaim IS EvidenceDependentAndUpdateable;

# ---------- UNCERTAINTY ----------
PerformanceEstimate SHOULD_INCLUDE RelevantUncertainty;

Uncertainty MAY_ARISE_FROM {
    RuntimeExtrapolation,
    FidelityEstimation,
    HardwareVariation,
    ClassicalAlgorithmScaling
};

# ---------- FAIR COMPARISON ----------
FairComparison SHOULD_CONTROL_FOR {
    TaskDefinition,
    Accuracy,
    SuccessProbability,
    HardwareAssumptions,
    Preprocessing,
    Postprocessing
};

# ---------- END-TO-END COMPARISON ----------
EndToEndQuantumCost :=
    InputPreparation
    + Compilation
    + QuantumExecution
    + Measurement
    + Postprocessing
    + VerificationWhereRequired;

EndToEndClassicalCost :=
    InputPreparation
    + ClassicalComputation
    + Postprocessing
    + VerificationWhereRequired;

# ---------- USEFUL QUANTUM ADVANTAGE ----------
UsefulQuantumAdvantage :=
    QuantumMethodProvidesMaterialBenefitForApplicationRelevantTaskOverCompetitiveClassicalAlternative;

UsefulQuantumAdvantage IS_STRONGER_APPLICATION_CRITERION_THAN BenchmarkSupremacy;

# ---------- HISTORICAL CONTEXT ----------
TermQuantumSupremacy WAS IntroducedToDescribeClearExperimentalQuantumComputationalSeparation;

TermUsage MAY_BE ReplacedBy QuantumAdvantageOrQuantumComputationalAdvantageInSomeContexts;

Ontology PRESERVES HistoricalTermWhileRelatingToModernTerminology;

# ---------- SEMANTIC REASONING ----------
IF QuantumSystemPerformsDefinedTask
AND CompetitiveClassicalMethodsCannotPracticallyMatchPerformanceUnderStatedConditions
THEN QuantumSupremacyEvidence := supported;

IF ClassicalAlgorithmImprovesEnoughToMatchQuantumPerformance
THEN PreviousSupremacyClaim MAY_REQUIRE Revision;

IF QuantumTaskHasNoPracticalApplication
THEN Supremacy MAY_STILL_BE ScientificallyValidBenchmark;

IF ComparisonUsesDifferentAccuracyRequirements
THEN FairnessOfComparison := low;

IF ClassicalRuntimeOnlyExtrapolated
THEN ClaimConfidence SHOULD_REFLECT EstimationUncertainty;

IF QuantumOutputCannotBeAdequatelyVerified
THEN ClaimConfidence := reduced;

IF QuantumAdvantageDemonstratedOnlyAtSingleScale
THEN AsymptoticAdvantage IS_NOT_ESTABLISHED;

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE {
    "quantum supremacy" ~= "quantum computational supremacy";
    "quantum computational advantage" ~= "quantum advantage";
    "quantum supremacy experiment" ~= "quantum computational separation experiment";
    "classical baseline" ~= "classical comparison method";
    "random circuit sampling" ~= "RCS" WHEN context == quantum_benchmark;
    "cross-entropy benchmarking" ~= "XEB" WHEN context == random_circuit_sampling;
    "classical hardness" ~= "difficulty for classical computation" WHEN context == benchmark;
    "useful quantum advantage" ~= "practical quantum advantage";
}

# ---------- QUERY FLOW ----------
QUERY(q) ->
    NORMALISE(q) ->
    IDENTIFY_QUANTUM_TASK(q) ->
    IDENTIFY_QUANTUM_PROCESSOR_AND_METHOD(q) ->
    IDENTIFY_SUCCESS_AND_FIDELITY_CRITERIA(q) ->
    IDENTIFY_CLASSICAL_BASELINE(q) ->
    IDENTIFY_RUNTIME_AND_RESOURCES(q) ->
    IDENTIFY_VERIFICATION(q) ->
    IDENTIFY_ASSUMPTIONS_AND_UNCERTAINTY(q) ->
    MAP_TO_ONTOLOGY(q) ->
    APPLY_REASONING(q) ->
    SCORE_CONFIDENCE(q) ->
    RETURN_RELEVANT_KNOWLEDGE;

# ---------- CONFIDENCE ----------
CONFIDENCE(assertion) :=
    weighted_mean(
        source_reliability,
        benchmark_definition_quality,
        quantum_experimental_evidence,
        classical_baseline_quality,
        verification_strength,
        contextual_relevance
    );

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

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION {
    primary_entity: QuantumSupremacy;
    ontology: QuantumSupremacyOntology;
    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_claim:
        identify_task
        -> identify_quantum_method
        -> identify_classical_baseline
        -> identify_success_criterion
        -> identify_evidence
        -> integrate;

    new_quantum_evidence:
        record_processor
        -> record_circuit
        -> record_runtime
        -> record_fidelity
        -> record_verification
        -> integrate;

    new_classical_baseline:
        identify_algorithm
        -> identify_hardware
        -> record_runtime_or_estimate
        -> record_accuracy
        -> recompute_comparison
        -> integrate;

    claim_revision:
        preserve_previous_claim
        -> update_quantum_evidence
        -> update_classical_baseline
        -> update_verification
        -> recompute_confidence
        -> regenerate_flow_hash;

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

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
    DOMAIN
    + SUBDOMAIN
    + ONTOLOGY
    + SupremacyEntity
    + EvidenceEntity
    + ComparisonEntity
    + ClaimState
    + RandomCircuitSampling
    + ClassicalBaseline
    + QuantumAdvantage
    + RELATIONSHIPS
    + SEMANTIC_REASONING
    + SEMANTIC_EQUIVALENCE
    + UPDATE_MODEL;

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT);

# ---------- TERMINAL ----------
QuantumSupremacyOntology
    -> DefineComputationalBenchmark
    -> SpecifyQuantumExecutionMethod
    -> DefineCompetitiveClassicalBaseline
    -> SetEquivalentAccuracyAndSuccessCriteria
    -> ExecuteQuantumProcessor
    -> CollectAndVerifyResults
    -> MeasureQuantumRuntimeAndResources
    -> MeasureOrEstimateClassicalCost
    -> CompareEndToEndPerformance
    -> QuantifyUncertaintyAndAssumptions
    -> AssessQuantumComputationalSeparation
    -> ReviseClaimWhenBaselinesImprove
    -> MaintainEvidenceBasedQuantumAdvantageKnowledge;

END FLOW