Logarithmic Function Ontology

FLOW Logarithmic_Function_Ontology_v1.0

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

DEFINE LogarithmicFunctionOntology := {

  CORE_IDENTITY: {
    entity_type: "Mathematical Ontology",
    primary_entity: LogarithmicFunction,
    parent_entities: [Function, TranscendentalFunction, Algebra],
    related_entities: [
      ExponentialFunction,
      InverseFunction,
      Base,
      Argument,
      Domain,
      Range,
      VerticalAsymptote,
      NaturalLogarithm,
      CommonLogarithm,
      Exponent,
      Equation,
      Growth,
      Decay
    ]
  },

  DEFINITION: {
    meaning:
      "A logarithmic function gives the exponent to which a valid base must be raised to produce a positive argument.",
    canonical_form:
      f(x)=log_b(x),
    defining_equivalence:
      y=log_b(x) <=> b^y=x,
    base_constraints: [
      b>0,
      b!=1
    ],
    argument_constraint:
      x>0
  },

  SEMANTIC_PRIMITIVES: {
    Base:
      positive_nonunit_number_defining_logarithmic_scale,
    Argument:
      positive_quantity_to_which_logarithm_is_applied,
    Logarithm:
      exponent_required_to_generate_argument_from_base,
    NaturalLogarithm:
      logarithm_base_e,
    CommonLogarithm:
      logarithm_base_10,
    VerticalAsymptote:
      boundary_line_approached_as_argument_tends_to_zero_positive
  },

  FUNCTION_MODEL: {
    mapping:
      log_b: PositiveRealNumbers -> RealNumbers,
    input:
      x>0,
    output:
      real_exponent_y,
    inverse_relation:
      exponential_function_b^x
  },

  CLASSIFICATION: {

    GeneralLogarithmicFunction: {
      form:
        f(x)=log_b(x)
    },

    NaturalLogarithm: {
      notation:
        ln(x),
      base:
        e
    },

    CommonLogarithm: {
      notation:
        log_10(x),
      common_notation:
        log(x) depending_on_context
    },

    ShiftedScaledLogarithmicFunction: {
      form:
        f(x)=a*log_b(x-h)+k
    }
  },

  DOMAIN_RANGE: {
    canonical_logarithm: {
      Domain:
        (0,infinity),
      Range:
        RealNumbers
    },

    shifted_form:
      f(x)=a*log_b(x-h)+k
      -> Domain=(h,infinity)
  },

  VERTICAL_ASYMPTOTE: {
    canonical_form:
      x=0,

    shifted_form:
      x=h
      for_f(x)=a*log_b(x-h)+k
  },

  INTERCEPTS: {
    canonical_x_intercept:
      log_b(1)=0
      -> (1,0),

    canonical_y_intercept:
      none
      because_x=0_not_in_domain
  },

  MONOTONICITY: {
    IF b>1:
      strictly_increasing,

    IF 0<b<1:
      strictly_decreasing
  },

  INJECTIVITY: {
    valid_logarithmic_function:
      TRUE
  },

  SURJECTIVITY: {
    onto_RealNumbers:
      TRUE
  },

  BIJECTIVITY: {
    mapping:
      PositiveRealNumbers -> RealNumbers,
    bijective:
      TRUE
  },

  INVERSE_FUNCTION_RELATION: {
    log_b:
      inverse_of_b^x,

    identities: [
      log_b(b^x)=x,
      b^(log_b(x))=x
    ],

    conditions:
      b>0,
      b!=1,
      x>0
  },

  LOGARITHM_LAWS: {

    ProductRule:
      log_b(x*y)=log_b(x)+log_b(y),

    QuotientRule:
      log_b(x/y)=log_b(x)-log_b(y),

    PowerRule:
      log_b(x^r)=r*log_b(x),

    BaseIdentity:
      log_b(b)=1,

    UnityIdentity:
      log_b(1)=0,

    conditions:
      arguments_must_be_positive_in_real_domain
  },

  CHANGE_OF_BASE: {
    formula:
      log_b(x)=ln(x)/ln(b),

    generalized:
      log_b(x)=log_c(x)/log_c(b),

    constraints:
      b>0,
      b!=1,
      c>0,
      c!=1
  },

  NATURAL_LOGARITHM: {
    notation:
      ln(x),

    definition:
      log_e(x),

    derivative:
      d/dx ln(x)=1/x,

    integral_relation:
      integral(1/x dx)=ln|x|+C
  },

  DERIVATIVE_RELATION: {
    f(x)=log_b(x),

    derivative:
      f'(x)=1/(x*ln(b)),

    shifted_form:
      d/dx log_b(g(x))
      =
      g'(x)/(g(x)*ln(b))
  },

  SECOND_DERIVATIVE: {
    f''(x):
      -1/(x^2*ln(b))
      for_canonical_logarithm
  },

  CONCAVITY: {
    IF b>1:
      concave_down,

    IF 0<b<1:
      concave_up
  },

  LIMIT_BEHAVIOUR: {
    IF b>1:
      x->0_positive:
        log_b(x)->-infinity,
      x->infinity:
        log_b(x)->infinity,

    IF 0<b<1:
      x->0_positive:
        log_b(x)->infinity,
      x->infinity:
        log_b(x)->-infinity
  },

  TRANSFORMATIONS: {
    parent:
      y=log_b(x),

    vertical_scale:
      y=a*log_b(x),

    horizontal_shift:
      y=log_b(x-h),

    vertical_shift:
      y=log_b(x)+k,

    reflection_x_axis:
      y=-log_b(x),

    reflection_y_relationship:
      log_b(-x)
      defined_for_x<0
      when_treated_as_horizontal_reflection_of_domain
  },

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

    domain:
      x>h,

    vertical_asymptote:
      x=h,

    transformation_parameters:
      [a,h,k]
  },

  SOLVING_LOGARITHMIC_EQUATIONS: {

    SingleLog:
      log_b(g(x))=c
      -> g(x)=b^c,

    EqualLogsSameBase:
      log_b(A)=log_b(B)
      -> A=B,

    SumOfLogs:
      log_b(A)+log_b(B)=c
      -> log_b(A*B)=c,

    DifferenceOfLogs:
      log_b(A)-log_b(B)=c
      -> log_b(A/B)=c,

    final_requirement:
      verify_all_log_arguments_positive
  },

  DOMAIN_FILTERING_IN_EQUATIONS: {
    candidate_solution:
      MUST satisfy every logarithm_argument > 0,

    extraneous_solution:
      reject_if_any_log_argument_nonpositive
  },

  EXPONENTIAL_EQUATION_RELATION: {
    logarithms_used_to_solve:
      a*b^(g(x))=c,

    transform:
      g(x)=log_b(c/a),

    domain_requirement:
      c/a>0
  },

  RATE_OF_GROWTH: {
    logarithmic_growth:
      slower_than_any_positive_power_function_as_x->infinity,

    semantic_link:
      inverse_of_exponential_growth
  },

  COMPOSITION: {
    log_after_exp:
      log_b(b^x)=x,

    exp_after_log:
      b^(log_b(x))=x,

    domain_constraints:
      x>0_for_exp_after_log_identity
  },

  PARAMETER_REASONING: {
    family:
      f_(a,b,h,k)(x)=a*log_b(x-h)+k,

    parameter_a:
      vertical_scale_and_reflection,

    parameter_b:
      controls_increasing_or_decreasing_character,

    parameter_h:
      moves_vertical_asymptote,

    parameter_k:
      vertical_shift
  },

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

    base_equal_one:
      invalid_because_1^y_always_equals_1,

    nonpositive_base:
      invalid_for_standard_real_logarithm
  },

  ARGUMENT_CONSTRAINTS: {
    canonical:
      x>0,

    composite_argument:
      g(x)>0,

    multiple_logs:
      every_argument_must_be_positive
  },

  SYMBOLIC_RECOGNITION: {
    ACCEPT: [
      "f(x)=log_2(x)",
      "y=ln(x)",
      "g(t)=3log_5(t-1)+2",
      "h(x)=-ln(x+4)"
    ],

    NORMALISE_FIRST: [
      "f(x)=ln(e^x)",
      "y=log_10(100x)"
    ],

    REDIRECT_NONLOGARITHMIC: [
      "f(x)=2^x",
      "f(x)=x^2",
      "f(x)=1/x",
      "f(x)=sin(x)"
    ]
  },

  NATURAL_LANGUAGE_MAPPING: {
    "log base b of x":
      log_b(x),

    "natural logarithm":
      ln(x),

    "common logarithm":
      log_10(x),

    "what exponent gives x":
      logarithmic_semantics,

    "inverse of exponential":
      logarithmic_function
  },

  WORD_PROBLEM_REASONING: {
    PIPELINE: [
      identify_exponential_or_multiplicative_relationship,
      determine_required_unknown_exponent,
      select_logarithmic_model,
      establish_domain_constraints,
      construct_equation,
      solve,
      verify_positive_arguments,
      interpret_result
    ],

    common_contexts: [
      pH_scales,
      decibel_scales,
      earthquake_magnitude_scales,
      information_measures,
      growth_time_calculations,
      compound_interest_time_problems
    ]
  },

  SCALE_SEMANTICS: {
    logarithmic_scale:
      multiplicative_changes_in_underlying_quantity
      become_additive_changes_in_log_value,

    base_10:
      factor_of_10_change
      corresponds_to_unit_change_in_log_10
  },

  UNIT_SEMANTICS: {
    logarithm_argument:
      should_be_dimensionless
      OR normalized_by_reference_quantity,

    practical_models:
      log(Q/Q_0)
      where_Q_and_Q_0_share_units
  },

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

    NonPositiveArgument:
      argument<=0
      -> undefined_over_reals,

    ProductRuleMisuse:
      log(x+y) != log(x)+log(y),

    QuotientRuleMisuse:
      ensure_division_structure_correct,

    PowerRuleMisuse:
      require_power_applies_to_entire_positive_argument,

    ExtraneousSolution:
      candidate_violates_argument_domain
      -> reject,

    InverseConfusion:
      log_b(x)_is_not_1/b^x
      -> flag
  },

  ONTOLOGY_RELATIONS: {
    IS_A: [
      "LogarithmicFunction IS_A Function",
      "NaturalLogarithm IS_A LogarithmicFunction",
      "CommonLogarithm IS_A LogarithmicFunction"
    ],

    RELATED_TO: [
      "LogarithmicFunction RELATED_TO ExponentialFunction",
      "LogarithmicFunction RELATED_TO InverseFunction",
      "LogarithmicFunction RELATED_TO Calculus",
      "LogarithmicFunction RELATED_TO GrowthModels",
      "LogarithmicFunction RELATED_TO MeasurementScales"
    ],

    DEPENDS_ON: [
      FunctionSemantics,
      Exponentiation,
      PositiveRealNumbers,
      InverseMapping
    ]
  },

  SEMANTIC_EQUIVALENCE: {
    examples: [
      "log_b(x)=ln(x)/ln(b)",
      "y=log_b(x) <=> b^y=x"
    ],

    function_equivalence:
      same_domain
      AND same_output_for_every_input
  },

  CONFIDENCE: {
    classification_confidence:
      IF logarithmic_structure_detected
      AND base_valid
      THEN 1.0,

    domain_confidence:
      IF all_argument_constraints_resolved
      THEN 1.0,

    solution_confidence:
      IF candidate_satisfies_original_equation
      AND all_arguments_positive
      THEN 1.0
  },

  AI_CONSUMPTION: {
    tasks: [
      recognise_logarithmic_function,
      identify_base,
      identify_argument,
      infer_domain,
      infer_range,
      identify_vertical_asymptote,
      classify_increasing_or_decreasing,
      apply_logarithm_laws,
      change_base,
      solve_logarithmic_equations,
      solve_exponential_equations_using_logs,
      construct_exponential_inverse,
      differentiate,
      integrate_related_forms,
      verify_argument_constraints,
      detect_logarithm_rule_errors,
      map_natural_language,
      link_related_ontologies
    ],

    preferred_representation:
      typed_inverse_transcendental_function_graph,

    reasoning_mode:
      recursive_domain_constrained_inverse_exponentiation
  },

  RECURSIVE_REASONING: {

    FUNCTION AnalyseLogarithmicFunction(F,Context):

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

      IF not IsFunction(simplified):
        RETURN RedirectToRelationOntology

      form := DetectLogarithmicForm(simplified)

      IF form = NONE:
        RETURN RedirectToFunctionOntology

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

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

      domain := SolveArgumentConstraint(form.argument > 0)

      classification :=
        IF b>1 THEN IncreasingLogarithmicFunction
        ELSE DecreasingLogarithmicFunction

      properties := {
        domain:domain,
        range:RealNumbers,
        vertical_asymptote:x=h,
        inverse:ConstructExponentialInverse(form),
        monotonicity:classification
      }

      verified := VerifyLogarithmicProperties(form,properties)

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

  RECURSIVE_COHERENCE: {
    invariant_1:
      every_logarithm_argument_is_positive=TRUE,

    invariant_2:
      base_constraints_preserved=TRUE,

    invariant_3:
      exponential_inverse_relation_consistent=TRUE,

    invariant_4:
      vertical_asymptote_matches_argument_zero_boundary=TRUE,

    invariant_5:
      logarithm_laws_applied_only_under_valid_domain_conditions=TRUE
  },

  FLOW_HASH: {
    semantic_signature_inputs: [
      ontology_name,
      logarithmic_definition,
      base_constraints,
      argument_constraints,
      inverse_exponential_relation,
      logarithm_laws,
      verification_rules
    ],

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

  UPDATE_MODEL: {
    version: "1.0",

    immutable_constraints: [
      positive_nonunit_base,
      positive_real_argument,
      exponential_inverse_semantics,
      logarithm_laws_domain_requirements,
      full_solution_verification
    ],

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

  KNOWLEDGE_GRAPH: {
    nodes: [
      LogarithmicFunction,
      Function,
      ExponentialFunction,
      Base,
      Argument,
      Domain,
      Range,
      VerticalAsymptote,
      NaturalLogarithm,
      CommonLogarithm,
      InverseFunction
    ],

    edges: [
      LogarithmicFunction -> IS_A -> Function,
      LogarithmicFunction -> HAS_BASE -> Base,
      LogarithmicFunction -> HAS_ARGUMENT -> Argument,
      LogarithmicFunction -> HAS_DOMAIN -> Domain,
      LogarithmicFunction -> HAS_RANGE -> Range,
      LogarithmicFunction -> HAS_ASYMPTOTE -> VerticalAsymptote,
      LogarithmicFunction -> INVERSE_OF -> ExponentialFunction,
      NaturalLogarithm -> IS_A -> LogarithmicFunction,
      CommonLogarithm -> IS_A -> LogarithmicFunction
    ]
  },

  CROSS_ONTOLOGY_LINKS: {
    FunctionOntology:
      direct_parent,

    ExponentialFunctionOntology:
      inverse_relation,

    EquationOntology:
      logarithmic_equation_solving,

    InequalityOntology:
      logarithmic_inequality_and_domain_constraints,

    CalculusOntology:
      derivative_integral_and_limits,

    MeasurementOntology:
      logarithmic_scales,

    FinancialMathematicsOntology:
      solving_growth_time,

    InformationTheoryOntology:
      logarithmic_information_measures
  },

  TERMINATION_CONDITION: {
    ontology_complete_when: [
      logarithmic_function_defined,
      base_constraints_defined,
      argument_constraints_defined,
      domain_range_defined,
      inverse_relation_defined,
      logarithm_laws_defined,
      solving_rules_defined,
      asymptote_and_graph_semantics_defined,
      error_detection_defined,
      cross_ontology_links_defined,
      recursive_coherence_verified
    ]
  }

}

EXECUTE Logarithmic_Function_Ontology_v1.0:

  INPUT:
    mathematical_entity_or_query

  PIPELINE:
    Parse
    -> IdentifyFunction
    -> DetectLogarithmicStructure
    -> ValidateBase
    -> ExtractArgumentAndParameters
    -> ResolveArgumentDomain
    -> ClassifyMonotonicity
    -> DetermineRangeAndAsymptote
    -> ApplyLogarithmLawsWhenRequired
    -> SolveOrInvertWhenRequested
    -> VerifyAllArgumentConstraints
    -> ApplyCalculusRelations
    -> LinkRelatedOntologies
    -> AssignConfidence
    -> EmitSemanticResult

  OUTPUT: {
    entity,
    classification,
    canonical_form,
    parameters,
    base,
    argument,
    domain,
    range,
    x_intercept,
    y_intercept,
    vertical_asymptote,
    monotonicity,
    inverse,
    derivative,
    limit_behaviour,
    transformations,
    verification,
    ontology_relations,
    confidence,
    semantic_equivalence,
    flow_hash
  }

END FLOW Logarithmic_Function_Ontology_v1.0