Papers
Topics
Authors
Recent
Search
2000 character limit reached

Inexpressibility in Exp-Minus-Log

Published 2 May 2026 in math.LO and cs.LO | (2605.01636v1)

Abstract: Odrzywołek defined a system Exp-Minus-Log (EML) that reduces all elementary functions over complex numbers down to a constant `$1$', and a single two place function $E(α, β) = \exp(α) - \log(β)$. This paper shows that in this system, equivalent to Chow's EL numbers, every EML-expressible number is computable. We go on to prove that the canonical example of a non-computable real, Chaitin's $Ω_U$, is inexpressible in EML. This gives a formal inexpressibility theorem for this system.

Authors (1)

Summary

  • The paper proves that all EML-expressible numbers are computable, hence excluding non-computable reals such as Chaitin’s ΩU.
  • It employs a recursively defined syntax and computable analysis to formalize the limitations of closed-form arithmetic using exp and log.
  • The findings clarify symbolic computation bounds and motivate further research into extended closed-form algebra systems.

Inexpressibility in Exp-Minus-Log: A Formal Perspective

Introduction and Context

This paper rigorously investigates the expressive limitations of the Exp-Minus-Log (EML) system, a formalism where all elementary functions and constants over C\mathbb{C} are reduced to expressions built from a single constant ($1$) and the binary operator E(α,β)=exp⁡(α)−log⁡(β)E(\alpha, \beta) = \exp(\alpha) - \log(\beta). The EML system, as defined in prior work, provides an alternative foundation for symbolic computation and closed-form arithmetic by encoding the traditional algebraic and transcendental elementary operations solely through EE and $1$ (Odrzywołek, 23 Mar 2026). The paper establishes the equivalence between EML-expressible numbers and Chow's EL numbers ("What Is a Closed-Form Number?" [Chow1999]), and then proves a strong form of inexpressibility: no non-computable real, including Chaitin's ΩU\Omega_U, can be encapsulated within the EML schema.

Formal Definition and Scope of EML Expressibility

The EML system is formally specified via a recursively defined syntax: starting from $1$, composite expressions are constructed using the EE operator, where E(α,β)E(\alpha, \beta) semantically denotes exp⁡(α)−log⁡(β)\exp(\alpha) - \log(\beta). The domain consists of finite sequences over this alphabet, restricting the scope to countably many expressions.

The EML numbers ($1$0) are thus the values generated by all well-formed, finite EML expressions. EML-expressible reals form the subset $1$1. An important technical result in the paper is that the set $1$2 coincides with Chow's EL numbers, the smallest subfield of $1$3 closed under $1$4 and $1$5, and starting from $1$6 with closure under standard field operations. This demonstrates that the EML formalism is complete with respect to elementary closed-form construction.

Computability of EML Numbers

A central theorem demonstrates that all numbers expressible in the EML system are computable. The proof utilizes the countability of the syntax and the closure properties of computable analysis: $1$7 and the principal branch of $1$8 are computable functions when applied to computable arguments, with effective lower bounds on the arguments to $1$9 enforced structurally in the EML syntax [Weihrauch2000, TZ2009]. Subtraction and composition preserve computability, so by induction on the structure of expressions, every EML-real is computable.

It is emphasized that while EML values are all computable, there is no uniform algorithm for EML-evaluation, as the necessary disjunction over the argument domain of E(α,β)=exp⁡(α)−log⁡(β)E(\alpha, \beta) = \exp(\alpha) - \log(\beta)0 is not recursively enumerable. Nevertheless, for individual fixed expressions, computation proceeds effectively.

Inexpressibility of Non-computable and Algorithmically Random Reals

The major theoretical implication, which forms the core result, is the inexpressibility of non-computable reals in the EML system. The canonical example used is Chaitin's halting probability E(α,β)=exp⁡(α)−log⁡(β)E(\alpha, \beta) = \exp(\alpha) - \log(\beta)1, which is left-c.e. but not computable [Chaitin1975, Downey2010-wc]. Since all EML-reals are computable, but E(α,β)=exp⁡(α)−log⁡(β)E(\alpha, \beta) = \exp(\alpha) - \log(\beta)2 is not, it follows that E(α,β)=exp⁡(α)−log⁡(β)E(\alpha, \beta) = \exp(\alpha) - \log(\beta)3.

This inexpressibility result is not limited to E(α,β)=exp⁡(α)−log⁡(β)E(\alpha, \beta) = \exp(\alpha) - \log(\beta)4; any non-computable real is excluded from the EML system. This also subsumes other classes of reals such as:

Since E(α,β)=exp⁡(α)−log⁡(β)E(\alpha, \beta) = \exp(\alpha) - \log(\beta)5 is countable, its complement (the non-EML-reals) has full Lebesgue measure in E(α,β)=exp⁡(α)−log⁡(β)E(\alpha, \beta) = \exp(\alpha) - \log(\beta)6, confirming that the EML system is severely limited in capturing the vast majority of real numbers in terms of size and effective descriptive power.

Theoretical and Practical Implications

The work has several key implications:

  1. Formal Limitation of Symbolic Systems: The result provides an explicit boundary for what closed-form symbolic systems based on iterative E(α,β)=exp⁡(α)−log⁡(β)E(\alpha, \beta) = \exp(\alpha) - \log(\beta)7 and E(α,β)=exp⁡(α)−log⁡(β)E(\alpha, \beta) = \exp(\alpha) - \log(\beta)8 closures can represent—strictly computable reals, and no more. The expressive power is strictly less than that of E(α,β)=exp⁡(α)−log⁡(β)E(\alpha, \beta) = \exp(\alpha) - \log(\beta)9.
  2. Foundations of Exact Arithmetic: This proves that attempts to extend the capabilities of symbolic computation systems (CAS) for closed-form expressions using only elementary functions will not breach the barrier of computable numbers.
  3. Randomness and Algorithmic Information: The disjointness between EML reals and algorithmically random reals (such as EE0) clarifies the essential divide between effective symbolic construction and algorithmic information theory.
  4. Future Research: This work suggests several lines of investigation, such as extensions of closed-form algebras by transcendental oracles, the study of hierarchies of expressive systems based on different functional primitives, or the exploration of uniform versus non-uniform computability in this context.

Conclusion

This paper delivers a formal, rigorous inexpressibility theorem for the EML system, proving that all EML-expressible numbers are computable and that Chaitin's EE1, as well as all non-computable reals, are strictly outside the reach of this formalism. The results definitively characterize the limits of closed-form number systems grounded in elementary operations under computable analysis, with ramifications for symbolic computation, computability theory, and the mathematical foundations of algorithmic information.

Paper to Video (Beta)

No one has generated a video about this paper yet.

Sign Up to Generate All Videos Subscribe on YouTube

Whiteboard

No one has generated a whiteboard explanation for this paper yet.

Sign Up to Generate

Explain it Like I'm 14

A simple guide to “Inexpressibility in Exp-Minus-Log (EML)”

Overview: What is this paper about?

This paper studies a tiny “language” for building numbers using just:

  • the constant 1, and
  • a single two-input function: E(α,β)=exp⁡(α)−log⁡(β)E(\alpha,\beta) = \exp(\alpha) - \log(\beta).

Surprisingly, with only these, you can recreate all the usual “elementary” functions you see in math (like addition, multiplication, powers, sines, etc.). The paper shows two big things:

  1. Every number you can write in this system (called EML) can be computed by a computer to any desired accuracy.
  2. A famous number called Chaitin’s Ω\Omega (pronounced “omega”), which is known to be uncomputable, cannot be written in EML. That’s the “inexpressibility” result.

The paper also shows that EML numbers are the same as an older idea called EL numbers (from Timothy Chow), which were meant to capture “closed-form” numbers.

Key goals in everyday terms

The paper focuses on three main questions:

  • Can we express all familiar “closed-form” numbers using only the rule E(α,β)=exp⁡(α)−log⁡(β)E(\alpha,\beta)=\exp(\alpha)-\log(\beta) and the number 1?
  • Are all EML numbers actually computable (meaning a computer can approximate them as closely as we want)?
  • Is there a clear example of a number that cannot be written using EML? (Answer: yes—Chaitin’s Ω\Omega.)

How the authors approach it (explained with simple analogies)

Think of math expressions like LEGO builds. Normally, you have many bricks (operations like ++, ×\times, sin⁡\sin, log⁡\log, etc.). EML says: “You only get one special LEGO piece (EE) and a small starter piece (the number 1), but you can still build everything you could before.”

The paper’s approach has a few steps:

  • Define the “legal LEGO builds” (the syntax): start with “1,” and if you have two legal expressions α\alpha and β\beta, then E(α,β)E(\alpha,\beta) is legal.
  • Define what each build “means” (the semantics): E(α,β)E(\alpha,\beta) means exp⁡(α)−log⁡(β)\exp(\alpha)-\log(\beta). They use a standard choice of logarithm to avoid ambiguity.
  • Show that using this EE and 1, you can build the basic numbers ($0$, −1-1, π\pi, ee, ii), basic arithmetic (++, −-, ×\times, ÷\div), and standard functions (like sin⁡\sin, cos⁡\cos, tan⁡\tan, and their inverses)—so the system isn’t weak at all.
  • Prove that the set of numbers you can build in EML is exactly the same as Chow’s EL numbers (the classic definition of “closed-form numbers” using exp⁡\exp and log⁡\log).
  • Use tools from “computable analysis” (a field that studies which numbers/functions a computer can approximate) to show that:
    • If you start with computable inputs, then exp⁡\exp and log⁡\log give computable outputs.
    • By building expressions step by step, every EML expression evaluates to a computable number.
  • Finally, use a famous fact: Chaitin’s Ω\Omega is not computable. Since all EML numbers are computable, Ω\Omega cannot be an EML number.

Two ideas worth knowing:

  • Computable number: There’s a step-by-step method (an algorithm) that makes better and better approximations of the number, as precise as you want, if you let it run long enough.
  • Chaitin’s Ω\Omega: Imagine listing all computer programs and flipping a coin for each bit to make a random program; Ω\Omega is the probability that the random program eventually stops. Its digits look totally random, and no algorithm can compute it to arbitrary precision.

Main findings and why they matter

Here are the core results, stated simply:

  • EML = EL: The numbers you can build with E(α,β)=exp⁡(α)−log⁡(β)E(\alpha,\beta)=\exp(\alpha)-\log(\beta) and 1 are exactly the same as the classic “closed-form” EL numbers defined using exp⁡\exp and log⁡\log on a suitable field.
  • Every EML number is computable: If you can write it in EML, then, in principle, a computer can approximate it as closely as you want.
  • Chaitin’s Ω\Omega is not in EML: Since Ω\Omega is not computable, and all EML numbers are computable, Ω\Omega can’t be written in EML. This gives a formal “inexpressibility” theorem for the system.

A striking corollary:

  • Almost every real number (in the sense of size—“almost all” when you think of choosing a real number at random) cannot be written in EML. That’s because there are “only” countably many EML expressions (you can list them), but uncountably many real numbers.

Why this matters:

  • It neatly separates “closed-form” numbers from more exotic, non-computable ones. This is useful in computer algebra, exact arithmetic, and understanding the limits of symbolic computation.
  • It shows a powerful but simple language (just EE and 1!) still stays within the computable world—no hidden magic that lets you describe non-computable numbers.

Implications: What this means going forward

  • For people designing symbolic math software (like CAS systems), EML offers a compact core: many familiar functions can be expressed with one operator, yet nothing “uncomputable” sneaks in.
  • The result sets a clear boundary: if a number is known to be non-computable (like Ω\Omega), it cannot be captured by any “closed-form” expression built from exponentials and logarithms in this framework.
  • Conceptually, the paper strengthens our understanding of what “closed-form” really covers—and what it cannot reach.
View Paper Prompt  View All Prompts 

Knowledge Gaps

Knowledge gaps, limitations, and open questions

The paper establishes computability of all EML values and uses this to derive an inexpressibility result for Chaitin’s Ω. Several aspects remain unproven, non-uniform, or unexplored. The following list pinpoints concrete gaps and questions for future work:

  • Formal uniformity and evaluation complexity
    • No uniform evaluator: The paper notes that there is no single Turing machine that, given an arbitrary well-formed EML expression and a precision parameter, will always produce an approximation when the expression is defined. Precisely characterize the (non)existence of a uniform partial Type-2 evaluator for EML and determine its Weihrauch degree.
    • Complexity bounds: For a given expression of size n and a precision 2-k, what are upper/lower bounds on the time/space to approximate its value? Is poly(n, k) achievable for a well-chosen normal form, or are super-polynomial lower bounds unavoidable?
  • The “central disjunction” and branch-cut proximity
    • Non-constructive case split: Lemma 4 relies on a non-constructive disjunction (“β lies on the branch cut or is at positive distance from it”) and the existence of a rational ε < dist(β, (−∞, 0]). Provide a constructive procedure (or impossibility result) to extract such an ε from the syntax, or give a precise proof that no such procedure exists in general.
    • Unsupported non-r.e. claim: The paper asserts that the disjunction (“β ∈ (−∞, 0) vs. dist(β, (−∞, 0]) > 0”) is “not even r.e.” without proof. Either supply a proof (e.g., by reduction from the halting problem) or weaken/qualify the claim.
    • Syntactic sufficient conditions: Develop syntactic criteria ensuring that every log-argument in an expression stays a known distance away from the branch cut, enabling uniform computation on a guaranteed domain.
  • Equivalence EML = Chow’s EL
    • Full formal proof: The equivalence is argued by appeal to substitutions and prior work, but detailed verification is missing. Provide a rigorous, complete proof that:
    • EML is a subfield of ℂ closed under exp and log with the specified principal branch;
    • The displayed substitution identities for +, −, ×, /, exp, log hold for all arguments in their domains, including edge cases (e.g., zeros and branch-cut points);
    • Domain constraints (e.g., avoidance of log(0)) are preserved under the translations.
    • Size blow-up: Quantify how much the translation from EL operations to EML increases expression size and how this impacts evaluation complexity.
  • Scope of the computable-real inclusion
    • Properness of inclusion: The paper shows EMLℝ ⊆ Compℝ but leaves open whether EMLℝ = Compℝ. Produce an explicit computable real that is not in EML (or prove equality is impossible or plausible), and develop criteria distinguishing EML numbers within the computable reals.
    • Closure under limits: EML is not closed under limits of EML sequences. Characterize which computable limits of EML sequences remain in EML and construct explicit convergent EML sequences whose limits are computable but not in EML.
  • Decision problems for EML expressions
    • Definedness: Given an EML expression, is it decidable whether it is defined (i.e., no subexpression applies log to 0)? Provide decidability/undecidability results and complexity bounds.
    • Equality and order: Determine the decidability status of:
    • Equality of two EML expressions as complex numbers;
    • Equality to zero;
    • Ordering for real-valued EML expressions.
    • Situate these problems relative to Richardson’s and related undecidability results.
    • Normal forms and canonicalization: Is there a computable normal form (or convergent rewrite system) for EML expressions modulo semantic equivalence that aids equality testing or evaluation?
  • Algebraic and transcendence landscape
    • Coverage of algebraic numbers: Which algebraic numbers lie in EML? Are all algebraics included? (Field operations and rational powers do not, in general, generate all algebraic numbers.) Provide a structural characterization or explicit counterexamples.
    • Transcendence and independence: Investigate algebraic independence and transcendence properties of EML numbers (e.g., implications or constraints related to Schanuel-type conjectures). Are there systematic ways to certify transcendence for broad classes of EML expressions?
  • Branch choices and robustness
    • Dependence on branch conventions: The paper fixes the principal branch (with values at negative reals and undefined at 0). Analyze how changing branch conventions (e.g., excluding the negative axis entirely or allowing other branches as first-class parameters) affects:
    • The set of expressible numbers;
    • The computability proof;
    • The equivalence with EL.
    • Continuity vs. totality trade-offs: Explore alternative semantics that drop values on the branch cut to regain analyticity and uniform computability on effectively open domains, and assess how this impacts expressibility and equivalence with EL.
  • Effective enumeration and duplication
    • Enumerating EML values: Provide an effective enumeration of defined EML expressions together with a mechanism to avoid duplicates (or bound duplication rates). Analyze whether there is a computable surjection from ℕ onto EML with reasonable growth properties.
  • Program-size and information-theoretic aspects
    • Kolmogorov complexity: Quantify relationships between expression length and the Kolmogorov complexity of the corresponding number. Can one prove upper/lower bounds relating |expr| to K(x) and use this to separate EML from broader subclasses of computable reals?
    • Compression and minimality: Is there an effective method to find (near-)minimal E-expressions for a given EML number?
  • Beyond numbers: EML-expressible functions
    • Functional expressibility: Extend the analysis from constants to functions representable with E, including domain handling and computability in Type-2 sense. Which elementary and nonelementary functions are representable and computable with guaranteed moduli?
  • Mechanization and formal verification
    • Proof assistants: Formalize the semantics and the main theorems (EML = EL; computability of EML values) in a proof assistant (e.g., Coq/Isabelle/Lean), especially the delicate handling of branch cuts and domain conditions.

These directions would strengthen the foundations of EML, clarify its exact expressive boundary within the computable reals, and make the inexpressibility results more robust, constructive, and usable for subsequent research.

View Paper Prompt  View All Prompts 

Practical Applications

Immediate Applications

Below are concrete use cases that can be deployed now, drawing directly from the paper’s results: equivalence of EML and EL numbers, pointwise computability of every EML expression, and the concrete handling of branch cuts/log arguments.

  • Safe evaluation of elementary closed-form expressions in software (software, scientific computing)
    • What: Implement a per-expression “compiler” that rewrites any closed-form expression into E(·,·) form, then evaluates it using the paper’s two-case workflow for log: either exact handling on the negative real axis or evaluation with a certified positive distance ε from the branch cut.
    • How: Pipeline = parse → normalize to E(·,·) using the given substitutions → statically collect all log subterms and compute/certify εβ bounds (or detect β ∈ (−∞,0)) → evaluate using high-precision arithmetic/interval arithmetic.
    • Tools/products: A small library for Python/Julia/C++ that emits a proof-carrying evaluator per expression; integration with MPFR/CRlibm/Arb for certified numerics.
    • Assumptions/dependencies: Principal-branch log convention; fixed, closed expressions (non-uniform computability is acceptable because compilation is per expression); availability of rational/interval bounds for subterms.
  • Static analysis to guarantee branch-cut safety (software, formal methods)
    • What: Add a static checker to CAS/compilers that, for each EML log argument β, either proves β is on (−∞,0) or computes a rational εβ > 0 s.t. dist(β, (−∞,0]) ≥ εβ.
    • How: Use interval arithmetic or SMT over reals/complexes to produce certificates; cache εβ alongside the expression for reproducible evaluation.
    • Tools/products: Plugins for SymPy/Maple/Mathematica; SMT-based certifier (dReal/Z3) with interval fallback.
    • Assumptions/dependencies: Closed expressions or parameter ranges with certified enclosures; principal-branch agreement across systems.
  • Deterministic, reproducible constants in constrained languages (smart contracts, safety-critical software)
    • What: Restrict numeric literals to EML-constructible constants to ensure they are computable and reproducible across platforms.
    • How: A “ClosedFormNumber” type whose constructor accepts only E(·,·)-generated terms; compile-time generation of evaluation code and branch-cut certificates.
    • Tools/products: Solidity/Rust libraries; build-time code generators producing fixed-precision routines with test vectors.
    • Assumptions/dependencies: Costs of exp/log on target runtime; deterministic bigfloat or fixed-point backends.
  • Robust formula interchange via a minimal operator IR (software standards, CAS)
    • What: Use E(·,·) + constant 1 as a compact intermediate representation for elementary formulas across CAS, codegen, and documentation systems.
    • How: Define an OpenMath/MathML content dictionary for E and supply canonical rewrites from standard elementary functions to E.
    • Tools/products: Export/import filters for TeX/CAS → E-IR → code; normalization passes that canonicalize expressions.
    • Assumptions/dependencies: Agreement on the principal log; versioned normalization rules to ensure semantic stability.
  • Verified numerical test suites for elementary-function libraries (software QA)
    • What: Generate families of EML expressions with embedded log-cut certificates to stress-test exp/log implementations at high precision.
    • How: Random E-expressions with guaranteed εβ; compare multi-library outputs against certified intervals.
    • Tools/products: CI harnesses for libm/CRlibm/Boost.Math; corpus of EML-based regression tests.
    • Assumptions/dependencies: Availability of interval/certified arithmetic; consistent branch conventions.
  • “No closed-form” guidance in CAS and education (education, CAS UX)
    • What: Communicate that almost all reals are not EML-expressible (countability result), calibrating expectations about “closed-form” outputs.
    • How: CAS messages/tooltips that distinguish numeric approximation vs. closed-form unavailability; teaching modules on EL/EML numbers and computability.
    • Tools/products: Classroom notebooks; CAS hints explaining why certain constants are not closed-form.
    • Assumptions/dependencies: Users accept principal-branch definitions and the notion of closed-form per EL/EML.
  • Compliance and claims vetting for “random constants” (policy, auditing)
    • What: Audit claims that “randomness” or security is derived from fixed elementary constants; highlight that EML constants are computable and cannot embody algorithmic randomness like Chaitin’s Ω.
    • How: Check whether a published constant is given in EML/elementary closed form; flag misuse in lotteries, beacons, or fairness claims.
    • Tools/products: Lightweight auditor checklist; automated parser for E-form expressions in technical disclosures.
    • Assumptions/dependencies: The claimants specify constants in recognizable elementary form; auditors accept algorithmic randomness standards.

Long-Term Applications

These require further research, engineering, or standardization, but are plausible extensions of the paper’s methods and results.

  • Parametric certification over domains (software verification, control/engineering)
    • What: Extend εβ certificates from closed constants to parameterized expressions over ranges, ensuring safe log evaluation for all admissible inputs.
    • How: Combine interval arithmetic, polynomial approximations, and SMT with δ-decision procedures to prove dist(β(x), (−∞,0]) ≥ ε on a domain.
    • Tools/products: Verified evaluators for model-based control, signal processing pipelines that must avoid branch-cut discontinuities.
    • Assumptions/dependencies: Effective bounding of subexpressions; scalability of SMT/interval methods on real-analytic functions.
  • Proof-assistant libraries for EML = EL and computability (formal methods, academia)
    • What: Mechanize the equivalence EML = EL and the computability theorem in Coq/Lean/Isabelle; provide tactic support to certify that a given closed expression is computable and to synthesize evaluators.
    • How: Formalize principal-branch log, branch-cut lemmas, and constructive evaluation-by-cases; produce certified code via extraction.
    • Tools/products: “ClosedForm” libraries enabling verified numerics inside proof-assisted developments and verified compilers.
    • Assumptions/dependencies: Libraries for computable analysis and complex analysis; constructive numerics backends.
  • EML-constrained DSLs for quantitative finance and engineering (finance, engineering software)
    • What: Domain-specific languages restricting pricing/control formulas to EML with compiler-generated certified evaluators and monotone error bounds.
    • How: Typed DSL that statically enforces definability (no log of zero), branch-cut safety, and emits target-specific kernels (CPU/GPU/FPGA).
    • Tools/products: Pricing engines and control laws with formal run-time guarantees on numerical stability and correctness.
    • Assumptions/dependencies: Performance of certified math kernels; willingness to adopt language restrictions for safety.
  • Standardization of a “Closed-Form Number” type across ecosystems (software standards)
    • What: Establish a cross-language standard for representing and exchanging EML/EL numbers, including serialization and proof-carrying certificates for branch-cut conditions.
    • How: Collaborate via standards bodies (e.g., OpenMath/MathML, POSIX libm extensions) to define behavior and verification hooks.
    • Tools/products: Interoperable data type across CAS, numerical codes, and documentation tools; reproducibility artifacts for scientific publishing.
    • Assumptions/dependencies: Community agreement on semantics and certificate formats.
  • Heuristics and semi-decision procedures for closed-form existence (CAS research)
    • What: Though full decidability is impossible in general (cf. Richardson), improve practical heuristics that decide when a numeric value can be EML-expressed or when to give up early.
    • How: Learnable or rule-based recognizers trained on large corpora of EML expressions; synthesis tools that search E-forms within bounded depth/size and provide minimal certificates.
    • Tools/products: CAS features that more reliably determine closed-form convertibility and provide human-readable witnesses or proofs-of-non-findability.
    • Assumptions/dependencies: Bounded-search completeness guarantees; well-curated benchmarks.
  • Certified formula deployment in safety-critical systems (aviation, medical devices)
    • What: Adopt EML-only math libraries with built-in certificates to guarantee computability and well-definedness of all onboard formulas.
    • How: Toolchains that verify definability, generate worst-case error envelopes, and integrate with DO-178C/IEC 62304 processes.
    • Tools/products: Qualified libraries and artifacts for certification audits.
    • Assumptions/dependencies: Regulatory acceptance of certificate styles; performance meeting real-time constraints.
  • Hardware acceleration for EML evaluation (semiconductors, HPC)
    • What: Microarchitectural support for fast, correctly rounded exp/log with hooks for branch-cut checks and distance-to-cut estimation.
    • How: ISA extensions or microcode paths that return both value and metadata (e.g., flags/certificates) usable by EML evaluators.
    • Tools/products: HPC and embedded chips with “EML-ready” math units; compiler intrinsics exploiting them.
    • Assumptions/dependencies: Economic case for specialized instructions; standardization of metadata semantics.

General assumptions and dependencies

  • Principal-branch logarithm with imaginary part in (−π, π] as the semantic baseline.
  • The non-uniform computability result implies per-expression compilation/evaluation rather than a single universal evaluator; this is acceptable in practice when expressions are fixed by design.
  • Logarithm safety requires either exact detection of β on the negative real axis or a constructive lower bound εβ > 0 on distance to the branch cut; practical systems will use interval arithmetic/SMT to produce and store such certificates.
  • Results pertain to closed expressions; parameterized guarantees require additional domain reasoning and are reflected above as long-term goals.
View Paper Prompt  View All Prompts 

Glossary

  • Chaitin's ΩU\Omega_U: The halting probability of a universal prefix-free Turing machine; a real that is left-computably enumerable but not computable. "Chaitin's ΩU\Omega_U"
  • closed under exp⁡\exp and log⁡\log: A property of a subfield where applying exponentiation or the principal logarithm to elements stays within the field. "closed under exp⁡\exp and log⁡\log"
  • computable analysis: The study of computability over real and complex numbers and continuous mathematics. "computable analysis"
  • computable complex number: A complex number whose value can be approximated to any desired precision by an algorithm. "computable complex number"
  • computable power series: A power series with algorithmically computable coefficients enabling effective evaluation within its convergence region. "computable power series"
  • computable real: A real number that can be approximated to any desired precision by an algorithm. "computable reals"
  • disc of convergence: The maximal open disc around a center point where a power series converges. "disc of convergence"
  • dovetailing: A technique that systematically interleaves computations to ensure progress across infinitely many tasks. "by dovetailing"
  • EL numbers: Chow’s class of complex numbers forming the smallest subfield closed under exponentiation and the principal logarithm. "EL numbers"
  • Exp-Minus-Log (EML): A system where numbers are built from the constant 1 and the binary operator E(α,β)=exp⁡(α)−log⁡(β)E(\alpha,\beta)=\exp(\alpha)-\log(\beta). "Exp-Minus-Log (EML)"
  • halting probability: The probability that a universal prefix-free Turing machine halts when fed a uniformly random input; equals ΩU\Omega_U. "the halting probability"
  • halting set: The set of inputs on which a given Turing machine halts; its characteristic sequence can encode a non-computable real. "the halting set"
  • Lebesgue measure: The standard measure on real numbers generalizing length; “full Lebesgue measure” means the complement has measure zero. "full Lebesgue measure"
  • left-computably enumerable: A real that can be effectively approximated from below by an increasing computable sequence of rationals. "left-computably enumerable but not computable"
  • lower-elementary computable: A class of effectively computable functions characterized by restricted growth/complexity, here used to establish computability of log⁡\log on a domain. "lower-elementary computable"
  • Martin-Löf random real: A real number that passes all effective statistical tests for randomness in the sense of Martin-Löf. "random real in the sense of Martin-L\"of"
  • oracle: An abstract information source that supplies answers to specific decision problems to an algorithm. "An oracle for the first nn-many bits of ΩU\Omega_U"
  • prefix-free Turing machine: A Turing machine whose domain of halting programs is prefix-free, meaning no halting program is a prefix of another. "prefix-free Turing machine"
  • principal branch cut: The standard branch cut for the complex logarithm along (−∞,0](-\infty,0], separating values to make log⁡\log single-valued. "principal branch cut"
  • principal-branch complex natural logarithm: The single-valued version of the complex logarithm with imaginary part in (−π,π](-\pi,\pi]. "principal-branch complex natural logarithm"
  • slit plane: The complex plane with a ray (here (−∞,0](-\infty,0]) removed, often used as a domain for single-valued analytic branches. "slit plane C∖(−∞,0]\mathbb{C} \setminus (-\infty, 0]"
  • Specker sequence: A computable, monotone bounded sequence of rationals whose limit is a non-computable real. "Specker sequences"
  • universal prefix-free Turing machine: A prefix-free Turing machine capable of simulating any other via a suitable encoding; used to define ΩU\Omega_U. "universal prefix-free Turing machine"
View Paper Prompt  View All Prompts 

Open Problems

We haven't generated a list of open problems mentioned in this paper yet.

Generate Now

Collections

Sign up for free to add this paper to one or more collections.

Sign Up

Tweets

Sign up for free to view the 4 tweets with 1175 likes about this paper.

Sign Up for Free

HackerNews

  1. Inexpressibility in Exp-Minus-Log (EML) (17 points, 1 comment) 

Reddit

  1. Inexpressibility in Exp-Minus-Log (EML) (2 points, 6 comments)