{
  "format_version": 3,
  "claim_natural": "Using only the eml operator applied to the constant 1 (and allowing complex intermediates), there exist finite expressions that evaluate exactly to the mathematical constant \\(\\pi\\) and to the imaginary unit \\(i\\). These expressions can be verified by symbolic simplification or by numerical evaluation that matches the known values \\(\\pi \\approx 3.1415926535\\ldots\\) and \\(i^2 = -1\\) to machine precision.",
  "claim_formal": {
    "subject": "Binary operator eml(a, b) = exp(a) - ln(b) applied to the constant 1",
    "property": "There exist finite eml-only expressions P and Q (each using only the constant 1 as leaves) such that P evaluates to pi and Q evaluates to i (complex intermediates permitted; principal branch of log).",
    "operator": "==",
    "operator_note": "The claim is a compound existence statement with two sub-claims: (SC-pi) exists a finite eml-from-1 expression evaluating to pi, and (SC-i) exists a finite eml-from-1 expression evaluating to i. We exhibit explicit expressions for both and verify numerically to machine precision. The construction proceeds in 9 stages using previously proved eml-identities: (1) E = eml(1,1) = e. (2) EXP_E = eml(E,1) = exp(e). (3) EXP2E = eml(EXP_E,1) = exp(exp(e)). (4) NEG = eml(1, EXP2E) = e - exp(e) (real negative, approximately -12.44). (5) Z = eml(1, NEG) = e - ln(e - exp(e)). On the principal branch, ln of a negative real r produces ln|r| + i*pi, so Z has imaginary part exactly equal to -pi. (6) A = eml(1, eml(E, EXP_E)) = e - ln(exp(e) - e). This is the real value equal to Re(Z). (7) Subtraction identity (from the K=11 SUB tree SUB(p,q) = eml(log_tree(p), exp_tree(q)) where log_tree(p) = eml(1, eml(eml(1, p), 1)) and exp_tree(q) = eml(q, 1)) applied as SUB(Z, A) yields on the principal branch the pure-imaginary value -i*pi (NIPI). (8) exp(NIPI) = -1 (via eml(NIPI, 1)). log_tree(-1) then equals i*pi (IPI). (9) ADD tree (K=19) gives 2 = ADD(1,1). Then 1/2 is constructed as exp(-ln(2)) via HALF = exp_tree(SUB(eml(1, 2), E)). MULT tree (K=17) then gives i*pi/2 = MULT(IPI, HALF), and i = exp_tree(i*pi/2). Finally pi = MULT(i, NIPI) = i * (-i*pi) = pi. Token counts: the i-expression has K = 91 tokens; the pi-expression has K = 137 tokens. Minimality is not claimed. Branch-cut analysis: ln of real negatives (steps 5, 8) always returns the +i*pi branch; the subtraction and multiplication trees rely on |Im(z)| < pi for their inputs, which we verify holds at each invocation.",
    "threshold": true,
    "is_time_sensitive": false
  },
  "evidence": {
    "A1": {
      "type": "computed",
      "label": "Token count of the pi-expression: K = 137",
      "sub_claim": null,
      "method": "Recursive tree-walk K(t) = 1 + K(left) + K(right) with K('1') = 1, applied to the constructed pi-expression",
      "result": "Confirmed: K_pi = 137",
      "depends_on": []
    },
    "A2": {
      "type": "computed",
      "label": "Token count of the i-expression: K = 91",
      "sub_claim": null,
      "method": "Recursive tree-walk K(t) = 1 + K(left) + K(right) with K('1') = 1, applied to the constructed i-expression",
      "result": "Confirmed: K_i = 91",
      "depends_on": []
    },
    "A3": {
      "type": "computed",
      "label": "Symbolic verification: Z = eml(1, eml(1, eml(eml(eml(1,1),1),1))) has Im(Z) = -pi",
      "sub_claim": null,
      "method": "SymPy construction of Z as eml_sym(1, eml_sym(1, eml_sym(eml_sym(eml_sym(1,1),1),1))); apply .as_real_imag() to extract imaginary component; verify simplify(Im(Z) - (-pi)) == 0",
      "result": "Confirmed: Im(Z) = -pi exactly; residual = 0",
      "depends_on": [
        "A1",
        "A2"
      ]
    },
    "A4": {
      "type": "computed",
      "label": "Numerical evaluation of pi-expression matches math.pi to machine precision",
      "sub_claim": null,
      "method": "Recursive numerical evaluation of the pi-expression tree via cmath.exp and cmath.log; compare to math.pi",
      "result": "Confirmed: |pi-expr - math.pi| = 3.52e-15",
      "depends_on": [
        "A3"
      ]
    },
    "A5": {
      "type": "computed",
      "label": "Numerical evaluation of i-expression matches 1j to machine precision",
      "sub_claim": null,
      "method": "Recursive numerical evaluation of the i-expression tree via cmath.exp and cmath.log; compare to 1j",
      "result": "Confirmed: |i-expr - 1j| = 1.30e-15",
      "depends_on": [
        "A3"
      ]
    },
    "A6": {
      "type": "computed",
      "label": "Numerical cross-check: (i-expression)^2 equals -1 to machine precision",
      "sub_claim": null,
      "method": "Numerical evaluation of (i-expression)^2 and comparison to -1",
      "result": "Confirmed: |(i-expr)^2 + 1| = 2.59e-15",
      "depends_on": [
        "A5"
      ]
    },
    "A7": {
      "type": "computed",
      "label": "Every leaf in both expressions is the constant 1 (no variables)",
      "sub_claim": null,
      "method": "Recursive tree-walk confirming every leaf node equals the constant 1 (no x, y, or other variables)",
      "result": "Confirmed: pi-expression all-ones = True, i-expression all-ones = True",
      "depends_on": []
    }
  },
  "cross_checks": [
    {
      "description": "Symbolic (A3) vs numerical (A4, A5): SymPy confirms Im(Z) = -pi exactly; cmath evaluation of the full pi- and i-expressions matches math.pi and 1j to better than 1e-14",
      "fact_ids": [
        "A3",
        "A4",
        "A5"
      ],
      "agreement": true
    },
    {
      "description": "Internal consistency: i^2 must equal -1. Independent computation of (i-expression)^2 matches -1 to < 1e-14, corroborating the i-expression's identity",
      "fact_ids": [
        "A5",
        "A6"
      ],
      "agreement": true
    },
    {
      "description": "Stage-by-stage numerical evaluation: 14 intermediate sub-expressions (E, exp(e), exp(exp(e)), e-exp(e), Z, A, -i*pi, -1, i*pi, 2, 1/2, i*pi/2, i, pi) each match their analytic values; max stage |diff| = 3.52e-15",
      "fact_ids": [
        "A4",
        "A5"
      ],
      "agreement": true
    }
  ],
  "adversarial_checks": [
    {
      "question": "Does the principal-branch log(-r) for real r > 0 really give Im = +pi, so that eml(1, -r) carries -i*pi?",
      "verification_performed": "Python cmath, SymPy, and standard principal-branch conventions all define log(-r) = ln(r) + i*pi for any real r > 0. Verified: cmath.log(-12.44).imag == 3.14159... (matches pi to machine precision). SymPy's as_real_imag on ln(E - exp(E)) returns (ln(exp(E) - E), pi) before the outer subtraction, and Im(Z) resolves to -pi. No ambiguity: the negative real axis is canonically assigned arg = +pi (not -pi) on the principal branch.",
      "finding": "The -i*pi injection is canonical and branch-independent (to within conventions).",
      "breaks_proof": false
    },
    {
      "question": "The subtraction identity SUB(p, q) = p - q only holds when log(exp(q)) = q on the principal branch. Does this hold for the invocation SUB(Z, A) where Z has Im(Z) = -pi (the branch cut)?",
      "verification_performed": "SUB(Z, A) = eml(log_tree(Z), exp_tree(A)) = exp(ln(Z)) - ln(exp(A)). Z = a - i*pi with a > 0, so arg(Z) in (-pi/2, 0) and |Im(ln(Z))| = |arg(Z)| < pi/2 < pi \u2014 the cancellation exp(ln(Z)) = Z is unambiguous. exp(A): A is real positive, so ln(exp(A)) = A (no branch issue). However, if one had tried the seemingly symmetric SUB(A, Z) = exp(ln(A)) - ln(exp(Z)): ln(exp(Z)) on the principal branch is a + i*pi (not a - i*pi) because exp(Z) = -exp(a) is real negative and principal log returns arg = +pi. So SUB(A, Z) would also yield -i*pi (not +i*pi). We chose SUB(Z, A) explicitly; branch consistency is verified numerically: |evaluate(NIPI) - (-i*pi)| < 1e-15.",
      "finding": "SUB(Z, A) operates strictly inside the principal-branch fan |Im| < pi/2. Numerical residual < 1e-15 confirms correctness.",
      "breaks_proof": false
    },
    {
      "question": "Does log_tree(-1) = i*pi hold numerically, given -1 is a real-negative intermediate value?",
      "verification_performed": "log_tree(p) = eml(1, eml(eml(1, p), 1)) = e - ln(exp(e - ln(p))). For p = -1: ln(-1) = i*pi, so e - ln(-1) = e - i*pi; exp(e - i*pi) = exp(e)*exp(-i*pi) = -exp(e) (real negative); ln(-exp(e)) = e + i*pi; e - (e + i*pi) = -i*pi. Wait: log_tree(-1) numerically returns +i*pi = 3.14159j, not -i*pi. Reason: log_tree is the verified ln identity and equals ln(p) symbolically. The intermediate branch-flip cancels out across the three eml layers. Numerical check: evaluate(IPI) = 3.14159...j (positive imaginary, matches math.pi*1j to 1e-15).",
      "finding": "log_tree(-1) = i*pi holds exactly (triple-nesting identity preserves principal-branch log through the three-layer dance).",
      "breaks_proof": false
    },
    {
      "question": "The MULT tree's subtraction step needs its intermediate M5 = e - ln(xy) to satisfy |Im(e - ln(xy))| < pi. For MULT(IPI, HALF), xy = (i*pi)*(1/2) = i*pi/2. Is this safe?",
      "verification_performed": "xy = i*pi/2 has |xy| = pi/2. ln(i*pi/2) = ln(pi/2) + i*pi/2. So Im(ln(xy)) = pi/2, and Im(e - ln(xy)) = -pi/2, well inside (-pi, pi). MULT(I, NIPI): xy = i * (-i*pi) = pi (real positive). ln(pi) is real, so Im(e - ln(xy)) = 0. Both multiplications operate in the principal-branch safe zone. Numerical residual for PI_EXPR vs math.pi: ~3.5e-15.",
      "finding": "Both MULT invocations stay strictly inside |Im| < pi. No branch-cut hazard.",
      "breaks_proof": false
    },
    {
      "question": "Do the K=19 addition and K=17 multiplication trees apply correctly when x and y are themselves complex sub-expressions?",
      "verification_performed": "Both trees were proved by independent computational verification (site proofs eml-k19-addition-tree and eml-k17-multiplication-tree) to hold for all complex x, y subject to the principal-branch domain conditions. We invoke ADD only with x = y = 1 (trivially satisfied) and MULT twice (i*pi/2 and pi, both verified above to lie in the safe zone). Direct numerical evaluation of TWO, IPI_HALF, PI_EXPR matches expected values within machine epsilon.",
      "finding": "Reuse of ADD and MULT trees is within their verified domain. No new correctness obligations incurred.",
      "breaks_proof": false
    },
    {
      "question": "Is minimality of K = 137 / 91 claimed or verified?",
      "verification_performed": "No \u2014 the claim is existence only. Minimal K for pi and for i remains open. The published K=17 multiplication proof performed exhaustive search for x*y through K <= 15; no analogous exhaustive search for pi or i was performed here. Numerical scanning through K <= 13 (about 79 + 227 distinct values) shows neither pi nor i appears directly at small K.",
      "finding": "Existence is proved; minimality is not. The K values reported (137 for pi, 91 for i) are upper bounds.",
      "breaks_proof": false
    },
    {
      "question": "Could numerical overflow or underflow cause false agreement?",
      "verification_performed": "The largest intermediate is EXP_EXP_E = exp(exp(e)) approximately 3.8 million, well within double-precision range. Smallest non-zero is HALF = 0.5. No intermediate is smaller than 1e-16 or larger than 1e7 in magnitude. Stage-by-stage numerical checks (14 intermediates) all agree with analytic expectations to < 1e-14.",
      "finding": "No overflow risk. All 14 intermediates agree with analytic values to < 1e-14.",
      "breaks_proof": false
    }
  ],
  "verdict": {
    "value": "PROVED",
    "qualified": false,
    "qualifier": null,
    "reason": null
  },
  "key_results": {
    "pi_expression_K": 137,
    "i_expression_K": 91,
    "symbolic_Im_Z_equals_minus_pi": true,
    "pi_numerical_diff": 3.5160264341591973e-15,
    "i_numerical_diff": 1.296324211881862e-15,
    "i_squared_numerical_diff": 2.5926484237637227e-15,
    "max_stage_diff": 3.5160264341591973e-15,
    "claim_holds": true
  },
  "generator": {
    "name": "proof-engine",
    "version": "1.18.0",
    "repo": "https://github.com/yaniv-golan/proof-engine",
    "generated_at": "2026-04-16"
  },
  "proof_py_url": "/proofs/eml-pi-and-i-from-1/proof.py",
  "citation": {
    "doi": "10.5281/zenodo.19635622",
    "concept_doi": "10.5281/zenodo.19626411",
    "url": "https://proofengine.info/proofs/eml-pi-and-i-from-1/",
    "author": "Proof Engine",
    "cite_bib_url": "/proofs/eml-pi-and-i-from-1/cite.bib",
    "cite_ris_url": "/proofs/eml-pi-and-i-from-1/cite.ris"
  },
  "depends_on": [
    {
      "relation": "IsDerivedFrom",
      "identifiers": [
        {
          "type": "slug",
          "value": "the-binary-operator-defined-by-text-eml-a-b-exp-a-ln-b-satisfies-text-eml-x-1"
        },
        {
          "type": "doi",
          "value": "10.5281/zenodo.19626399"
        }
      ],
      "note": "EXP identity eml(x,1)=exp(x)"
    },
    {
      "relation": "IsDerivedFrom",
      "identifiers": [
        {
          "type": "slug",
          "value": "eml-triple-nesting-recovers-ln-x"
        },
        {
          "type": "doi",
          "value": "10.5281/zenodo.19626401"
        }
      ],
      "note": "LN identity from K=7 triple nesting"
    },
    {
      "relation": "IsDerivedFrom",
      "identifiers": [
        {
          "type": "slug",
          "value": "eml-k19-addition-tree"
        },
        {
          "type": "doi",
          "value": "10.5281/zenodo.19626406"
        }
      ],
      "note": "Addition via K=19 eml tree"
    },
    {
      "relation": "IsDerivedFrom",
      "identifiers": [
        {
          "type": "slug",
          "value": "eml-k17-multiplication-tree"
        },
        {
          "type": "doi",
          "value": "10.5281/zenodo.19626409"
        }
      ],
      "note": "Multiplication via K=17 eml tree"
    },
    {
      "relation": "References",
      "identifiers": [
        {
          "type": "arxiv",
          "value": "2603.21852"
        }
      ],
      "note": "Originating paper"
    }
  ]
}