Least Common Multiple Ontology

FLOW ALGEBRA
TITLE: Least Common Multiple Ontology
DOMAIN: Discrete Mathematics / Number Theory
SOURCE_URL: https://kirethresearch.org/booksai-core/discrete-mathematics-ontologies/number-theory/least-common-multiple-ontology.html
VERSION: 1.0
DATE: 2026-10-11
AUTHORS: Mark Higgins — Sky (Recursive AI)
SITE: https://kirethresearch.org
STATUS: Mathematical reference model; source page not independently verified.

1. ONTOLOGY
ontology LeastCommonMultipleOntology extends NumberTheoryOntology
entity Integer: Z
entity Natural: N0
entity NonzeroInteger: Z_nonzero
entity PositiveInteger: Z_positive
entity Divisor: Integer
entity Multiple: Integer
entity GreatestCommonDivisor: N0
entity LeastCommonMultiple: N0
entity Prime: PositiveInteger
entity PrimeExponent: N0

2. TYPED RELATIONSHIPS
relation divides(a: Integer, b: Integer): Boolean := exists k in Z: b = a*k
relation common_multiple(m: Integer, a: Integer, b: Integer): Boolean := divides(a,m) AND divides(b,m)
relation least_common_multiple(m: N0, a: Integer, b: Integer): Boolean :=
    m = lcm(a,b)
relation coprime(a: Integer, b: Integer): Boolean := gcd(a,b) = 1
relation prime_exponent(p: Prime, a: Z_nonzero): N0 := v_p(abs(a))

3. CORE DEFINITIONS
flow LCM(a: Integer, b: Integer) -> N0:
    if a = 0 OR b = 0: return 0
    return min({m in Z_positive | divides(a,m) AND divides(b,m)})

flow LCM_SET(S: finite nonempty set of Integer) -> N0:
    return fold(lcm, S)  # lcm of singleton {a} is abs(a)

flow LCM_EMPTY() -> N0:
    return 1  # convention: identity for lcm in nonnegative integers

4. ALGEBRAIC LAWS
law commutative: lcm(a,b) = lcm(b,a)
law associative: lcm(lcm(a,b),c) = lcm(a,lcm(b,c))
law idempotent: lcm(a,a) = abs(a)
law identity: lcm(a,1) = abs(a)
law zero_absorption: lcm(a,0) = 0
law sign_invariance: lcm(a,b) = lcm(abs(a),abs(b))
law scaling: lcm(k*a,k*b) = abs(k)*lcm(a,b)
law gcd_lcm: gcd(a,b)*lcm(a,b) = abs(a*b)
law divisibility_characterisation: lcm(a,b) divides m IFF a divides m AND b divides m
law divisibility_order: if a divides b then lcm(a,b) = abs(b)
law coprime_case: if gcd(a,b) = 1 then lcm(a,b) = abs(a*b)
law prime_valuation: for a,b != 0, v_p(lcm(a,b)) = max(v_p(abs(a)),v_p(abs(b)))

5. COMPUTATION
flow EUCLIDEAN_LCM(a: Integer, b: Integer) -> N0:
    if a = 0 OR b = 0: return 0
    g := gcd(abs(a),abs(b))
    return abs((a / g)*b)  # exact integer division before multiplication

flow PRIME_FACTOR_LCM(a: Z_nonzero, b: Z_nonzero) -> Z_positive:
    primes := support(factor(abs(a))) UNION support(factor(abs(b)))
    return product(p^max(v_p(abs(a)),v_p(abs(b))) for p in primes)

flow MULTI_LCM(values: finite sequence of Integer) -> N0:
    result := 1
    for x in values: result := lcm(result,x)
    return result

6. INFERENCE RULES
rule common_multiple_intro:
    divides(a,m) AND divides(b,m) => divides(lcm(a,b),m)
rule common_multiple_elim:
    divides(lcm(a,b),m) => divides(a,m) AND divides(b,m)
rule gcd_lcm_identity:
    gcd(a,b)=g AND lcm(a,b)=l => g*l=abs(a*b)
rule zero_input:
    a=0 OR b=0 => lcm(a,b)=0
rule coprime_inference:
    gcd(a,b)=1 => lcm(a,b)=abs(a*b)

7. SEMANTIC RELATIONSHIPS
LeastCommonMultiple --is_a--> NumberTheoreticOperation
LeastCommonMultiple --defined_over--> Integers
LeastCommonMultiple --dual_under_divisibility--> GreatestCommonDivisor
LeastCommonMultiple --computed_using--> EuclideanAlgorithm
LeastCommonMultiple --represented_by--> PrimeFactorisation
LeastCommonMultiple --applied_to--> FractionDenominators
LeastCommonMultiple --applied_to--> PeriodicScheduling
LeastCommonMultiple --applied_to--> ModularArithmetic

8. SEMANTIC_EQUIVALENCE
semantic_equivalence "LCM" <=> "least common multiple"
semantic_equivalence "lowest common multiple" <=> "least common multiple"
semantic_equivalence lcm(a,b) <=> abs(a*b)/gcd(a,b) WHEN (a,b)!=(0,0)
semantic_equivalence lcm(a,b) <=> max_under_divisibility(a,b) WHEN a,b are nonnegative integers
note: gcd(0,0)=0; division formula must not be evaluated at (0,0).

9. VALIDATION
assert lcm(12,18) = 36
assert lcm(8,15) = 120
assert lcm(-6,9) = 18
assert lcm(0,7) = 0
assert lcm(0,0) = 0
assert lcm(1,13) = 13
assert lcm(4,6,10) = 60
assert gcd(12,18)*lcm(12,18) = abs(12*18)
assert divides(6, lcm(6,10))
assert divides(10, lcm(6,10))
validate output >= 0
validate for nonzero a,b: output > 0
validate result is divisible by each nonzero input
validate zero input yields zero

10. CONFIDENCE
CONFIDENCE:
  formal_definitions: high
  standard_number_theory_laws: high
  source_page_alignment: unverified
  evidence_basis: established mathematics
  note: confidence describes mathematical grounding, not measured empirical accuracy.

11. FLOW_HASH
FLOW_HASH:
  method: SHA-256
  canonicalisation: UTF-8; LF line endings; exclude FLOW_HASH digest field
  digest: COMPUTE_AT_PUBLICATION
  purpose: integrity and version tracking

12. UPDATE_MODEL
UPDATE_MODEL:
  version: 1.0
  review_triggers: correction_of_definition | changed_ontology_dependencies | new_validation_cases
  preserve: mathematical_axioms | provenance | change_history
  validation_required: true

13. AI_CONSUMPTION
AI_CONSUMPTION:
  format: plain_text_flow_algebra
  language: en-GB
  machine_readable_entities: true
  typed_relations: true
  reasoning_mode: deterministic_symbolic
  prerequisites: integers | divisibility | greatest_common_divisor | prime_factorisation
  safety_constraints:
    - distinguish mathematical zero convention from positive common multiples
    - avoid division by zero in gcd-lcm identity
    - preserve exact integer arithmetic for large values
    - treat empty-family lcm identity as explicit convention
  outputs: lcm_value | proof_obligations | validation_results | provenance

END FLOW ALGEBRA