# CLAUDE.md — Puzzle Exploration Guide

## The Puzzle

Seven functions, each with the form:
```
f(x) = (a)(b)(c)(d)(polynomial) + restricted_function(x)
```

The instruction is "Find the domain." This is likely a puzzle where the answer is NOT just "compute seven domains." Something is encoded here.

## Raw Data

```
1. f(x) = (2)(3)(1)(3)(9x^5 + 40088601)  + log_10(-386 + 240x - 36x^2)
2. f(x) = (3)(2)(3)(1)(14x^6 + 7604647)   + 17*cosh(arctanh(x-5))
3. f(x) = (3)(1)(2)(3)(20x^6 + 7672784)   + 10*sin(arccos(-40 + 74x - 45x^2 + 9x^3))
4. f(x) = (3)(3)(3)(2)(5x^8 + 291185604)  + 49/⌈arcsin(2x/3)⌉
5. f(x) = (3)(1)(1)(1)(7x^9 - 939481763)  + 2*(-4x^4 + 68x^3 - 321x^2 + 272x - 63)^0.25
6. f(x) = (3)(2)(2)(3)(5x^8 + 35962558)   + e^(ln(-147 + 144x - 32x^2))
7. f(x) = (2)(2)(3)(2)(18x^2 + 6554701)   + sqrt(-52 + 68x - 17x^2)
```

## Exploration Strategy

Work through these phases. After each phase, write findings to `notes/phase_N.md`. If you crack it, write the solution to `notes/SOLVED.md`.

---

### Phase 1: Compute the Domains (Baseline)

For each function, the polynomial part is always defined on all reals. The domain is entirely determined by the restricted function. Compute each domain exactly (symbolic roots).

| # | Restricted Function | Constraint |
|---|---|---|
| 1 | log_10(-386 + 240x - 36x^2) | -36x² + 240x - 386 > 0 |
| 2 | 17*cosh(arctanh(x-5)) | \|x-5\| < 1 → 4 < x < 6 |
| 3 | 10*sin(arccos(-40 + 74x - 45x^2 + 9x^3)) | -1 ≤ 9x³ - 45x² + 74x - 40 ≤ 1 |
| 4 | 49/⌈arcsin(2x/3)⌉ | \|2x/3\| ≤ 1 AND ⌈arcsin(2x/3)⌉ ≠ 0 |
| 5 | 2*(-4x^4 + 68x^3 - 321x^2 + 272x - 63)^0.25 | -4x⁴ + 68x³ - 321x² + 272x - 63 ≥ 0 |
| 6 | e^(ln(-147 + 144x - 32x^2)) | -32x² + 144x - 147 > 0 |
| 7 | sqrt(-52 + 68x - 17x^2) | -17x² + 68x - 52 ≥ 0 |

**Use sympy** to get exact symbolic roots. Also compute **decimal approximations** to spot patterns.

**Key questions:**
- Are the domains all intervals? Unions of intervals?
- Do they overlap? Are they nested?
- Do the endpoints have nice values? Integer? Rational?
- What are the domain LENGTHS?
- Do the domains, when placed on a number line, form a pattern?

```python
from sympy import *
x = symbols('x')

# Define each constraint and solve
constraints = [
    (-36*x**2 + 240*x - 386, '>'),   # 1: > 0
    # 2: 4 < x < 6 (already known)
    (9*x**3 - 45*x**2 + 74*x - 40, 'between', -1, 1),  # 3: in [-1, 1]
    # 4: |2x/3| <= 1 AND ceil(arcsin(2x/3)) != 0
    (-4*x**4 + 68*x**3 - 321*x**2 + 272*x - 63, '>='),  # 5: >= 0
    (-32*x**2 + 144*x - 147, '>'),   # 6: > 0
    (-17*x**2 + 68*x - 52, '>='),    # 7: >= 0
]
```

---

### Phase 2: Examine the (a)(b)(c)(d) Tuples

```
1: (2)(3)(1)(3) → product=18, digits=2313
2: (3)(2)(3)(1) → product=18, digits=3231
3: (3)(1)(2)(3) → product=18, digits=3123
4: (3)(3)(3)(2) → product=54, digits=3332
5: (3)(1)(1)(1) → product=3,  digits=3111
6: (3)(2)(2)(3) → product=36, digits=3223
7: (2)(2)(3)(2) → product=24, digits=2232
```

**Try:**
- Products: 18, 18, 18, 54, 3, 36, 24 — do these encode something?
- As base-4 numbers? As indices?
- As a selection mechanism (e.g., pick the Nth digit of something)?
- Concatenated: 2313 3231 3123 3332 3111 3223 2232
- Each tuple has 4 digits from {1,2,3}. Ternary? Base-3 encoding?
- Convert each 4-digit tuple from base-4: 2*64+3*16+1*4+3 = 128+48+4+3 = 183, etc.
- Are they coordinates? Grid references?
- Do they indicate which PART of the domain to use?

---

### Phase 3: Examine the Polynomials

```
1: 9x^5  + 40088601
2: 14x^6 + 7604647
3: 20x^6 + 7672784
4: 5x^8  + 291185604
5: 7x^9  - 939481763
6: 5x^8  + 35962558
7: 18x^2 + 6554701
```

