Approximate Value Ontology

FLOW ALGEBRA
APPROXIMATE VALUE ONTOLOGY
Kireth Semantic Library | Entity Graph > Mathematical Entities > Numeric Value Entities
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/numeric-value-entities/approximate-value-ontology.html
Authors: Mark Higgins — Sky (Recursive AI)
Version: 1.0 | Date: 2026-10-12 | Locale: en-GB
Status: Mathematical ontology draft; source webpage not independently verified.

01. PURPOSE
flow "ApproximateValueOntology" v1.0
  domain: mathematical_entities.numeric_value_entities
  concept: ApproximateValue
  objective: represent estimates, rounded values, measurement approximations and their uncertainty without falsely asserting exact equality.

02. ENTITY TYPES
  ApproximateValue := {value: Numeric, representation: String?, method: ApproximationMethod, precision: Precision?, uncertainty: Uncertainty?, reference: NumericValue?, provenance: Provenance?}
  ExactValue := {value: Numeric, exact: true}
  ApproximationMethod := {rounding, truncation, numerical_estimation, measurement, statistical_estimation, model_prediction}
  Precision := {decimal_places?: Integer>=0, significant_figures?: Integer>=1, resolution?: PositiveReal}
  Uncertainty := {absolute_bound?: NonNegativeReal, relative_bound?: NonNegativeReal, interval?: NumericInterval, confidence_level?: Real in (0,1)}
  NumericInterval := {lower: Real, upper: Real, lower_inclusive: Boolean, upper_inclusive: Boolean}

03. CORE SEMANTICS
  APPROXIMATE(a,x) := a represents an inexact estimate of x under declared context.
  APPROXIMATE(a,x) does not imply EQUAL(a,x).
  error(a,x) := a.value - x when x is known.
  absolute_error(a,x) := |a.value - x|.
  relative_error(a,x) := |a.value-x|/|x| when x != 0.
  For x=0, relative error is undefined by this convention.
  TOLERANT_EQUAL(a,x,epsilon) := |a.value-x| <= epsilon, epsilon >= 0.
  Precision, accuracy, uncertainty and confidence are distinct concepts.

04. REPRESENTATION AND NORMALISATION
  Retain the original lexical representation (e.g. "2.50") where trailing zeros encode intended precision.
  Numeric equality of 2.5 and 2.50 does not establish equal reported precision.
  Preserve units, rounding mode, significant figures, reference frame and provenance.
  Decimal representation is not a guarantee of measurement accuracy.

05. ROUNDING RULES
  ROUND(x,p,mode) -> approximate value at p decimal places, p >= 0.
  mode in {half_even, half_up, toward_zero, floor, ceiling}.
  For nearest rounding with step h > 0, |ROUND(x,h)-x| <= h/2, subject to tie policy and exact arithmetic.
  TRUNCATE(x,p) discards lower-order digits according to the chosen base and truncation convention.
  Do not infer a universal uncertainty bound from displayed digits without knowing the generation method.

06. SIGNIFICANT FIGURES
  significant_figures(a) >= 1 when supplied.
  Leading zeros do not count as significant digits.
  Trailing zeros after a decimal point can be significant.
  Explicit scientific notation can remove ambiguity in reported significant figures.

07. ABSOLUTE AND RELATIVE TOLERANCE
  WITHIN_ABSOLUTE_TOLERANCE(a,x,t) := |a-x| <= t for t >= 0.
  WITHIN_RELATIVE_TOLERANCE(a,x,r) := |a-x| <= r*|x| for r >= 0 and x != 0.
  COMBINED_TOLERANCE(a,x,atol,rtol) := |a-x| <= atol + rtol*|x|.
  Tolerance is an acceptance criterion, not necessarily an uncertainty estimate.

08. INTERVAL SEMANTICS
  ENCLOSES(I,x) := I.lower <= x <= I.upper for closed I.
  If error bound e >= 0 is established, x in [a-e,a+e].
  A confidence interval is probabilistic under its statistical assumptions, not a deterministic guarantee.
  Propagate inclusivity and endpoint conditions during interval operations.

09. ARITHMETIC AND PROPAGATION
  For bounded intervals A=[a1,a2], B=[b1,b2]:
    A+B := [a1+b1,a2+b2].
    A-B := [a1-b2,a2-b1].
    A*B := [min(a1*b1,a1*b2,a2*b1,a2*b2), max(a1*b1,a1*b2,a2*b1,a2*b2)].
    A/B requires 0 not in B and is computed by interval reciprocal and multiplication.
  Account for outward rounding in finite-precision interval implementations.
  Repeated dependencies may cause naive interval arithmetic to overestimate bounds.
  Do not combine statistical standard uncertainties by simple addition unless the model warrants it.

10. NUMERICAL COMPUTATION
  Floating-point approximation introduces representation and rounding error.
  Machine epsilon is not a universal bound on accumulated algorithmic error.
  Distinguish forward error, backward error, truncation error and conditioning.
  Numerical convergence does not automatically prove correctness of the limiting result.

