Proportion Ontology

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

01. PURPOSE
flow "ProportionOntology" v1.0
  domain: mathematics.numeric_values
  entity: Proportion
  intent: represent, validate, compare, infer and calculate equality of ratios
  scope: exact rational proportions, positive scaling, signed values, direct and inverse proportionality

02. TYPE SYSTEM
type Scalar = RealNumber | RationalNumber | ExactDecimal
type NonzeroScalar = Scalar where value != 0
type Ratio = {antecedent: Scalar, consequent: NonzeroScalar}
type Proportion = {left: Ratio, right: Ratio, relation: "equal"}
type Quantity = {value: Scalar, unit: Unit}
type ProportionalRelation = {dependent: Variable, independent: Variable, constant: Scalar, mode: Direct | Inverse}
type Validation = {valid: Boolean, reasons: List[String], confidence: [0,1]}

03. CORE DEFINITION
  proportion(a,b,c,d) := (b != 0) AND (d != 0) AND (a/b = c/d)
  equivalently: a*d = b*c, provided b != 0 and d != 0
  examples: 2:3 = 4:6; 1/4 = 25/100
  non_example: 2:3 != 4:5
  note: a proportion is an equality of ratios, not merely a part-to-whole fraction

04. ENTITY IDENTIFIERS
  ID(Proportion) := canonical("proportion", normalize(a,b), normalize(c,d))
  canonical_ratio(a,b) := reduced fraction with positive denominator, when a,b are exact rational values and b != 0
  normalized_equality: swapping left and right does not change the truth value
  identity_of_expression != identity_of_representation

05. AXIOMS AND INVARIANTS
  reflexivity: ratio(a,b) = ratio(a,b)
  symmetry: proportion(a,b,c,d) -> proportion(c,d,a,b)
  transitivity: (r1=r2 AND r2=r3) -> r1=r3
  cross_product: (a/b=c/d) <-> (a*d=b*c), b*d != 0
  common_scale: (a/b) = (k*a)/(k*b), k != 0
  exact_arithmetic: avoid floating-point equality for exact claims
  zero_numerator: 0/b = 0/d for nonzero b,d
  forbidden: any ratio with denominator 0

06. DIRECT PROPORTIONALITY
  direct(y,x,k) := y = k*x
  invariant: x != 0 -> y/x = k
  origin: y(0)=0
  scaling: y(t*x)=t*y(x)
  if k != 0, x/y=1/k when y != 0
  examples: distance = speed*time at constant speed
  caveat: use consistent units and domain assumptions

07. INVERSE PROPORTIONALITY
  inverse(y,x,k) := x != 0 AND y = k/x
  invariant: x*y=k
  scaling: y(t*x)=y(x)/t for t != 0
  examples: time = fixed_work/rate for positive rate
  caveat: inverse proportionality is not the same as negative correlation

08. OPERATIONS
  solve_missing(a,b,c,?): d=(b*c)/a if a != 0, b != 0, and derived d != 0
  solve_missing(a,b,?,d): c=(a*d)/b if b != 0 and d != 0
  solve_missing(a,?,c,d): b=(a*d)/c if c != 0 and derived b != 0
  solve_missing(?,b,c,d): a=(b*c)/d if b != 0 and d != 0
  otherwise: classify as no_solution, underdetermined or invalid_denominator
  validate_solution: substitute into original ratios

09. PROPORTION AS PART OF A WHOLE
  share(part,total) := part/total where total != 0
  percentage(part,total) := 100*part/total
  if total > 0 and 0 <= part <= total: 0 <= share <= 1
  sum_of_parts: sum(parts)=total -> sum(shares)=1
  caveat: part-to-whole proportions and ratio equalities are distinct concepts

10. UNIT AND DIMENSION RULES
  compare_ratios: dimensions(a)/dimensions(b) must match dimensions(c)/dimensions(d)
  dimensionless_ratio: quantities have compatible dimensions
  convert_units: normalize compatible units before comparing numeric ratios
  reject: physically incompatible ratio comparisons without declared interpretation

11. SEMANTIC RELATIONSHIPS
  Proportion IS_A MathematicalRelation
  Proportion HAS_PART Ratio
  Proportion ASSERTS RatioEquality
  Ratio HAS_PART Antecedent
  Ratio HAS_PART Consequent
  Proportion RELATED_TO Fraction
  Proportion RELATED_TO Percentage
  Proportion RELATED_TO Scaling
  DirectProportionality HAS_CONSTANT ProportionalityConstant
  InverseProportionality HAS_CONSTANT ProductConstant
  Proportion DEPENDS_ON NonzeroDenominatorConstraint

