Complex Number Ontology

FLOW Complex_Number_Ontology_v1.0

PAGE:
  title: "Complex Number Ontology"
  canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/algebra-ontologies/complex-number-ontology.html"
  language: "en-GB"
  domain: "Mathematics > Algebra > Number Systems > Complex Numbers"

DEFINE ComplexNumberOntology := {

  CORE_IDENTITY: {
    entity_type: "Mathematical Ontology",
    primary_entity: ComplexNumber,
    parent_entities: [Number, AlgebraicObject, NumberSystem],
    related_entities: [
      RealNumber,
      ImaginaryNumber,
      ImaginaryUnit,
      CartesianForm,
      PolarForm,
      ExponentialForm,
      Modulus,
      Argument,
      Conjugate,
      ComplexPlane,
      Root,
      PolynomialEquation,
      EulerFormula
    ]
  },

  DEFINITION: {
    meaning:
      "A complex number is an ordered algebraic quantity expressible as a+bi, where a and b are real numbers and i is defined by i^2=-1.",
    canonical_form:
      z=a+b*i,
    constraints: [
      a in RealNumbers,
      b in RealNumbers,
      i^2=-1
    ],
    real_part:
      Re(z)=a,
    imaginary_part:
      Im(z)=b
  },

  SEMANTIC_PRIMITIVES: {
    ImaginaryUnit:
      i_where_i^2=-1,
    RealPart:
      coefficient_a,
    ImaginaryPart:
      coefficient_b,
    Modulus:
      distance_from_origin_in_complex_plane,
    Argument:
      directed_angle_from_positive_real_axis,
    Conjugate:
      a-b*i_for_z=a+b*i
  },

  NUMBER_SYSTEM_RELATIONS: {
    RealNumbers_subset_ComplexNumbers:
      TRUE,
    RationalNumbers_subset_RealNumbers:
      TRUE,
    Integers_subset_RationalNumbers:
      TRUE,
    NaturalNumbers_subset_Integers:
      TRUE
  },

  SPECIAL_CASES: {
    PureRealNumber: {
      condition:
        b=0,
      form:
        z=a
    },

    PureImaginaryNumber: {
      condition:
        a=0 AND b!=0,
      form:
        z=b*i
    },

    ZeroComplexNumber: {
      condition:
        a=0 AND b=0
    }
  },

  CARTESIAN_FORM: {
    form:
      z=a+b*i,
    coordinate_mapping:
      (a,b),
    geometric_space:
      ComplexPlane
  },

  COMPLEX_PLANE: {
    horizontal_axis:
      real_axis,
    vertical_axis:
      imaginary_axis,
    point_representation:
      z=a+b*i <-> (a,b)
  },

  MODULUS: {
    notation:
      |z|,
    formula:
      sqrt(a^2+b^2),
    geometric_meaning:
      Euclidean_distance_from_origin,
    nonnegative:
      TRUE,
    zero_condition:
      |z|=0 <=> z=0
  },

  ARGUMENT: {
    notation:
      arg(z),
    geometric_meaning:
      angle_from_positive_real_axis,
    principal_argument:
      Arg(z),
    common_principal_range:
      (-pi,pi],
    undefined_for:
      z=0
  },

  POLAR_FORM: {
    form:
      z=r*(cos(theta)+i*sin(theta)),
    parameters: {
      r:
        |z|,
      theta:
        arg(z)
    },
    condition:
      r>=0
  },

  EXPONENTIAL_FORM: {
    form:
      z=r*e^(i*theta),
    basis:
      EulerFormula
  },

  EULER_FORMULA: {
    identity:
      e^(i*theta)=cos(theta)+i*sin(theta)
  },

  CONJUGATE: {
    notation:
      conjugate(z),
    IF z=a+b*i:
      conjugate(z)=a-b*i,

    properties: [
      z*conjugate(z)=|z|^2,
      conjugate(conjugate(z))=z,
      Re(z)=(z+conjugate(z))/2,
      Im(z)=(z-conjugate(z))/(2*i)
    ]
  },

  EQUALITY: {
    a+b*i = c+d*i
    IFF:
      a=c AND b=d
  },

  ADDITION: {
    (a+b*i)+(c+d*i):
      (a+c)+(b+d)*i,
    geometric_interpretation:
      vector_addition_in_complex_plane
  },

  SUBTRACTION: {
    (a+b*i)-(c+d*i):
      (a-c)+(b-d)*i
  },

  MULTIPLICATION: {
    (a+b*i)*(c+d*i):
      (a*c-b*d)+(a*d+b*c)*i,

    polar_rule:
      multiply_moduli_and_add_arguments
  },

  DIVISION: {
    z1/z2:
      multiply_numerator_and_denominator_by_conjugate(z2),

    condition:
      z2!=0,

    cartesian_formula:
      ((a+b*i)/(c+d*i))
      =
      ((a*c+b*d)+(b*c-a*d)*i)/(c^2+d^2)
  },

  RECIPROCAL: {
    1/z:
      conjugate(z)/|z|^2,
    condition:
      z!=0
  },

  POWERS_OF_I: {
    i^0:
      1,
    i^1:
      i,
    i^2:
      -1,
    i^3:
      -i,
    i^4:
      1,
    cycle_period:
      4
  },

  MODULUS_PROPERTIES: {
    |z*w|:
      |z|*|w|,
    |z/w|:
      |z|/|w|
      WHERE w!=0,
    triangle_inequality:
      |z+w|<=|z|+|w|
  },

  ARGUMENT_PROPERTIES: {
    arg(z*w):
      arg(z)+arg(w)
      modulo_2*pi,

    arg(z/w):
      arg(z)-arg(w)
      modulo_2*pi
  },

  POLAR_MULTIPLICATION: {
    z1=r1*e^(i*theta1),
    z2=r2*e^(i*theta2),

    product:
      z1*z2=(r1*r2)*e^(i*(theta1+theta2))
  },

  POLAR_DIVISION: {
    quotient:
      z1/z2=(r1/r2)*e^(i*(theta1-theta2)),
    condition:
      r2!=0
  },

  DE_MOIVRE_THEOREM: {
    form:
      (r*(cos(theta)+i*sin(theta)))^n
      =
      r^n*(cos(n*theta)+i*sin(n*theta)),

    integer_n:
      TRUE
  },

  NTH_ROOTS: {
    equation:
      z^n=w,

    IF w=R*e^(i*phi):
      roots:
        z_k=R^(1/n)*e^(i*(phi+2*pi*k)/n),

    k:
      0,1,...,n-1
  },

  ROOT_GEOMETRY: {
    nth_roots_of_nonzero_complex_number:
      equally_spaced_on_circle,
    radius:
      R^(1/n),
    angular_spacing:
      2*pi/n
  },

  POLYNOMIAL_RELATION: {
    FundamentalTheoremOfAlgebra:
      every_nonconstant_polynomial_with_complex_coefficients_has_at_least_one_complex_root,

    consequence:
      degree_n_polynomial_has_n_complex_roots_counting_multiplicity
  },

  CONJUGATE_ROOT_THEOREM: {
    IF polynomial_has_real_coefficients
    AND a+b*i_is_root
    THEN:
      a-b*i_is_also_root
  },

  QUADRATIC_RELATION: {
    discriminant_negative_over_reals:
      produces_complex_conjugate_roots,

    formula:
      x=(-b ± i*sqrt(4*a*c-b^2))/(2*a)
      WHEN b^2-4*a*c<0
  },

  REAL_IMAGINARY_DECOMPOSITION: {
    z:
      Re(z)+i*Im(z),

    uniqueness:
      TRUE
  },

  ORDER_RELATION: {
    standard_total_order_compatible_with_field_operations:
      DOES_NOT_EXIST,

    semantic_rule:
      inequalities_like_z1<z2_not_standard_for_general_complex_numbers
  },

  FIELD_PROPERTIES: {
    addition:
      closed,
    subtraction:
      closed,
    multiplication:
      closed,
    division:
      closed_except_division_by_zero,
    additive_identity:
      0,
    multiplicative_identity:
      1,
    additive_inverse:
      -z,
    multiplicative_inverse:
      1/z_for_z!=0
  },

  ALGEBRAIC_CLOSURE: {
    ComplexNumbers:
      algebraically_closed_field
  },

  DISTANCE: {
    distance_between_z1_and_z2:
      |z1-z2|
  },

  LOCUS_SEMANTICS: {
    |z-a|=r:
      circle_centre_a_radius_r,

    |z-a|<r:
      open_disc,

    |z-a|<=r:
      closed_disc
  },

  LINE_AND_HALF_PLANE_RELATION: {
    Re(z)=c:
      vertical_line,

    Im(z)=c:
      horizontal_line,

    Re(z)>c:
      right_half_plane,

    Im(z)>c:
      upper_half_plane
  },

  TRANSFORMATIONS: {
    addition_by_c:
      translation_in_complex_plane,

    multiplication_by_positive_real_r:
      radial_scaling,

    multiplication_by_e^(i*theta):
      rotation_by_theta,

    multiplication_by_r*e^(i*theta):
      scale_by_r_then_rotate_by_theta
  },

  COMPLEX_EXPONENTIAL: {
    e^(x+i*y):
      e^x*(cos(y)+i*sin(y)),

    periodicity:
      e^(z+2*pi*i)=e^z
  },

  COMPLEX_LOGARITHM: {
    multivalued_form:
      log(z)=ln|z|+i*(arg(z)+2*pi*k),

    k:
      integer,

    principal_log:
      Log(z)=ln|z|+i*Arg(z),

    condition:
      z!=0
  },

  COMPLEX_SQUARE_ROOT: {
    nonzero_complex_number:
      has_exactly_two_square_roots,

    zero:
      has_one_square_root_zero
  },

  PARAMETER_REASONING: {
    z(t)=a(t)+i*b(t),

    tasks: [
      track_real_and_imaginary_parts,
      derive_modulus,
      derive_argument,
      analyse_locus,
      detect_parameter_values_where_z=0
    ]
  },

  SYMBOLIC_RECOGNITION: {
    ACCEPT: [
      "3+4i",
      "-2i",
      "5",
      "2e^(i*pi/3)",
      "4(cos(theta)+i sin(theta))"
    ],

    NORMALISE_FIRST: [
      "sqrt(-9)",
      "(1+i)^2",
      "1/(2-i)"
    ],

    INVALID_STANDARD_REAL_ORDER: [
      "3+i < 4+2i"
    ]
  },

  NATURAL_LANGUAGE_MAPPING: {
    "real part":
      Re(z),

    "imaginary part":
      Im(z),

    "modulus":
      |z|,

    "argument":
      arg(z),

    "complex conjugate":
      reflect_imaginary_part_sign,

    "complex plane":
      geometric_representation_of_a+bi
  },

  UNIT_SEMANTICS: {
    real_and_imaginary_components:
      should_share_same_physical_dimension_when_representing_one_physical_complex_quantity,

    phase:
      dimensionless_angle
  },

  ERROR_DETECTION: {
    ImaginaryUnitError:
      i^2_not_equal_-1
      -> flag,

    ConjugateError:
      only_imaginary_sign_should_reverse
      -> flag,

    ModulusError:
      |a+bi| != a+b
      -> flag,

    DivisionError:
      denominator_not_rationalised_or_zero_case_ignored
      -> flag,

    ArgumentQuadrantError:
      angle_not_adjusted_for_correct_quadrant
      -> flag,

    OrderError:
      total_order_assumed_on_complex_numbers
      -> flag
  },

  ONTOLOGY_RELATIONS: {
    IS_A: [
      "ComplexNumber IS_A Number",
      "RealNumber IS_A ComplexNumber",
      "PureImaginaryNumber IS_A ComplexNumber"
    ],

    RELATED_TO: [
      "ComplexNumber RELATED_TO ComplexPlane",
      "ComplexNumber RELATED_TO PolarCoordinates",
      "ComplexNumber RELATED_TO PolynomialRoots",
      "ComplexNumber RELATED_TO EulerFormula",
      "ComplexNumber RELATED_TO Trigonometry"
    ],

    DEPENDS_ON: [
      RealNumbers,
      ImaginaryUnit,
      FieldOperations,
      TrigonometricFunctions
    ]
  },

  SEMANTIC_EQUIVALENCE: {
    cartesian_polar_equivalence:
      a+b*i
      <=> r*(cos(theta)+i*sin(theta)),

    exponential_equivalence:
      r*(cos(theta)+i*sin(theta))
      <=> r*e^(i*theta),

    condition:
      same_modulus_and_argument_modulo_2*pi
  },

  CONFIDENCE: {
    classification_confidence:
      IF expression_reducible_to_a+b*i_with_real_a_b
      THEN 1.0,

    modulus_confidence:
      IF real_and_imaginary_parts_verified
      THEN 1.0,

    polar_conversion_confidence:
      IF quadrant_and_argument_verified
      THEN 1.0
  },

  AI_CONSUMPTION: {
    tasks: [
      recognise_complex_number,
      extract_real_part,
      extract_imaginary_part,
      simplify_powers_of_i,
      add_subtract_multiply_divide,
      compute_conjugate,
      compute_modulus,
      compute_argument,
      convert_cartesian_to_polar,
      convert_polar_to_cartesian,
      apply_de_moivre,
      compute_nth_roots,
      analyse_polynomial_root_structure,
      analyse_complex_plane_loci,
      detect_invalid_ordering,
      map_natural_language,
      link_related_ontologies
    ],

    preferred_representation:
      typed_complex_scalar_with_cartesian_and_polar_views,

    reasoning_mode:
      recursive_dual_algebraic_geometric_representation
  },

  RECURSIVE_REASONING: {

    FUNCTION AnalyseComplexNumber(Z,Context):

      parsed := ParseExpression(Z)
      simplified := SimplifyComplexExpression(parsed)

      [a,b] := ExtractRealImaginaryParts(simplified)

      IF not IsReal(a) OR not IsReal(b):
        RETURN RedirectToMoreGeneralAlgebraicObjectOntology

      modulus := sqrt(a^2+b^2)

      IF modulus=0:
        argument := Undefined
      ELSE:
        argument := DetermineQuadrantAwareArgument(a,b)

      conjugate := a-b*i

      polar :=
        IF modulus=0
        THEN 0
        ELSE modulus*e^(i*argument)

      verified := VerifyRepresentations(
        simplified,
        a+b*i,
        polar
      )

      RETURN {
        complex_number:simplified,
        real_part:a,
        imaginary_part:b,
        modulus,
        argument,
        conjugate,
        polar_form:polar,
        verified
      }
  },

  RECURSIVE_COHERENCE: {
    invariant_1:
      i^2=-1=TRUE,

    invariant_2:
      cartesian_and_polar_forms_represent_same_number=TRUE,

    invariant_3:
      z*conjugate(z)=|z|^2=TRUE,

    invariant_4:
      argument_quadrant_matches_real_imaginary_signs=TRUE,

    invariant_5:
      field_operations_preserve_complex_number_membership=TRUE
  },

  FLOW_HASH: {
    semantic_signature_inputs: [
      ontology_name,
      complex_number_definition,
      imaginary_unit_rule,
      cartesian_model,
      polar_model,
      conjugate_properties,
      root_and_polynomial_relations
    ],

    purpose:
      "Detect semantic drift between revisions of the ontology."
  },

  UPDATE_MODEL: {
    version: "1.0",

    immutable_constraints: [
      i_squared_equals_negative_one,
      unique_real_imaginary_decomposition,
      modulus_definition,
      conjugate_definition,
      field_structure,
      no_standard_total_order
    ],

    revision_triggers: [
      semantic_conflict,
      NumberOntology_update,
      PolynomialOntology_update,
      ComplexAnalysisOntology_update,
      representation_standard_change
    ]
  },

  KNOWLEDGE_GRAPH: {
    nodes: [
      ComplexNumber,
      RealNumber,
      ImaginaryUnit,
      RealPart,
      ImaginaryPart,
      Modulus,
      Argument,
      Conjugate,
      ComplexPlane,
      PolarForm,
      ExponentialForm
    ],

    edges: [
      ComplexNumber -> IS_A -> Number,
      RealNumber -> IS_A -> ComplexNumber,
      ComplexNumber -> HAS_REAL_PART -> RealPart,
      ComplexNumber -> HAS_IMAGINARY_PART -> ImaginaryPart,
      ComplexNumber -> HAS_MODULUS -> Modulus,
      ComplexNumber -> HAS_ARGUMENT -> Argument,
      ComplexNumber -> HAS_CONJUGATE -> Conjugate,
      ComplexNumber -> REPRESENTED_IN -> ComplexPlane,
      ComplexNumber -> HAS_REPRESENTATION -> PolarForm,
      PolarForm -> EQUIVALENT_TO -> ExponentialForm
    ]
  },

  CROSS_ONTOLOGY_LINKS: {
    NumberOntology:
      direct_parent,

    RealNumberOntology:
      embedded_subsystem,

    PolynomialEquationOntology:
      complex_roots,

    QuadraticEquationOntology:
      negative_discriminant_solutions,

    TrigonometryOntology:
      polar_representation,

    CoordinateGeometryOntology:
      complex_plane,

    ExponentialFunctionOntology:
      Euler_and_complex_exponential_relation,

    ComplexAnalysisOntology:
      logarithm_argument_holomorphic_structure
  },

  TERMINATION_CONDITION: {
    ontology_complete_when: [
      complex_number_defined,
      real_imaginary_parts_defined,
      imaginary_unit_defined,
      arithmetic_operations_defined,
      modulus_and_argument_defined,
      conjugate_defined,
      cartesian_polar_exponential_forms_defined,
      de_moivre_and_roots_defined,
      polynomial_relations_defined,
      error_detection_defined,
      cross_ontology_links_defined,
      recursive_coherence_verified
    ]
  }

}

EXECUTE Complex_Number_Ontology_v1.0:

  INPUT:
    mathematical_entity_or_query

  PIPELINE:
    Parse
    -> IdentifyComplexStructure
    -> SimplifyPowersOfImaginaryUnit
    -> ExtractRealAndImaginaryParts
    -> ComputeConjugate
    -> ComputeModulus
    -> DetermineArgument
    -> ConvertRepresentationsWhenRequired
    -> ApplyArithmeticOrRootOperations
    -> VerifyGeometricAndAlgebraicConsistency
    -> LinkPolynomialAndFunctionRelations
    -> AssignConfidence
    -> EmitSemanticResult

  OUTPUT: {
    entity,
    classification,
    cartesian_form,
    real_part,
    imaginary_part,
    modulus,
    argument,
    conjugate,
    polar_form,
    exponential_form,
    roots,
    locus_semantics,
    transformations,
    verification,
    ontology_relations,
    confidence,
    semantic_equivalence,
    flow_hash
  }

END FLOW Complex_Number_Ontology_v1.0