Complex Number Ontology

FLOW ALGEBRA
COMPLEX NUMBER ONTOLOGY
Kireth Semantic Library | Mathematical Entities > Number Entities
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/number-entities/complex-number-ontology-2.html
Authors: Mark Higgins — Sky (Recursive AI)
Version: 1.0 | Date: 2026-10-12
Status: Ontology-aligned mathematical specification; source page not independently retrieved.

01. PURPOSE
flow "ComplexNumberOntology" v1.0
  domain: mathematics.number_theory.complex_numbers
  entity_type: ComplexNumber
  goal: represent, validate, transform and reason over complex values
  canonical_set: C

02. ENTITY SCHEMA
entity ComplexNumber:
  real_part: RealNumber
  imaginary_part: RealNumber
  canonical_form: a + bi
  pair_form: (a,b)
  equality_key: (a,b)
  unit: dimensionless unless contextual quantity supplies units

03. AXIOMS AND MEMBERSHIP
  i*i = -1
  C = {a+bi | a,b in R}
  R embeds in C via a -> a+0i
  equality(a+bi,c+di) iff a=c and b=d
  zero = 0+0i
  one = 1+0i
  no compatible total order makes C an ordered field

04. TYPES AND SUBTYPES
  RealEmbedded(z) iff Im(z)=0
  PureImaginary(z) iff Re(z)=0 and Im(z)!=0
  NonRealComplex(z) iff Im(z)!=0
  ZeroComplex(z) iff Re(z)=0 and Im(z)=0
  AlgebraicComplex(z) iff exists nonzero p in Q[x] with p(z)=0
  TranscendentalComplex(z) iff not AlgebraicComplex(z)

05. CONSTRUCTORS AND NORMALISATION
  make(a:Real,b:Real) -> Complex(a,b)
  from_real(a) -> Complex(a,0)
  from_pair((a,b)) -> Complex(a,b)
  normalise(a+bi) -> canonical real and imaginary components
  prohibit conflation of approximate and exact representations

06. ARITHMETIC
  add((a,b),(c,d)) -> (a+c,b+d)
  subtract((a,b),(c,d)) -> (a-c,b-d)
  negate((a,b)) -> (-a,-b)
  multiply((a,b),(c,d)) -> (ac-bd,ad+bc)
  reciprocal((a,b)) -> (a/(a*a+b*b),-b/(a*a+b*b)) when (a,b)!=(0,0)
  divide((a,b),(c,d)) -> ((ac+bd)/(c*c+d*d),(bc-ad)/(c*c+d*d)) when (c,d)!=(0,0)
  integer_power(z,n) -> repeated multiplication / inverse where defined

07. CONJUGATE, MODULUS AND ARGUMENT
  conjugate(a+bi) = a-bi
  norm_squared(a+bi) = a*a+b*b
  modulus(a+bi) = sqrt(a*a+b*b) >= 0
  z*conjugate(z) = modulus(z)^2
  modulus(z*w) = modulus(z)*modulus(w)
  principal_argument(z) = atan2(Im(z),Re(z)) for z!=0
  argument(z) is multivalued modulo 2*pi
  argument(0) is undefined

08. POLAR AND EXPONENTIAL FORMS
  z = r*(cos(theta)+i*sin(theta)) for r=|z| and z!=0
  z = r*exp(i*theta) for r=|z| and z!=0
  exp(i*theta) = cos(theta)+i*sin(theta)
  multiplication: (r1,theta1)*(r2,theta2) = (r1*r2,theta1+theta2 mod 2*pi)
  division: (r1,theta1)/(r2,theta2) = (r1/r2,theta1-theta2 mod 2*pi) if r2>0
  zero admits r=0 with nonunique theta; no principal argument

