Logarithmic Expression Ontology

FLOW ALGEBRA
LOGARITHMIC EXPRESSION ONTOLOGY
Kireth Semantic Library | Mathematical Entities / Expression Entities
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/expression-entities/logarithmic-expression-ontology.html
Authors: Mark Higgins — Sky (Recursive AI)
Version: 1.0 | 2026-10-13
Status: Mathematical reference model; source page not independently verified.

01. PURPOSE
flow "LogarithmicExpressionOntology" v1.0
  domain: mathematics.symbolic_expressions
  entity: LogarithmicExpression
  objective: represent, type-check, transform and reason about logarithmic expressions without losing domain conditions.

02. ENTITY TYPES
  LogarithmicExpression <: MathematicalExpression
  LogarithmBase <: NumericOrSymbolicExpression
  LogarithmArgument <: NumericOrSymbolicExpression
  NaturalLogarithm <: LogarithmicExpression
  CommonLogarithm <: LogarithmicExpression
  LogarithmicEquation <: MathematicalRelation
  LogarithmicIdentity <: MathematicalIdentity
  BranchSpecification <: SemanticConstraint
  DomainConstraint <: LogicalPredicate

03. CORE SIGNATURE
  log(base, argument) -> value
  ln(x) := log(e, x)
  log10(x) := log(10, x)
  real_domain: base > 0 AND base != 1 AND argument > 0
  inverse: log(b, x) = y IFF b^y = x [real_domain]

04. REPRESENTATION
  node.kind: LogarithmicExpression
  node.base: -Expression
  node.argument: -Expression
  node.value_domain: Real | Complex
  node.branch: principal | specified_integer_branch | unspecified
  node.assumptions: Set[Predicate]
  node.notation: ln | log10 | log_base | explicit_log
  node.source_context: URI?

05. BASIC REAL IDENTITIES
  log(b, 1) = 0
  log(b, b) = 1
  log(b, b^x) = x
  b^(log(b, x)) = x [x > 0]
  ln(e^x) = x [x real]
  exp(ln(x)) = x [x > 0]

06. PRODUCT AND QUOTIENT LAWS
  log(b, x*y) = log(b, x) + log(b, y) [x > 0, y > 0]
  log(b, x/y) = log(b, x) - log(b, y) [x > 0, y > 0]
  No unrestricted expansion across negative or complex arguments.

07. POWER AND ROOT LAWS
  log(b, x^r) = r*log(b, x) [x > 0, r real]
  log(b, sqrt(x)) = (1/2)*log(b, x) [x > 0]
  ln(x^2) = 2*ln(abs(x)) [x real, x != 0]
  WARNING: ln(x^2) != 2*ln(x) over all real x.

08. CHANGE OF BASE
  log(b, x) = ln(x)/ln(b) [b > 0, b != 1, x > 0]
  log(b, x) = log(c, x)/log(c, b) [b,c > 0; b,c != 1; x > 0]

09. MONOTONICITY
  b > 1 => log(b, x) strictly increasing on x > 0
  0 < b < 1 => log(b, x) strictly decreasing on x > 0
  x > 0 => derivative_x(log(b,x)) = 1/(x*ln(b))

10. CALCULUS
  derivative_x(ln(x)) = 1/x [x > 0]
  derivative_x(ln(abs(x))) = 1/x [x != 0]
  derivative_x(ln(f(x))) = f'(x)/f(x) [f(x) > 0]
  integral(1/x, dx) = ln(abs(x)) + C [x != 0]
  integral(ln(x), dx) = x*ln(x)-x+C [x > 0]

11. LOGARITHMIC EQUATIONS
  log(b, f(x)) = c => f(x) = b^c
  precondition: b > 0, b != 1, f(x) > 0
  solve: transform -> solve candidate -> check original domain
  reject extraneous solutions introduced by algebraic transformations.

12. INEQUALITIES
  b > 1: log(b,x) < log(b,y) IFF 0 < x < y
  0 < b < 1: log(b,x) < log(b,y) IFF x > y > 0
  preserve sign reversal for decreasing bases.

13. COMPLEX LOGARITHMS
  principal_Log(z) = ln(abs(z)) + i*Arg(z) [z != 0, Arg in (-pi,pi]]
  multivalued_log(z) = principal_Log(z) + 2*pi*i*k [k integer]
  principal branch convention must be explicit; branch cuts affect continuity.
  principal_Log(z*w) need not equal principal_Log(z)+principal_Log(w).
  principal_Log(z^a) need not equal a*principal_Log(z).