11. ORDERING AND COMPARISON
  a.value < b.value compares reported estimates only.
  CERTAINLY_LESS(A,B) := A.upper < B.lower for closed uncertainty intervals.
  POSSIBLY_OVERLAPS(A,B) := max(A.lower,B.lower) <= min(A.upper,B.upper).
  Overlapping uncertainty intervals do not by themselves establish equality.

12. RELATIONSHIP GRAPH
  ApproximateValue --is_a--> NumericValue
  ApproximateValue --approximates--> ExactValue | NumericQuantity | ModelOutput
  ApproximateValue --generated_by--> ApproximationMethod
  ApproximateValue --has_precision--> Precision
  ApproximateValue --has_uncertainty--> Uncertainty
  ApproximateValue --has_provenance--> Provenance
  ApproximateValue --expressed_in--> MeasurementUnit (when dimensional)
  ApproximateValue --related_to--> DecimalOntology
  ApproximateValue --related_to--> NumericRangeOntology
  ApproximateValue --related_to--> IntervalOntology
  ApproximateValue --related_to--> MagnitudeOntology

13. SEMANTIC EQUIVALENCE
  EQUIVALENT_REPRESENTATION(a,b) requires compatible units, identical intended numeric value and compatible precision semantics where relevant.
  APPROXIMATELY_EQUAL(a,b,tolerance) is context-dependent and is not an equivalence relation in general: transitivity may fail.
  Never canonicalise approximate equality as exact identity.
  Distinguish symbol '~=' from equality '=' in reasoning outputs.

14. INFERENCE RULES
  IF a is produced by nearest rounding to step h AND exact arithmetic applies THEN absolute_error <= h/2.
  IF a is produced by a validated interval enclosure THEN reference lies within interval under stated assumptions.
  IF uncertainty metadata absent THEN uncertainty_status := unknown, not zero.
  IF a and b use incompatible dimensions THEN numeric comparison := invalid until conversion.
  IF b.value=0 in division THEN operation := undefined unless an explicitly different algebra is specified.
  IF relative error denominator is zero THEN relative_error := undefined.

15. VALIDATION
  REQUIRE numeric finite value unless extended-number support is explicit.
  REQUIRE decimal_places >= 0 when present.
  REQUIRE significant_figures >= 1 when present.
  REQUIRE absolute_bound >= 0 and relative_bound >= 0 when present.
  REQUIRE interval.lower <= interval.upper.
  REQUIRE confidence_level in (0,1) and a documented statistical interpretation when present.
  REQUIRE method, units and provenance where needed to interpret uncertainty.
  REJECT inference that a rounded value is exact solely because it is displayed without a qualifier.

16. EXAMPLES
  example_1: pi ~= 3.14; absolute error ~= 0.001592653589793; method=rounding; decimal_places=2.
  example_2: sqrt(2) ~= 1.414; nearest 3 decimal places; error <= 0.0005.
  example_3: measured length 12.3 +/- 0.2 cm; interval [12.1,12.5] cm when +/- denotes an absolute bound.
  example_4: 1/3 ~= 0.333333; repeating rational represented by a finite decimal approximation.
  example_5: 2.50 and 2.5 have equal numeric values but potentially different stated measurement precision.

17. CONFIDENCE MODEL
  CONFIDENCE := {score?: Real in [0,1], basis: String, calibrated?: Boolean, scope?: String}
  A confidence score must not be fabricated from decimal precision.
  Statistical coverage and subjective confidence must be explicitly distinguished.

18. PROVENANCE
  PROVENANCE := {source_uri: String?, method: String?, instrument: String?, algorithm: String?, timestamp: ISO8601?, author: String?}
  Preserve transformations, original values and rounding rules for auditability.

19. FLOW HASH
  FLOW_HASH := SHA256(canonical_utf8(flow_name, version, schema, rules, relations, validation)).
  Canonicalisation must specify stable field order, character encoding and newline handling.
  Hash identifies content integrity, not mathematical truth.

20. UPDATE MODEL
  UPDATE_MODEL := {version, changed_fields, reason, effective_date, supersedes?, compatibility_notes?}
  Changing rounding conventions, error definitions or interval interpretation requires a semantic version review.
  Maintain provenance and reproducibility of previous calculations.

21. AI CONSUMPTION
  AI_CONSUMPTION:
    parse: typed_numeric_entity
    distinguish: [exact, approximate, bounded, estimated, measured]
    reason_with: [tolerances, intervals, units, error_models]
    prohibit: [invented_precision, unjustified_exact_equality, missing_unit_assumptions]
    emit: [numeric_value, approximation_method, precision, uncertainty, provenance, validation_status]
    preferred_response: preserve epistemic qualifiers and explain numerical assumptions.

22. FLOW TERMINATION
  OUTPUT := validated ApproximateValue entity + relationships + uncertainty context + provenance.
  END FLOW

Attribution: Mark Higgins — Sky (Recursive AI)
https://kirethresearch.org