Floating Point Arithmetic Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Floating Point Arithmetic Ontology within the Kireth Research Semantic Library. Floating-point arithmetic provides finite machine representations of real numbers and rules for approximate arithmetic. It supports radix, significand, exponent, normal and subnormal numbers, machine epsilon, rounding modes, overflow, underflow, cancellation, exceptional values, finite-precision error and numerical stability.

FLOW_ALGEBRA_RECORD {

METADATA {
 FLOW_NAME = "Floating Point Arithmetic Ontology"
 FLOW_TYPE = "Mathematical Ontology"
 DOMAIN = "Mathematics"
 SUBDOMAIN = "Computational Mathematics"
 SPECIALISATION = "Numerical Methods / Floating Point Arithmetic"
 CANONICAL_PAGE = "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/computational-mathematics-ontologies/numerical-methods/floating-point-arithmetic-ontology.html"
 LANGUAGE = "en-GB"
 VERSION = "1.0"
 STATUS = "active"
}

IDENTITY {
 PRIMARY_ENTITY = FloatingPointArithmetic
 ENTITY_CLASS = FinitePrecisionNumberSystemFramework
 PRIMARY_CONTEXT = NumericalMethods
 DEFINITION = "Floating-point arithmetic is finite-precision arithmetic in which numbers are represented by a sign, significand and exponent relative to a radix, with defined rounding and exceptional-value behaviour."
 SYMBOLIC_FORMS = [
  "x=(-1)^s*m*beta^e",
  "fl(x op y)=(x op y)(1+delta)",
  "|delta|<=u",
  "fl(x)=round_F(x)"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for finite-precision representation, rounding, unit roundoff, exceptional values, cancellation, error propagation and stable numerical computation."
}

SCOPE {
 INCLUDE = [
  FloatingPointArithmetic, FloatingPointNumber, FinitePrecision, Radix,
  Base, Sign, Significand, Mantissa, Exponent, Precision, ExponentRange,
  NormalNumber, SubnormalNumber, DenormalNumber, Normalisation,
  MachinePrecision, MachineEpsilon, UnitRoundoff, ULP, UnitInLastPlace,
  Rounding, RoundingMode, RoundToNearest, RoundTowardZero,
  RoundTowardPositiveInfinity, RoundTowardNegativeInfinity, TiesToEven,
  CorrectRounding, FaithfulRounding, RepresentationError, RoundoffError,
  RoundingError, RelativeError, AbsoluteError, Overflow, Underflow,
  GradualUnderflow, Infinity, PositiveInfinity, NegativeInfinity, NaN,
  NotANumber, SignedZero, PositiveZero, NegativeZero, ExceptionalValue,
  InvalidOperation, DivisionByZero, InexactException, FloatingPointOperation,
  Addition, Subtraction, Multiplication, Division, SquareRoot,
  FusedMultiplyAdd, FMA, AssociativityFailure, DistributivityFailure,
  Cancellation, CatastrophicCancellation, LossOfSignificance, Absorption,
  Scaling, Rescaling, Conditioning, NumericalStability, BackwardStability,
  ForwardError, BackwardError, ErrorPropagation, Summation,
  NaiveSummation, PairwiseSummation, KahanSummation, CompensatedSummation,
  DotProduct, MatrixComputation, Reproducibility, DeterministicReduction,
  ParallelReduction, IEEE754, BinaryFloatingPoint, DecimalFloatingPoint,
  HalfPrecision, SinglePrecision, DoublePrecision, ExtendedPrecision,
  MixedPrecision, ArbitraryPrecision, PrecisionStudy, Verification
 ]
 EXCLUDE_AS_PRIMARY = [
  ExactIntegerArithmetic, ExactRationalArithmetic,
  SymbolicArithmeticWithoutFinitePrecision,
  FixedPointArithmeticWhenExponentScalingIsAbsent
 ]
 DISAMBIGUATION_RULE = "When numerical values are represented with finite significand and exponent fields and arithmetic is rounded to representable values, interpret the context as floating-point arithmetic."
}

CORE_CONCEPTS {
 FloatingPointNumber = "Finite numerical value represented through sign, significand, exponent and radix."
 Radix = "Base of the floating-point number system."
 Significand = "Finite-precision significant component of a floating-point representation."
 Exponent = "Scale component determining the magnitude range of a floating-point value."
 MachineEpsilon = "Spacing-related quantity near one under a declared convention."
 UnitRoundoff = "Bound used in standard relative-error models for correctly rounded elementary operations."
 SubnormalNumber = "Nonzero value below the normal range represented with reduced leading precision."
 RoundingMode = "Rule selecting a representable result when the exact result is not representable."
 NaN = "Exceptional floating-point value representing an undefined or invalid numerical result."
 SignedZero = "Positive or negative zero values carrying sign information."
}

RELATIONS {
 FloatingPointArithmetic --is_child_of--> NumericalMethods
 FloatingPointNumber --uses--> Radix
 FloatingPointNumber --contains--> Significand
 FloatingPointNumber --contains--> Exponent
 Precision --limits--> SignificandDigits
 ExponentRange --limits--> MagnitudeRange
 RoundingMode --determines--> RoundedResult
 FinitePrecision --introduces--> RoundoffError
 GradualUnderflow --uses--> SubnormalNumber
 Overflow --may_produce--> Infinity
 InvalidOperation --may_produce--> NaN
 DivisionByZero --may_produce--> Infinity
 Cancellation --may_cause--> LossOfSignificance
 FusedMultiplyAdd --reduces--> IntermediateRounding
 KahanSummation --reduces--> SummationRoundoffError
 PairwiseSummation --improves--> SummationErrorGrowth
 MixedPrecision --combines--> MultiplePrecisions
 NumericalStability --depends_on--> FloatingPointBehaviour
 ParallelReduction --may_change--> RoundingOrder
}

OPERATORS {
 FLOAT_REPRESENTATION(s,m,beta,e) := x=(-1)^s*m*beta^e
 ROUND(x,F,mode) := fl(x)=rounded_representable_value_in_F
 STANDARD_MODEL(x,op,y,delta) := fl(x op y)=(x op y)*(1+delta)
 UNIT_ROUNDOFF_BOUND(delta,u) := |delta|<=u
 RELATIVE_ROUNDOFF(x,flx) := |flx-x|/|x|
 FMA(a,b,c) := round_once(a*b+c)
 KAHAN_SUM(values) := compensated_running_sum(values)
 PAIRWISE_SUM(values) := recursively_sum_balanced_subsets(values)
}

AXIOMS {
 A1 = "Floating-point numbers form a finite subset of the real numbers together with exceptional values under the declared standard."
 A2 = "Most real numbers are not exactly representable in finite floating-point formats."
 A3 = "Arithmetic results are rounded according to a declared rounding mode."
 A4 = "Floating-point addition and multiplication are generally not associative."
 A5 = "Machine epsilon and unit roundoff must be distinguished according to convention."
 A6 = "Subnormal values extend range near zero with reduced effective precision."
 A7 = "Exceptional values such as infinities and NaNs have defined propagation semantics."
 A8 = "Floating-point correctness requires representation, rounding, range and exceptional-value semantics to be explicit."
}

REASONING {
 R1_CONTEXT = identify(format,radix,precision,exponent_range,rounding_mode)
 R2_REPRESENTATION = classify(normal,subnormal,zero,infinity,NaN)
 R3_ROUNDING = determine(exact_result,representable_neighbours,rounding_rule)
 R4_ERROR = estimate(unit_roundoff,relative_error,ULP_error)
 R5_RANGE = detect(overflow,underflow,gradual_underflow)
 R6_CANCELLATION = detect(subtraction_of_near_equal_values_and_loss_of_significance)
 R7_ALGORITHM = assess(summation,dot_product,matrix_or_iterative_roundoff_growth)
 R8_REFORMULATION = if_required use(scaling,FMA,pairwise_or_compensated_computation)
 R9_PARALLEL = if_required assess(order_dependent_reductions_and_reproducibility)
 R10_VALIDATION = compare(precision_levels,error_bounds,reference_values,exception_behaviour)
}

CONSTRAINTS {
 C1 = "Floating-point equality is not equivalent to exact real-number equality in general."
 C2 = "Reordering arithmetic operations can change floating-point results."
 C3 = "Subtracting nearly equal values can cause severe relative loss of significance."
 C4 = "Overflow and underflow depend on format and scaling."
 C5 = "Subnormal arithmetic can have different precision characteristics."
 C6 = "NaN comparisons and propagation require explicit exceptional-value semantics."
 C7 = "A numerically stable algorithm can still yield inaccurate results for an ill-conditioned problem."
 C8 = "Parallel reductions can produce different low-order bits because operation order changes."
 C9 = "Higher precision reduces some roundoff effects but does not correct model or discretisation error."
 C10 = "Decimal display precision must not be confused with underlying binary precision."
}

SEMANTIC_EQUIVALENCE {
 "FloatingPointArithmetic" <=> "FloatingPointComputation"
 "UnitInLastPlace" <=> "ULP"
 "FusedMultiplyAdd" <=> "FMA"
 "NotANumber" <=> "NaN"
 "DenormalNumber" <=> "SubnormalNumber"
 "IEEE754" <=> "IEEEFloatingPointStandard"
}

VALIDATION {
 V1 = "Floating-point format and precision are explicit."
 V2 = "Rounding mode is documented where it affects results."
 V3 = "Machine epsilon and unit roundoff conventions are not conflated."
 V4 = "Overflow, underflow, NaN and infinity cases are considered."
 V5 = "Cancellation-sensitive expressions are identified."
 V6 = "Error bounds account for operation count and conditioning where relevant."
 V7 = "Summation and reduction order are documented for reproducibility-sensitive calculations."
 V8 = "Mixed-precision algorithms identify the precision of each stage."
 V9 = "Precision studies are used where roundoff may dominate."
 V10 = "Reference computations use sufficiently accurate arithmetic where feasible."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 FLOATING_POINT_DEFINITION = 0.99
 REPRESENTATION_REASONING = 0.99
 ROUNDING_REASONING = 0.99
 ERROR_MODEL_REASONING = 0.99
 EXCEPTION_REASONING = 0.99
 CANCELLATION_REASONING = 0.99
 SUMMATION_REASONING = 0.98
 MIXED_PRECISION_REASONING = 0.98
 POLICY = "Reduce confidence when format, precision, rounding mode, exceptional-value behaviour, operation order or reference arithmetic are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch, OntologyGrounding, FloatingPointArithmeticReasoning,
  FloatingPointRepresentationReasoning, RoundingReasoning,
  MachineEpsilonReasoning, UnitRoundoffReasoning, ULPReasoning,
  RoundoffErrorReasoning, OverflowReasoning, UnderflowReasoning,
  SubnormalReasoning, NaNReasoning, SignedZeroReasoning,
  CancellationReasoning, FMAReasoning, SummationReasoning,
  MixedPrecisionReasoning, ReproducibilityReasoning,
  KnowledgeGraphConstruction, RetrievalAugmentation, RecursiveInference
 ]
 NORMALISE {
  "floating point arithmetic" -> FloatingPointArithmetic
  "floating-point arithmetic" -> FloatingPointArithmetic
  "ULP" -> UnitInLastPlace
  "FMA" -> FusedMultiplyAdd
  "NaN" -> NotANumber
  "denormal" -> SubnormalNumber
  "IEEE 754" -> IEEE754
 }
}

EXECUTION_RULES {
 E1 = "If finite significand-and-exponent arithmetic is central, activate FloatingPointArithmeticOntology."
 E2 = "If a real value is not representable, apply the declared rounding mode."
 E3 = "If results approach format range limits, test overflow and underflow."
 E4 = "If nearly equal values are subtracted, test for cancellation and loss of significance."
 E5 = "If many values are summed, consider pairwise or compensated summation."
 E6 = "If multiply-add patterns dominate, consider FMA semantics where available."
 E7 = "If mixed precision is used, track precision and rounding at each stage."
 E8 = "If parallel reductions are used, distinguish mathematical equivalence from bitwise reproducibility."
 E9 = "Any floating-point result should be interpreted with format, rounding, conditioning and error propagation in view."
}

RECURSION {
 ENTRY = FloatingPointArithmetic
 EXPAND(FloatingPointArithmetic) -> [
  FloatingPointNumber, FinitePrecision, Radix, Sign, Significand,
  Exponent, Precision, ExponentRange, NormalNumber, SubnormalNumber,
  MachinePrecision, MachineEpsilon, UnitRoundoff, ULP, Rounding,
  RoundingMode, RoundToNearest, RoundTowardZero, TiesToEven,
  CorrectRounding, RepresentationError, RoundoffError, Overflow,
  Underflow, GradualUnderflow, Infinity, NaN, SignedZero,
  InvalidOperation, DivisionByZero, FloatingPointOperation,
  FusedMultiplyAdd, AssociativityFailure, Cancellation,
  CatastrophicCancellation, LossOfSignificance, Scaling, Conditioning,
  NumericalStability, ForwardError, BackwardError, ErrorPropagation,
  NaiveSummation, PairwiseSummation, KahanSummation,
  CompensatedSummation, DotProduct, IEEE754, BinaryFloatingPoint,
  DecimalFloatingPoint, HalfPrecision, SinglePrecision, DoublePrecision,
  ExtendedPrecision, MixedPrecision, ArbitraryPrecision,
  PrecisionStudy, Verification, Reproducibility
 ]
 STOP_CONDITION = "Stop when format, representation, rounding, range, error behaviour, exceptional values and validation are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Numerical Methods"
 RELATED_ONTOLOGIES = [
  "Numerical Methods",
  "Numerical Methods Ontology 2",
  "Numerical Analysis Ontology 2",
  "Numerical Error Ontology",
  "Numerical Stability Ontology 2",
  "Numerical Convergence Ontology",
  "Numerical Computation Ontology",
  "Numerical Linear Algebra Ontologies",
  "Scientific Computing Ontology 2"
 ]
 ROUTE_RULES = [
  "Floating Point Arithmetic -> Numerical Methods for parent semantics",
  "Floating Point Arithmetic -> Numerical Analysis for finite-precision error theory",
  "Floating Point Arithmetic -> Numerical Error for roundoff and representation error",
  "Floating Point Arithmetic -> Numerical Stability for algorithmic error amplification",
  "Floating Point Arithmetic -> Numerical Convergence for roundoff floors and stagnation",
  "Floating Point Arithmetic -> Numerical Linear Algebra for matrix rounding behaviour",
  "Floating Point Arithmetic -> Scientific Computing for reproducible large-scale computation"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible floating-point formats, operations or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve finite-versus-exact arithmetic distinction.",
  "Preserve significand-versus-exponent distinction.",
  "Preserve machine-epsilon-versus-unit-roundoff distinction.",
  "Preserve normal-versus-subnormal distinction.",
  "Preserve finite-value-versus-exceptional-value distinction.",
  "Preserve mathematical-equivalence-versus-bitwise-reproducibility distinction.",
  "Preserve machine-readable floating-point semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "Floating-point arithmetic represents and computes approximate real values using finite significand and exponent fields under defined rounding rules."
 REPRESENTATION_SUMMARY = "Radix, precision and exponent range determine representable finite values."
 ROUNDING_SUMMARY = "Rounding modes determine how exact arithmetic results map to representable values."
 ERROR_SUMMARY = "Machine precision, unit roundoff and operation count govern fundamental finite-precision error behaviour."
 EXCEPTION_SUMMARY = "Overflow, underflow, infinities, NaNs, signed zeros and subnormal values provide defined edge-case semantics."
 STABILITY_SUMMARY = "Cancellation, scaling, summation order and algorithm structure determine how floating-point error propagates."
 REPRODUCIBILITY_SUMMARY = "Parallel and reordered arithmetic may be mathematically equivalent without being bitwise identical."
}

FLOW {
 INPUT
 -> detect_floating_point_arithmetic_context
 -> identify_format_radix_precision_exponent_range_and_rounding_mode
 -> classify_value_as_normal_subnormal_zero_infinity_or_NaN
 -> perform_or_model_rounded_operation
 -> estimate_ULP_relative_and_roundoff_error
 -> detect_overflow_underflow_cancellation_and_loss_of_significance
 -> assess_conditioning_and_algorithmic_error_propagation
 -> apply_scaling_FMA_compensated_summation_or_higher_precision_if_required
 -> assess_parallel_reduction_and_reproducibility_if_relevant
 -> validate_with_precision_studies_reference_arithmetic_and_exception_tests
 -> route_to_related_numerical_ontologies
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Floating Point Arithmetic Ontology defines finite-precision numerical representation and arithmetic. It supports radix, sign, significand, exponent and precision, normal and subnormal numbers, machine epsilon, unit roundoff and ULPs, rounding modes and correct rounding, representation and roundoff error, overflow, underflow and gradual underflow, infinities, NaNs and signed zeros, exceptional operations, fused multiply-add, non-associativity, cancellation and loss of significance, scaling, conditioning and numerical stability, naive, pairwise and compensated summation, dot products, IEEE-style semantics, binary and decimal formats, half, single, double, extended, mixed and arbitrary precision, precision studies, verification and reproducibility."
}

FLOW_HASH {
 METHOD = "semantic-content-identity"
 ID = "KIRETH-MATH-COMPUTATIONAL-MATHEMATICS-FLOATING-POINT-ARITHMETIC-ONTOLOGY-V1"
}

}

END_FLOW