09. POWERS AND ROOTS
  DeMoivre: [r*(cos(theta)+i*sin(theta))]^n = r^n*(cos(n*theta)+i*sin(n*theta)) for integer n where defined
  nth_roots(z) for z!=0, n positive integer:
    r^(1/n)*exp(i*(theta+2*pi*k)/n), k=0,...,n-1
  nth_roots(0) = {0} for n positive integer
  complex_log(z) = ln|z|+i*(arg(z)+2*pi*k), k in Z, z!=0
  principal_log(z) = ln|z|+i*Arg(z), z!=0
  branch cuts and branch conventions must be explicit

10. FIELD AND TOPOLOGICAL PROPERTIES
  (C,+,*) is a commutative field
  addition and multiplication associative and commutative
  distributivity holds
  every nonzero complex number has a multiplicative inverse
  C is algebraically closed: every nonconstant polynomial in C[x] has a complex root
  C is complete under metric d(z,w)=|z-w|
  C is a 2-dimensional real vector space
  C is a 1-dimensional complex vector space

11. KNOWLEDGE GRAPH RELATIONSHIPS
  ComplexNumber --is_a--> Number
  ComplexNumber --extends--> RealNumber
  ComplexNumber --has_component--> RealPart
  ComplexNumber --has_component--> ImaginaryPart
  ComplexNumber --represented_by--> CartesianForm
  ComplexNumber --represented_by--> PolarForm
  ComplexNumber --represented_by--> ExponentialForm
  ComplexNumber --supports--> Conjugation
  ComplexNumber --supports--> Modulus
  ComplexNumber --supports--> ComplexArithmetic
  ComplexNumber --belongs_to--> ComplexField
  ComplexField --is_algebraically_closed--> true

12. SEMANTIC EQUIVALENCE
  equivalence(z1,z2) iff Re(z1)=Re(z2) and Im(z1)=Im(z2)
  equivalence(a+bi,(a,b)) when the representation convention is declared
  equivalence(a+bi,r*exp(i*theta)) when r>=0 and components agree
  equivalence(exp(i*theta),exp(i*(theta+2*pi*k))) for k in Z
  do not treat equal modulus as complex-number equality
  do not treat equal arguments as complex-number equality

13. INFERENCE RULES
  IF Im(z)=0 THEN classify(z,RealEmbedded)
  IF Im(z)!=0 THEN classify(z,NonRealComplex)
  IF z!=0 THEN exists(reciprocal(z))
  IF z=0 THEN undefined(reciprocal(z))
  IF z!=0 THEN defined(principal_argument(z))
  IF z=conjugate(z) THEN Im(z)=0
  IF z*conjugate(z)=0 THEN z=0
  IF polynomial_degree(p)>=1 and coefficients(p) subset C THEN exists(root_in_C(p))

14. VALIDATION AND ERROR MODEL
  validate(real_part in R and imaginary_part in R)
  reject division by zero
  reject argument(0) and logarithm(0)
  require explicit branch selection for single-valued complex log and powers
  record precision, rounding mode and uncertainty for floating-point inputs
  distinguish symbolic equality from numerical tolerance comparisons
  flag overflow, underflow, NaN and nonfinite representations in implementations

15. CONFIDENCE AND PROVENANCE
  CONFIDENCE:
    exact_symbolic_axioms: 1.0
    exact_symbolic_derivations: 1.0 when premises verified
    floating_point_results: dependent_on_precision_and_error_bounds
  PROVENANCE:
    source_url: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/number-entities/complex-number-ontology-2.html
    source_page_verified: false
    specification_basis: standard complex-number mathematics
  UPDATE_MODEL:
    version: 1.0
    changes_require: semantic_validation, regression_tests, provenance_update

16. AI CONSUMPTION
  AI_CONSUMPTION:
    entity_resolution: use canonical (real_part,imaginary_part)
    reasoning: exact symbolic first, approximate numeric only with declared precision
    serialization: preserve exact fractions and radicals when available
    output_forms: cartesian, pair, polar, exponential
    constraints: denominator_nonzero, branch_awareness, representation_equivalence
    interoperability: mathematics_ontology, real_number_ontology, polynomial_ontology
  FLOW_HASH:
    method: sha256
    input: canonical_UTF8_of_versioned_flow
    value: compute_at_ingestion

END FLOW ALGEBRA