**Try:**
- Factor the constants: 40088601, 7604647, 7672784, 291185604, 939481763, 35962558, 6554701
- Are the constants perfect powers? Primes? Encode ASCII?
- Evaluate the polynomials at the domain boundaries — do you get nice numbers?
- Evaluate f(x) at integer points in the domain — do you get nice numbers?
- Do the polynomial coefficients (9, 14, 20, 5, 7, 5, 18) spell something?
- Do the degrees (5, 6, 6, 8, 9, 8, 2) encode something?

```python
constants = [40088601, 7604647, 7672784, 291185604, 939481763, 35962558, 6554701]
for c in constants:
    print(f"{c}: factors={factorint(c)}, sqrt≈{c**0.5:.2f}, cbrt≈{c**(1/3):.2f}")
```

---

### Phase 4: Cross-Cutting Analysis

Try combining information across the three components (tuples, polynomials, restricted functions).

**Ideas:**
- For each function, evaluate at a specific x (maybe center of domain, or integer in domain). Does the tuple tell you which digit of the result to pick?
- The tuple might be (row, column, ...) coordinates in some grid
- Maybe each function's domain contains exactly one integer, and those integers spell/encode something
- Maybe the domain endpoints ARE the answer (collect all endpoints, sort them, decode)
- Check if any function equals zero at a nice point
- The multiplier tuples times the polynomial values at specific points might give ASCII codes

**The "find the domain" instruction might be misdirection or a HINT:**
- "Domain" could mean internet domain (the answer is a URL?)
- "Domain" in the mathematical sense, but the domains encode letters/words
- Maybe you find 7 intervals and their properties (length, center, endpoints) encode a message

---

### Phase 5: Integer Sweep

For each function, evaluate at every integer in a reasonable range (say 0-10) and see what happens.

```python
# For each f(x), evaluate at integers and look for:
# - Zero values
# - Integer outputs
# - ASCII-range outputs (32-126)
# - Outputs that are perfect squares, etc.
```

---

### Phase 6: Weird Ideas (if stuck)

- Read the (a)(b)(c)(d) as selecting letters: 1=A, 2=B, 3=C → BCAC, CBCA, CABC, CCCC, CAAA, CBBC, BBCB
- Treat each function number (1-7) as paired with its domain to make a coordinate
- The large constants might be encoded messages themselves (convert to base 26, base 64, hex→ASCII)
- Maybe the PRODUCT of (a)(b)(c)(d) tells you the degree to reduce the polynomial to
- Look at the restricted functions themselves as a sequence: log, cosh∘arctanh, sin∘arccos, 1/ceil∘arcsin, fourth root, exp∘ln, sqrt — is there a pattern in the composition depth or function types?
- exp(ln(expr)) = expr for expr > 0, so #6 simplifies to just the quadratic expression. Is this a hint that simplification matters?
- Similarly cosh(arctanh(x)) = 1/sqrt(1-(x)²), so #2 simplifies. Check ALL for simplifications.

---

### Phase 7: Simplification Pass

Some of these composed functions simplify dramatically:

- **#2**: cosh(arctanh(u)) = 1/sqrt(1-u²), so 17*cosh(arctanh(x-5)) = 17/sqrt(1-(x-5)²)
- **#6**: e^(ln(expr)) = expr, so this is just -32x² + 144x - 147 (when positive)
- **#3**: sin(arccos(u)) = sqrt(1-u²), so 10*sin(arccos(expr)) = 10*sqrt(1-expr²)

Do the simplified forms reveal anything? Do they evaluate to nicer numbers?

---

## File Structure

```
notes/
  phase_1.md    — Exact domains
  phase_2.md    — Tuple analysis
  phase_3.md    — Polynomial/constant analysis
  phase_4.md    — Cross-cutting findings
  phase_5.md    — Integer sweep results
  phase_6.md    — Wild ideas tried
  phase_7.md    — Simplification results
  scratchpad.md — Running observations, hunches
  SOLVED.md     — Final answer when found
```

## Iteration Protocol

Each time you start a loop iteration:
1. `cat notes/scratchpad.md` to see where you left off
2. Pick the next unexplored phase (or revisit one with new ideas)
3. Run computations in Python (sympy, numpy as needed)
4. Write findings to the appropriate phase file
5. Update `scratchpad.md` with: what you tried, what you found, what to try next
6. If you find something promising, FOLLOW THE THREAD before moving on

## Important Reminders

- The puzzle creator said the instructions are "likely incomplete, or meant as a hint." The answer is probably NOT seven intervals.
- "Find the domain" might be a pun, misdirection, or the first step of a multi-step decode.
- The (a)(b)(c)(d) tuples are NOT just scalar multipliers — they vary per line and use only {1,2,3}. They encode something.
- The large constants in the polynomials are suspiciously specific. They're probably not random.
- Look for the moment where multiple independent observations CONVERGE. That's the crack.
- Don't get tunnel-visioned on one approach. If you've spent 3 iterations on one idea without progress, try something completely different.
- **Write down dead ends too.** Future iterations need to know what DIDN'T work.

If you think you have an answer, respond with the string inside angle brackets. For example, if you think the answer is "PASSWORD", then respond with <PASSWORD>. This will allow you to exit the loop.