Exponential Function Ontology

FLOW Exponential_Function_Ontology_v1.0

PAGE:
  title: "Exponential Function Ontology"
  canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/algebra-ontologies/exponential-function-ontology.html"
  language: "en-GB"
  domain: "Mathematics > Algebra > Functions > Exponential Functions"

DEFINE ExponentialFunctionOntology := {

  CORE_IDENTITY: {
    entity_type: "Mathematical Ontology",
    primary_entity: ExponentialFunction,
    parent_entities: [Function, TranscendentalFunction, AlgebraicAnalysisObject],
    related_entities: [
      Base,
      Exponent,
      Variable,
      Constant,
      Growth,
      Decay,
      NaturalExponentialFunction,
      LogarithmicFunction,
      InverseFunction,
      Domain,
      Range,
      Asymptote,
      CompoundGrowth,
      ContinuousGrowth
    ]
  },

  DEFINITION: {
    meaning:
      "A function in which the independent variable appears in the exponent of a positive constant base.",
    canonical_form:
      f(x)=a*b^x,
    constraints: [
      a != 0,
      b > 0,
      b != 1
    ],
    base:
      b,
    initial_scale:
      a
  },

  SEMANTIC_PRIMITIVES: {
    Base:
      fixed_positive_number_raised_to_variable_power,
    Exponent:
      variable_or_expression_controlling_repeated_multiplicative_change,
    GrowthFactor:
      multiplicative_change_per_unit_input,
    InitialValue:
      f(0),
    Asymptote:
      line_or_curve_approached_but_not_reached_in_limit_context,
    NaturalBase:
      e
  },

  FUNCTION_MODEL: {
    mapping:
      f: Domain -> Codomain,
    standard_real_domain:
      RealNumbers,
    standard_real_codomain:
      RealNumbers,
    canonical_rule:
      x -> a*b^x
  },

  PARAMETER_MODEL: {
    a:
      vertical_scale_and_initial_value,
    b:
      multiplicative_base,
    x:
      independent_variable
  },

  INITIAL_VALUE: {
    formula:
      f(0)=a*b^0=a,
    interpretation:
      initial_scale
  },

  GROWTH_DECAY_CLASSIFICATION: {
    IF b>1:
      classification:
        ExponentialGrowth,
    IF 0<b<1:
      classification:
        ExponentialDecay
  },

  NATURAL_EXPONENTIAL_FUNCTION: {
    form:
      f(x)=a*e^(k*x),
    base:
      e,
    parameter_k:
      continuous_growth_or_decay_rate
  },

  EQUIVALENT_PARAMETERISATION: {
    discrete_form:
      f(x)=a*b^x,
    continuous_form:
      f(x)=a*e^(k*x),
    conversion:
      k=ln(b),
    inverse_conversion:
      b=e^k
  },

  DOMAIN_RANGE: {
    standard_real_exponential: {
      Domain:
        RealNumbers
    },

    IF a>0:
      Range:
        (0,infinity),

    IF a<0:
      Range:
        (-infinity,0),

    IF vertical_shift_present:
      range_shifted_accordingly
  },

  Y_INTERCEPT: {
    coordinate:
      (0,a)
  },

  X_INTERCEPT: {
    canonical_unshifted_form:
      none_over_real_numbers,
    reason:
      a*b^x != 0 for finite_real_x_when_a!=0
  },

  HORIZONTAL_ASYMPTOTE: {
    canonical_unshifted_form:
      y=0,

    shifted_form:
      f(x)=a*b^(x-h)+k
      -> asymptote y=k
  },

  LIMIT_BEHAVIOUR: {
    IF b>1 AND a>0:
      x->infinity:
        f(x)->infinity,
      x->-infinity:
        f(x)->0_positive,

    IF 0<b<1 AND a>0:
      x->infinity:
        f(x)->0_positive,
      x->-infinity:
        f(x)->infinity
  },

  MONOTONICITY: {
    IF a>0 AND b>1:
      strictly_increasing,

    IF a>0 AND 0<b<1:
      strictly_decreasing,

    sign_of_a:
      reflects_graph_across_x_axis
  },

  CONTINUITY: {
    real_exponential_function:
      continuous_on_RealNumbers=TRUE
  },

  DIFFERENTIABILITY: {
    f(x)=a*b^x,
    derivative:
      f'(x)=a*b^x*ln(b),

    natural_base:
      derivative_of_a*e^x = a*e^x
  },

  SECOND_DERIVATIVE: {
    f''(x)=a*b^x*(ln(b))^2
  },

  CONCAVITY: {
    IF a>0:
      concave_up,
    IF a<0:
      concave_down
  },

  INTEGRAL_RELATION: {
    IF b!=1:
      integral_of_a*b^x_dx =
        a*b^x/ln(b)+C,

    natural_base:
      integral_of_a*e^x_dx =
        a*e^x+C
  },

  LOGARITHMIC_INVERSE: {
    function:
      f(x)=b^x,
    inverse:
      f^(-1)(x)=log_b(x),

    conditions:
      b>0,
      b!=1,

    domain_range_swap: {
      Domain(exponential):
        RealNumbers,
      Range(exponential):
        PositiveRealNumbers,
      Domain(logarithm):
        PositiveRealNumbers,
      Range(logarithm):
        RealNumbers
    }
  },

  SOLVING_EXPONENTIAL_EQUATIONS: {
    same_base_method:
      IF b^(u)=b^(v)
      THEN u=v,

    logarithmic_method:
      a*b^(g(x))=c
      -> b^(g(x))=c/a
      -> g(x)=log_b(c/a),

    domain_requirement:
      c/a > 0
  },

  EXPONENTIAL_LAWS: {
    product:
      b^x*b^y=b^(x+y),

    quotient:
      b^x/b^y=b^(x-y),

    power_of_power:
      (b^x)^y=b^(x*y),

    zero_exponent:
      b^0=1,

    negative_exponent:
      b^(-x)=1/b^x
  },

  TRANSFORMATIONS: {
    base:
      y=b^x,

    vertical_scale:
      y=a*b^x,

    horizontal_shift:
      y=b^(x-h),

    vertical_shift:
      y=b^x+k,

    reflection_x_axis:
      y=-b^x,

    reflection_y_axis:
      y=b^(-x)=(1/b)^x
  },

  SHIFTED_FORM: {
    form:
      f(x)=a*b^(x-h)+k,

    horizontal_shift:
      h,

    vertical_shift:
      k,

    asymptote:
      y=k
  },

  COMPOSITION: {
    exponential_after_linear:
      f(g(x))=a*b^(m*x+c),

    linear_after_exponential:
      g(f(x))=m*(a*b^x)+c,

    semantic_note:
      output_type_and_domain_constraints_must_be_preserved
  },

  INJECTIVITY: {
    canonical_exponential_with_valid_base:
      TRUE
  },

  SURJECTIVITY: {
    onto_PositiveRealNumbers_for_b^x:
      TRUE,

    onto_RealNumbers:
      FALSE
  },

  BIJECTIVITY: {
    b^x:
      RealNumbers -> PositiveRealNumbers
      is_bijective
  },

  RATE_OF_CHANGE: {
    relative_rate:
      f'(x)/f(x)=ln(b),

    natural_continuous_form:
      f'(x)=k*f(x)
      for_f(x)=a*e^(k*x)
  },

  DIFFERENTIAL_EQUATION_RELATION: {
    equation:
      y'=k*y,

    general_solution:
      y=C*e^(k*x),

    semantic_relation:
      exponential_functions_are_eigenfunctions_of_differentiation
  },

  COMPOUND_GROWTH: {
    discrete_model:
      A=P*(1+r)^n,

    base:
      1+r,

    initial_value:
      P,

    growth_rate:
      r
  },

  COMPOUND_DECAY: {
    model:
      A=P*(1-r)^n,

    constraint:
      0<r<1
  },

  CONTINUOUS_GROWTH: {
    model:
      A=P*e^(r*t)
  },

  DOUBLING_TIME: {
    model:
      A=P*e^(k*t),

    IF k>0:
      doubling_time:
        ln(2)/k
  },

  HALF_LIFE: {
    model:
      A=P*e^(k*t),

    IF k<0:
      half_life:
        ln(2)/(-k)
  },

  PERCENTAGE_CHANGE_RELATION: {
    growth_factor:
      1+r,

    decay_factor:
      1-r,

    percentage_rate:
      100*r_percent
  },

  DISCRETE_VS_CONTINUOUS: {
    discrete_exponential:
      repeated_multiplicative_steps,

    continuous_exponential:
      continuously_compounded_change,

    relation:
      b^x=e^(x*ln(b))
  },

  TABLE_RECOGNITION: {
    equally_spaced_inputs:
      constant_output_ratio_indicates_exponential_pattern,

    test:
      f(x+d)/f(x)=constant
      WHERE outputs_nonzero
  },

  SEQUENCE_RELATION: {
    geometric_sequence:
      a_n=a_1*r^(n-1),

    relation:
      exponential_function_restricted_to_integer_index
  },

  LOG_LINEAR_RELATION: {
    IF y=a*b^x AND y/a>0:
      ln(|y/a|)=x*ln(b),

    use:
      transform_exponential_relation_to_linear_relation_in_log_space
  },

  PARAMETER_REASONING: {
    family:
      f_(a,b)(x)=a*b^x,

    special_cases: {
      a=0:
        zero_function_not_exponential_under_canonical_definition,

      b=1:
        constant_function,

      b<=0:
        not_standard_real_exponential_function_over_all_real_x
    }
  },

  BASE_CONSTRAINTS: {
    standard_real_exponential_base:
      b>0 AND b!=1,

    negative_base:
      not_defined_for_all_real_exponents,

    zero_base:
      invalid_for_general_real_exponential_function
  },

  SYMBOLIC_RECOGNITION: {
    ACCEPT: [
      "f(x)=2^x",
      "y=3*5^x",
      "g(t)=4e^(0.2t)",
      "h(x)=7*(1/2)^x"
    ],

    NORMALISE_FIRST: [
      "f(x)=e^(ln(3)*x)",
      "y=2^(x-1)+4"
    ],

    REDIRECT_NONEXPONENTIAL: [
      "f(x)=x^3",
      "f(x)=log(x)",
      "f(x)=x^x",
      "f(x)=(-2)^x over all real x"
    ]
  },

  NATURAL_LANGUAGE_MAPPING: {
    "grows by a constant percentage":
      exponential_growth,

    "decays by a constant percentage":
      exponential_decay,

    "doubles every":
      exponential_growth_with_doubling_time,

    "half-life":
      exponential_decay,

    "continuous growth":
      natural_exponential_model
  },

  WORD_PROBLEM_REASONING: {
    PIPELINE: [
      identify_initial_quantity,
      identify_growth_or_decay_rate,
      determine_discrete_or_continuous_model,
      identify_time_or_input_variable,
      construct_exponential_function,
      apply_domain_constraints,
      solve_or_evaluate,
      verify_units_and_context
    ],

    common_contexts: [
      population_growth,
      radioactive_decay,
      compound_interest,
      depreciation,
      bacterial_growth,
      cooling_approximations,
      information_growth
    ]
  },

  UNIT_SEMANTICS: {
    exponent_dimension:
      must_be_dimensionless,

    IF exponent=k*t:
      k_units:
        inverse_time_units,

    output_units:
      inherited_from_scale_parameter_a
  },

  ERROR_DETECTION: {
    InvalidBase:
      b<=0_or_b=1
      -> reject_standard_exponential_classification,

    ZeroScale:
      a=0
      -> classify_as_zero_function,

    IncorrectAsymptote:
      shifted_form_asymptote_not_equal_k
      -> flag,

    GrowthDecayConfusion:
      base_greater_than_1_vs_between_0_and_1
      -> flag,

    LogDomainError:
      taking_log_of_nonpositive_quantity
      -> reject_step,

    PercentageFactorError:
      confusing_rate_r_with_factor_1+r
      -> flag
  },

  ONTOLOGY_RELATIONS: {
    IS_A: [
      "ExponentialFunction IS_A Function",
      "NaturalExponentialFunction IS_A ExponentialFunction"
    ],

    RELATED_TO: [
      "ExponentialFunction RELATED_TO LogarithmicFunction",
      "ExponentialFunction RELATED_TO GeometricSequence",
      "ExponentialFunction RELATED_TO DifferentialEquation",
      "ExponentialFunction RELATED_TO CompoundGrowth",
      "ExponentialFunction RELATED_TO Calculus"
    ],

    DEPENDS_ON: [
      FunctionSemantics,
      RealExponentiation,
      Logarithm,
      PositiveBaseConstraint
    ]
  },

  SEMANTIC_EQUIVALENCE: {
    examples: [
      "2^x <=> e^(x*ln(2))",
      "a*b^x <=> a*e^(x*ln(b))"
    ],

    function_equivalence:
      same_domain
      AND same_output_for_every_input
  },

  CONFIDENCE: {
    classification_confidence:
      IF variable_occurs_in_exponent
      AND valid_base_constraints
      THEN 1.0,

    growth_decay_confidence:
      IF base_verified
      THEN 1.0,

    inverse_confidence:
      IF monotonicity_and_range_verified
      THEN 1.0
  },

  AI_CONSUMPTION: {
    tasks: [
      recognise_exponential_function,
      extract_base_and_scale,
      classify_growth_or_decay,
      infer_domain_and_range,
      identify_asymptote,
      compute_intercepts,
      convert_between_base_b_and_base_e_forms,
      solve_exponential_equations,
      construct_logarithmic_inverse,
      analyse_compound_growth,
      analyse_half_life_and_doubling_time,
      interpret_tables_by_constant_ratio,
      differentiate,
      integrate,
      detect_invalid_bases,
      map_word_problems,
      link_related_ontologies
    ],

    preferred_representation:
      typed_transcendental_function_graph,

    reasoning_mode:
      recursive_multiplicative_change_analysis
  },

  RECURSIVE_REASONING: {

    FUNCTION AnalyseExponentialFunction(F,Context):

      parsed := ParseFunction(F)
      simplified := Simplify(parsed)

      IF not IsFunction(simplified):
        RETURN RedirectToRelationOntology

      form := DetectExponentialForm(simplified)

      IF form = NONE:
        RETURN RedirectToFunctionOntology

      [a,b,h,k] := ExtractExponentialParameters(form)

      IF a=0:
        RETURN ZeroFunction

      IF b<=0 OR b=1:
        RETURN InvalidStandardRealExponentialForm

      classification :=
        IF b>1 THEN ExponentialGrowth
        ELSE ExponentialDecay

      properties := {
        domain:RealNumbers,
        asymptote:y=k,
        initial_or_shifted_reference_value:EvaluateAtReference(form),
        monotonicity:InferMonotonicity(a,b),
        range:InferShiftedRange(a,k),
        inverse:ConstructLogarithmicInverseWhenApplicable(form)
      }

      verified := VerifyExponentialProperties(form,properties)

      RETURN {
        function:simplified,
        parameters:[a,b,h,k],
        classification,
        properties,
        verified
      }
  },

  RECURSIVE_COHERENCE: {
    invariant_1:
      valid_real_base_constraint_preserved=TRUE,

    invariant_2:
      constant_multiplicative_rate_matches_base=TRUE,

    invariant_3:
      asymptote_matches_vertical_shift=TRUE,

    invariant_4:
      logarithmic_inverse_semantics_consistent=TRUE,

    invariant_5:
      derivative_relative_rate_consistent_with_ln_base=TRUE
  },

  FLOW_HASH: {
    semantic_signature_inputs: [
      ontology_name,
      exponential_definition,
      base_constraints,
      growth_decay_model,
      logarithmic_inverse,
      asymptote_semantics,
      calculus_relations
    ],

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

  UPDATE_MODEL: {
    version: "1.0",

    immutable_constraints: [
      variable_in_exponent,
      positive_nonunit_base,
      multiplicative_change_semantics,
      logarithmic_inverse_relation,
      horizontal_asymptote_semantics
    ],

    revision_triggers: [
      semantic_conflict,
      FunctionOntology_update,
      LogarithmicFunctionOntology_update,
      new_representation_standard
    ]
  },

  KNOWLEDGE_GRAPH: {
    nodes: [
      ExponentialFunction,
      Function,
      Base,
      Exponent,
      Growth,
      Decay,
      NaturalExponentialFunction,
      LogarithmicFunction,
      Asymptote,
      Domain,
      Range,
      CompoundGrowth
    ],

    edges: [
      ExponentialFunction -> IS_A -> Function,
      ExponentialFunction -> HAS_BASE -> Base,
      ExponentialFunction -> HAS_EXPONENT -> Exponent,
      ExponentialFunction -> CLASSIFIED_AS -> Growth,
      ExponentialFunction -> CLASSIFIED_AS -> Decay,
      NaturalExponentialFunction -> USES_BASE -> e,
      ExponentialFunction -> HAS_INVERSE -> LogarithmicFunction,
      ExponentialFunction -> HAS_ASYMPTOTE -> Asymptote,
      ExponentialFunction -> HAS_DOMAIN -> Domain,
      ExponentialFunction -> HAS_RANGE -> Range
    ]
  },

  CROSS_ONTOLOGY_LINKS: {
    FunctionOntology:
      direct_parent,

    LogarithmicFunctionOntology:
      inverse_relation,

    SequenceOntology:
      geometric_sequence_relation,

    CalculusOntology:
      derivative_integral_and_limits,

    DifferentialEquationOntology:
      y_prime_equals_k_y,

    FinancialMathematicsOntology:
      compound_interest,

    ProbabilityOntology:
      exponential_models_in_distribution_context,

    InequalityOntology:
      solving_exponential_inequalities
  },

  TERMINATION_CONDITION: {
    ontology_complete_when: [
      exponential_function_defined,
      base_constraints_defined,
      growth_decay_classification_defined,
      domain_range_defined,
      asymptote_defined,
      inverse_relation_defined,
      solving_rules_defined,
      calculus_relations_defined,
      applied_growth_models_defined,
      error_detection_defined,
      cross_ontology_links_defined,
      recursive_coherence_verified
    ]
  }

}

EXECUTE Exponential_Function_Ontology_v1.0:

  INPUT:
    mathematical_entity_or_query

  PIPELINE:
    Parse
    -> IdentifyFunction
    -> DetectExponentialStructure
    -> ValidateBase
    -> ExtractParameters
    -> ResolveDomain
    -> ClassifyGrowthOrDecay
    -> DetermineRangeAndAsymptote
    -> AnalyseInterceptsAndLimits
    -> ConvertBetweenBaseRepresentations
    -> SolveOrInvertWhenRequested
    -> ApplyCalculusRelations
    -> VerifySemanticConsistency
    -> LinkRelatedOntologies
    -> AssignConfidence
    -> EmitSemanticResult

  OUTPUT: {
    entity,
    classification,
    canonical_form,
    parameters,
    base,
    scale,
    domain,
    range,
    growth_or_decay,
    y_intercept,
    x_intercept,
    asymptote,
    inverse,
    doubling_time,
    half_life,
    derivative,
    integral,
    limit_behaviour,
    graph_semantics,
    verification,
    ontology_relations,
    confidence,
    semantic_equivalence,
    flow_hash
  }

END FLOW Exponential_Function_Ontology_v1.0