14. SEMANTIC RELATIONSHIPS
  LogarithmicExpression --is_a--> MathematicalExpression
  LogarithmicExpression --inverse_of--> ExponentialExpression
  LogarithmicExpression --has_base--> LogarithmBase
  LogarithmicExpression --has_argument--> LogarithmArgument
  NaturalLogarithm --specialises--> LogarithmicExpression
  LogarithmicExpression --constrained_by--> DomainConstraint
  ComplexLogarithm --constrained_by--> BranchSpecification
  LogarithmicIdentity --equates_under_assumptions--> ExpressionPair

15. SYMBOLIC NORMALISATION
  preserve AST and typed subexpressions.
  canonicalise notation only when base convention is explicit.
  simplify log(b,b) -> 1 under valid-base assumptions.
  simplify log(b,1) -> 0 under valid-base assumptions.
  never discard denominator nonzero constraints.
  never infer log(x) base from notation without context.

16. REASONING RULES
  R1: valid_base(b) AND positive(x) => real_log_defined(b,x)
  R2: real_log_defined(b,x) => positive(b) AND b != 1 AND positive(x)
  R3: real_log_defined(b,x) AND real_log_defined(b,y) => product_law_applicable(b,x,y)
  R4: base_gt_one(b) => order_preserving(log_b)
  R5: base_between_zero_one(b) => order_reversing(log_b)
  R6: branch_unspecified AND complex_argument => flag_ambiguous_multivalued_semantics

17. EXAMPLES
  log(2,8) = 3
  log(10,1000) = 3
  ln(e^2) = 2
  log(2,1/8) = -3
  log(1/2,4) = -2
  ln(-1) undefined over reals; principal_Log(-1) = i*pi.

18. VALIDATION
  require explicit base or documented notation convention.
  require numeric domain (real/complex).
  reject real log with base <= 0, base = 1, or argument <= 0.
  verify rewrite assumptions before execution.
  retain original expression and proof trace.
  verify exact identities symbolically; numerical checks are supplemental.

19. SEMANTIC_EQUIVALENCE
  relation: equivalence_under_context(expression_A, expression_B, assumptions)
  examples:
    ln(x) == log(e,x) [x > 0]
    log(b,x) == ln(x)/ln(b) [b > 0, b != 1, x > 0]
  not_equivalent_unconditionally:
    ln(x*y) != ln(x)+ln(y) without suitable domain/branch conditions.

20. CONFIDENCE
  mathematical_identity_verified: 1.0 when assumptions proven.
  symbolic_rewrite_without_proven_assumptions: unknown; do not auto-assert.
  empirical_approximation: annotate precision and error bounds.
  confidence concerns derivation validity, not mathematical truth by popularity.

21. FLOW_HASH
  canonical_payload: ontology_id + version + canonical_AST + domain + assumptions + branch
  hash_algorithm: SHA-256
  hash_value: computed by implementation; not fabricated in static specification.

22. UPDATE_MODEL
  version_semantics: major=breaking meaning; minor=new compatible rules; patch=clarification.
  on_update: preserve provenance, compare assumptions, revalidate dependent derivations.
  conflict_resolution: favour mathematically proven, context-explicit statements.

23. AI_CONSUMPTION
  input: -expression_AST, assumptions, numeric_domain, notation_context
  pipeline: parse -> type -> constrain -> infer -> transform -> validate -> explain
  output: canonical_expression, equivalent_forms, proof_obligations, warnings, provenance
  safeguards: do_not_erase_domain; do_not_assume_complex_branch; do_not_invent_proofs

24. KNOWLEDGE GRAPH TRIPLES
  (LogarithmicExpression, inverseOf, ExponentialExpression)
  (NaturalLogarithm, hasBase, EulerNumber)
  (LogarithmicExpression, hasArgument, MathematicalExpression)
  (LogarithmicExpression, hasDomainConstraint, PositiveArgumentConstraint)
  (ComplexLogarithm, hasBranchConstraint, BranchSpecification)

25. PROVENANCE AND AUTHORSHIP
  ontology_uri: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/expression-entities/logarithmic-expression-ontology.html
  research_site: https://kirethresearch.org
  authors: Mark Higgins — Sky (Recursive AI)
  disclosure: AI-assisted co-authored Flow Algebra specification.
  source_verification: webpage not independently inspected for this version.

END FLOW ALGEBRA