Real Number Ontology

FLOW Complex_Number_Ontology_Copy_v1.0

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

DEFINE ComplexNumberOntologyCopy := {

  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 a number expressible as a+bi, where a and b are real numbers and i is the imaginary unit satisfying 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:
      nonnegative_distance_from_origin,
    Argument:
      angle_from_positive_real_axis,
    Conjugate:
      a-b*i_for_z=a+b*i
  },

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

  SPECIAL_CASES: {
    RealComplexNumber: {
      condition:
        b=0
    },

    PureImaginaryNumber: {
      condition:
        a=0 AND b!=0
    },

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

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

  COMPLEX_PLANE: {
    real_axis:
      horizontal,
    imaginary_axis:
      vertical,
    origin:
      0+0*i
  },

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

  ADDITION: {
    rule:
      (a+b*i)+(c+d*i)
      =
      (a+c)+(b+d)*i,
    geometric_interpretation:
      vector_addition
  },

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

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

  DIVISION: {
    rule:
      (a+b*i)/(c+d*i)
      =
      ((a*c+b*d)+(b*c-a*d)*i)/(c^2+d^2),
    condition:
      c+d*i != 0
  },

  RECIPROCAL: {
    formula:
      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,
    period:
      4
  },

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

    identities: [
      conjugate(conjugate(z))=z,
      z*conjugate(z)=|z|^2,
      conjugate(z+w)=conjugate(z)+conjugate(w),
      conjugate(z*w)=conjugate(z)*conjugate(w)
    ]
  },

  MODULUS: {
    notation:
      |z|,
    formula:
      sqrt(a^2+b^2),
    geometric_meaning:
      distance_from_origin,
    properties: [
      |z|>=0,
      |z|=0 <=> z=0,
      |z*w|=|z|*|w|
    ]
  },

  ARGUMENT: {
    notation:
      arg(z),
    meaning:
      directed_angle_of_z_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)),
    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)
  },

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

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

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

  DE_MOIVRE_THEOREM: {
    formula:
      [r*(cos(theta)+i*sin(theta))]^n
      =
      r^n*(cos(n*theta)+i*sin(n*theta)),
    n:
      Integer
  },

  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: {
    root_count_for_nonzero_w:
      n_distinct_roots,

    radius:
      R^(1/n),

    angular_spacing:
      2*pi/n
  },

  POLYNOMIAL_RELATION: {
    fundamental_theorem_of_algebra:
      every_nonconstant_complex_polynomial_has_a_complex_root,

    consequence:
      degree_n_polynomial_has_n_roots_counting_multiplicity
  },

  CONJUGATE_ROOT_THEOREM: {
    condition:
      polynomial_coefficients_are_real,

    rule:
      IF a+b*i_is_root
      THEN a-b*i_is_root
  },

  QUADRATIC_RELATION: {
    IF discriminant_D<0:
      roots:
        (-b ± i*sqrt(-D))/(2*a)
  },

  FIELD_STRUCTURE: {
    closed_under: [
      addition,
      subtraction,
      multiplication,
      division_by_nonzero_elements
    ],

    additive_identity:
      0,

    multiplicative_identity:
      1,

    additive_inverse:
      -z,

    multiplicative_inverse:
      1/z WHERE z!=0
  },

  ALGEBRAIC_CLOSURE: {
    ComplexNumbers:
      algebraically_closed_field
  },

  ORDER_SEMANTICS: {
    compatible_total_order:
      none,

    rule:
      general_complex_numbers_do_not_support_standard_less_than_or_greater_than_order
  },

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

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

    |z-a|<r:
      open_disc,

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

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

    Im(z)=c:
      horizontal_line,

    Re(z)>c:
      right_half_plane,

    Im(z)>c:
      upper_half_plane
  },

  GEOMETRIC_TRANSFORMATIONS: {
    z -> z+c:
      translation,

    z -> r*z WHERE r>0:
      scaling,

    z -> e^(i*theta)*z:
      rotation,

    z -> r*e^(i*theta)*z:
      scaling_and_rotation
  },

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

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

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

    k:
      Integer,

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

    condition:
      z!=0
  },

  COMPLEX_POWER: {
    general_form:
      z^w=e^(w*Log(z))
      under_selected_branch,

    caution:
      branch_choice_matters
  },

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

    uniqueness:
      TRUE
  },

  COMPONENT_EXTRACTION: {
    Re(z):
      (z+conjugate(z))/2,

    Im(z):
      (z-conjugate(z))/(2*i)
  },

  MODULUS_ARGUMENT_RELATION: {
    IF z!=0:
      z/|z|=e^(i*arg(z))
      modulo_argument_branch
  },

  TRIANGLE_INEQUALITY: {
    |z+w| <= |z|+|w|
  },

  REVERSE_TRIANGLE_INEQUALITY: {
    ||z|-|w|| <= |z-w|
  },

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

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

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

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

    "imaginary part":
      Im(z),

    "complex conjugate":
      a-bi,

    "modulus":
      |z|,

    "argument":
      arg(z),

    "complex plane":
      cartesian_geometric_representation
  },

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

    tasks: [
      track_real_component,
      track_imaginary_component,
      calculate_modulus,
      calculate_argument,
      analyse_locus,
      detect_zero_crossing
    ]
  },

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

    EqualityComponentError:
      unequal_real_or_imaginary_parts_treated_as_equal
      -> flag,

    ConjugateError:
      incorrect_sign_change
      -> flag,

    ModulusError:
      modulus_not_sqrt(a^2+b^2)
      -> flag,

    ArgumentQuadrantError:
      incorrect_quadrant
      -> flag,

    DivisionByZero:
      denominator_complex_number_zero
      -> reject,

    OrderingError:
      standard_real_total_order_applied_to_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 TrigonometricFunctions"
    ],

    DEPENDS_ON: [
      RealNumberOntology,
      ImaginaryUnit,
      FieldOperations,
      TrigonometricSemantics
    ]
  },

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

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

    condition:
      equal_modulus
      AND arguments_equal_modulo_2*pi
  },

  CONFIDENCE: {
    classification_confidence:
      IF expression_reduces_to_a+b*i_with_real_a_and_b
      THEN 1.0,

    arithmetic_confidence:
      IF real_and_imaginary_components_verified
      THEN 1.0,

    geometric_confidence:
      IF modulus_and_argument_verified
      THEN 1.0
  },

  AI_CONSUMPTION: {
    tasks: [
      recognise_complex_number,
      extract_real_and_imaginary_parts,
      simplify_powers_of_i,
      perform_complex_arithmetic,
      compute_conjugate,
      compute_modulus,
      compute_argument,
      convert_between_cartesian_polar_and_exponential_forms,
      apply_de_moivre,
      find_nth_roots,
      analyse_polynomial_roots,
      analyse_complex_loci,
      detect_invalid_order_reasoning,
      link_related_ontologies
    ],

    preferred_representation:
      typed_complex_scalar_with_multiple_equivalent_views,

    reasoning_mode:
      recursive_algebraic_geometric_equivalence
  },

  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 RedirectToMoreGeneralObjectOntology

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

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

      conjugate_value := a-b*i

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

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

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

  RECURSIVE_COHERENCE: {
    invariant_1:
      imaginary_unit_square_equals_negative_one=TRUE,

    invariant_2:
      cartesian_representation_unique=TRUE,

    invariant_3:
      conjugate_product_equals_modulus_squared=TRUE,

    invariant_4:
      polar_and_cartesian_forms_agree=TRUE,

    invariant_5:
      arithmetic_closure_preserved=TRUE
  },

  FLOW_HASH: {
    semantic_signature_inputs: [
      ontology_name,
      complex_number_definition,
      imaginary_unit_rule,
      arithmetic_operations,
      cartesian_model,
      polar_model,
      root_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,
      ImaginaryNumber,
      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_root_semantics,

    QuadraticEquationOntology:
      negative_discriminant_roots,

    TrigonometryOntology:
      polar_coordinates,

    CoordinateGeometryOntology:
      complex_plane,

    ExponentialFunctionOntology:
      Euler_relation,

    LogarithmicFunctionOntology:
      complex_logarithm_relation,

    ComplexAnalysisOntology:
      advanced_complex_function_structure
  },

  TERMINATION_CONDITION: {
    ontology_complete_when: [
      complex_number_defined,
      real_and_imaginary_components_defined,
      imaginary_unit_defined,
      arithmetic_defined,
      conjugate_defined,
      modulus_defined,
      argument_defined,
      equivalent_forms_defined,
      de_moivre_and_roots_defined,
      polynomial_relations_defined,
      error_detection_defined,
      cross_ontology_links_defined,
      recursive_coherence_verified
    ]
  }

}

EXECUTE Complex_Number_Ontology_Copy_v1.0:

  INPUT:
    mathematical_entity_or_query

  PIPELINE:
    Parse
    -> IdentifyComplexStructure
    -> SimplifyImaginaryUnitPowers
    -> ExtractRealAndImaginaryParts
    -> ComputeConjugate
    -> ComputeModulus
    -> DetermineArgument
    -> ConvertCartesianPolarExponentialForms
    -> ApplyArithmeticOrRootReasoning
    -> VerifyEquivalentRepresentations
    -> AnalyseComplexPlaneSemantics
    -> LinkRelatedOntologies
    -> AssignConfidence
    -> EmitSemanticResult

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

END FLOW Complex_Number_Ontology_Copy_v1.0