12. KNOWLEDGE GRAPH TRIPLES
  (Proportion, rdf:type, MathematicalRelation)
  (Proportion, relates, Ratio)
  (Proportion, hasPredicate, RatioEquality)
  (Ratio, hasAntecedent, Scalar)
  (Ratio, hasConsequent, NonzeroScalar)
  (DirectProportionality, representedBy, "y=k*x")
  (InverseProportionality, representedBy, "x*y=k")
  (Proportion, constrainedBy, DenominatorNonzero)

13. INFERENCE RULES
  IF b != 0 AND d != 0 AND a*d=b*c THEN proportion(a,b,c,d)=true
  IF proportion(a,b,c,d) THEN proportion(c,d,a,b)
  IF proportion(a,b,c,d) AND k != 0 THEN proportion(k*a,k*b,c,d)
  IF y=k*x for all x in domain THEN direct(y,x,k)
  IF x*y=k for all nonzero x in domain THEN inverse(y,x,k)
  IF any denominator = 0 THEN invalid_ratio
  IF input precision is approximate THEN use tolerance and propagate uncertainty

14. SEMANTIC EQUIVALENCE
  equivalent("a:b = c:d", "a/b = c/d") when b,d != 0
  equivalent("a is to b as c is to d", "a:b = c:d")
  equivalent("cross multiplication", "a*d=b*c") only with denominator guards
  distinguish("proportion", "probability")
  distinguish("proportionality", "correlation")
  distinguish("percentage point change", "relative percentage change")

15. NUMERIC PRECISION AND UNCERTAINTY
  exact: use integer/rational cross products when possible
  approximate: |a/b-c/d| <= tolerance is an application-specific approximation, not exact equality
  uncertainty: carry input measurement uncertainties into derived values
  tolerance: document absolute/relative threshold and unit context
  overflow: use arbitrary-precision arithmetic or checked multiplication

16. VALIDATION
  require: all terms have declared numeric types
  require: b != 0 and d != 0
  require: dimensional compatibility where quantities are measured
  check: cross-product equivalence for exact rational input
  check: output retains unit and provenance information
  reject: NaN, unhandled infinity and undeclared numeric coercion

17. TEST CASES
  assert proportion(2,3,4,6) == true
  assert proportion(2,3,4,5) == false
  assert proportion(0,5,0,9) == true
  assert proportion(-2,3,4,-6) == true
  assert proportion(1,0,2,3) == invalid_ratio
  assert solve_missing(2,3,4,?) == 6
  assert direct(y=12,x=4,k=3) == true
  assert inverse(y=3,x=4,k=12) == true

18. CONFIDENCE
  confidence=1.0 for verified exact arithmetic under satisfied assumptions
  confidence<1.0 for empirical estimates, noisy measurements or ambiguous units
  provenance and confidence are separate attributes
  do not infer mathematical truth solely from source popularity

19. FLOW_HASH
  hash_inputs: ontology_id, version, canonical_type_schema, rules, constraints
  FLOW_HASH := SHA256(UTF8(canonical_serialize(hash_inputs)))
  exclude: timestamps and presentation-only whitespace from canonical payload
  purpose: reproducible change detection and integrity verification

20. UPDATE_MODEL
  versioning: semantic_version
  update_trigger: definition_change | constraint_change | inference_change | mapping_change
  preserve: previous hashes, changelog and compatibility notes
  require: regression tests before publication

21. AI_CONSUMPTION
  parse: identify quantities, ratio components, units and equality intent
  normalize: exact fractions, compatible units, canonical relationships
  reason: apply guarded inference and symbolic arithmetic
  validate: verify denominator restrictions and result substitution
  explain: show equation, substitutions, assumptions and uncertainty
  emit: structured result {proportion, status, derivation, confidence, provenance}
  refuse_to_infer: where units, definitions or required inputs are ambiguous

22. PROVENANCE AND AUTHORSHIP
  ontology_page: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/numeric-value-entities/proportion-ontology.html
  research_site: https://kirethresearch.org
  co_authors: Mark Higgins — Sky (Recursive AI)
  note: independently composed reference specification; not a verified transcription of the source webpage

END FLOW ALGEBRA