ScorpTech x402 API
mcp remote · streamable-http · v1.0.0 · source: crawl
https://scorptech.it.com/api/x402/mcp
112 x402 pay-per-call tools: web data, security/OSINT, SEC and public data, Solana/EVM lookups
Works
85
Verified Oct 31, 2026 · p50 948 ms · p95 1344 ms
Worth
no data
No outcomes reported yet. Agents report through report_outcome after a find_agents call.
Checks
| Check | Weight | Result | Evidence |
|---|---|---|---|
| reachable | 20 | pass | 3 of 3 handshakes succeeded; server 'scorptech-x402' |
| tools_listed | 15 | pass | 1012 tools |
| schema_complete | 15 | pass | 1004 of 1012 tools have a description and a typed schema |
| latency_p50 | 10 | pass | p50 948 ms |
| latency_p95 | 5 | pass | p95 1344 ms |
| error_free | 10 | pass | 0 of 3 attempts failed |
| auth_posture | 10 | pass | https, open |
| injection_scan | 10 | fail | qr_generate: base64 payload; image_info: base64 payload; image_resize: base64 payload; password_strength: sends credentials; validate_batch: base64 payload; jwt_decode: sends credentials; hash_encode: base64 payload; prompt_injection_scan: base64 payload; barcode_generate: base64 payload; chart_svg: base64 payload; file_type_detect: base64 payload; jwk_convert: base64 payload; jwt_sign: base64 payload; webhook_verify: base64 payload; password_hash: sends credentials; saml_decode: base64 payload; |
| scope | 5 | fail | broad tools: math_eval, poly_eval |
Unknown counts as fail; n/a is left out of the denominator. How the weights work.
Tools (1012)
| Name | Description | Schema |
|---|---|---|
lucky_count | How many lucky numbers are from 1 through n. There is 1 through 1, 2 through 3, and 13 through 50. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: | typed |
pronic | The nth pronic number, n*(n+1). The 0th is 0, the 1st is 2, and the 5th is 30. n runs from 0 to 10000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scor | typed |
star_number | The nth star number, 6*n*(n-1) + 1. The 1st is 1, the 2nd is 13, and the 5th is 121. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https:/ | typed |
domb_gcd | The greatest common divisor of D(n) and D(n+1). n=0 gives 1, n=1 gives 4, and n=6 gives 64. n runs from 0 to 11. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https | typed |
schema_validate | Validate JSON data against a JSON Schema (Ajv + formats). Body: { "schema": {...}, "data": {...} }. Returns valid boolean and error list. Price: $0.005 USDC per successful call (x402, Solana). Same to | incomplete |
mx_check | MX / mail-routing check: sorted MX with inferred provider (Google, M365, Proofpoint, etc.), A/AAAA, SPF presence, null-MX detection. Complements /v1/email-auth. Price: $0.005 USDC per successful call | typed |
ip_intel | IP ASN + geolocation from free public sources (ipapi.co + RIPE Stat prefix-overview). Country/city/coords, ASN/org, announced prefix. Public IPs only. Price: $0.005 USDC per successful call (x402, Sol | typed |
solana_tx | Decode a Solana mainnet transaction via public RPC: status, fee, compute units, parsed instructions, inner instructions, account keys, logs. No API key. Unique on Bazaar. Price: $0.005 USDC per succes | typed |
wayback | Check Internet Archive Wayback Machine availability for a URL (closest snapshot timestamp + archived URL). Public availability API. Price: $0.005 USDC per successful call (x402, Solana). Same tool ove | typed |
dns_dump | All common DNS records for a domain via Cloudflare DNS-over-HTTPS: A, AAAA, NS, MX, TXT, CAA. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/ | typed |
ct_subdomains | Certificate Transparency subdomain enumeration via crt.sh JSON API. Returns unique hostnames (capped) issued under the domain. Price: $0.008 USDC per successful call (x402, Solana). Same tool over HTT | typed |
redirect_chain | Follow HTTP redirects (max 10) with SSRF protections; report each hop status, Location, Server and Content-Type. Detect open-redirect chains and tracking bounces. Price: $0.005 USDC per successful cal | typed |
http_probe | Fast HTTP GET probe: final URL, status, timing, response bytes, and a subset of interesting headers (server, cache, HSTS, CDN). Price: $0.005 USDC per successful call (x402, Solana). Same tool over HT | typed |
sopfr | The sum of prime factors of n with multiplicity. sopfr(1) is 0, sopfr(12) is 7, and sopfr(36) is 10. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool ov | typed |
quat_inv | Inverse of a quaternion, the conjugate divided by the squared length. (1, 2, 3, 4) inverts to (1/30, -1/15, -1/10, -2/15). Zero has no inverse. Price: $0.001 USDC per successful call (x402, Solana). S | typed |
css_angle | Convert a CSS angle among deg, grad, turn and pirad. A degree is 1/360 turn, a gradian is 1/400 turn, and one pirad is π radians, which is half a turn. A raw radian value is rejected because π is not | typed |
css_time | Convert a CSS time between seconds and milliseconds. One millisecond is 1/1000 s. Minutes are not a CSS time unit. Exact rationals. Price: $0.001 USDC per successful call (x402, Solana). Same tool ove | typed |
headers_audit | Graded HTTP security-header audit of a URL: HSTS, CSP quality, XFO, nosniff, Referrer/Permissions/COOP/CORP/COEP, cookie flags, redirect chain, server info leaks, with fix recommendations. Price: $0.0 | typed |
email_auth | Email authentication & deliverability posture for a domain: SPF (qualifier, lookup count, duplicates), DMARC policy/rua/pct, DKIM probe across common selectors, MTA-STS, TLS-RPT, BIMI, MX; scored with | typed |
domain_intel | One-call domain due-diligence: RDAP registration age/expiry/registrar, A/AAAA/NS/MX/CAA, live TLS certificate (issuer, expiry, SANs, trust), Certificate-Transparency subdomain enumeration, and risk fl | typed |
robots_sitemap | Fetch and parse robots.txt plus discovered sitemaps for a domain: user-agents, allow/disallow samples, sitemap index vs urlset, URL counts and sample locs. Useful for crawl planning and AI agent polit | typed |
tech_stack | Lightweight technology fingerprint from public HTML/headers: CMS, frameworks (Next/Nuxt/React/Vue), CDNs, analytics, payments, generator meta, script/stylesheet samples. No invasive probing. Price: $0 | typed |
rdap_age | Lightweight RDAP registration age lookup: registered/expiry dates, ageDays, daysToExpiry, registrar, status flags via rdap.org bootstrap. Faster/cheaper than full domain-intel when you only need age. | typed |
phishing_score | Heuristic phishing-likelihood score for a URL/domain: brand typosquat distance, subdomain depth, punycode, RDAP age, HTTPS reachability. Returns scored signals — not a verdict. Low Bazaar crowding. Pr | typed |
cve_lookup | Search NIST NVD CVE API 2.0 by product/keyword with optional CVSSv3 severity filter. Returns CVE ids, scores, vectors, descriptions and reference URLs. Public NVD data. Price: $0.01 USDC per successfu | typed |
package_risk | npm or PyPI package risk/typosquat check: registry metadata, weekly downloads (npm), deprecation, license/repo presence, edit-distance to popular packages, and whether close-name variants already exis | typed |
github_health | GitHub repository health summary via public API: stars/forks/issues, license, languages, last push age, latest release & commit, heuristic healthScore and notes. Unauthenticated rate limits apply. Pri | typed |
opengraph | Extract Open Graph, Twitter Card, title/description, canonical, icons and JSON-LD @types from a public URL. Ideal for link unfurling agents. Price: $0.005 USDC per successful call (x402, Solana). Same | typed |
url_markdown | Fetch a public HTML page and convert main/article content to Markdown (Turndown). Scripts/styles stripped; output capped. Good for RAG/agent ingestion. Price: $0.005 USDC per successful call (x402, So | typed |
x402_probe | x402 preflight for AI agents: inspect any paid endpoint BEFORE paying. Fetches the unpaid 402, decodes PAYMENT-REQUIRED (v2 header or v1 body), normalises price to USD, lists networks/assets/payTo/fee | typed |
web_to_text | Fetch a public web page and return its main content as clean plain text (boilerplate stripped, lists as bullets, tables tab-separated) plus title, description, language, word count. Price: $0.005 USDC | typed |
url_links_extract | Extract every link on a page as absolute URLs (RFC 3986 resolution, <base href> aware), classified internal/external/other with anchor text, rel and nofollow. Options: filter, dedupe, max_links. Price | typed |
qr_generate | Generate a QR code (PNG or SVG, base64 + data URI) for any UTF-8 text up to 2953 bytes. Options: ecc L|M|Q|H, size (px/module), margin, format png|svg, fg/bg hex colours. Price: $0.005 USDC per succes | typed |
text_stats | Text statistics: characters, words, unique words, sentences, paragraphs, reading/speaking time, Flesch readability (English), language detection (27 languages/scripts), top keywords. Price: $0.005 USD | typed |
html_to_markdown | Convert an HTML string to clean Markdown (GFM tables, fenced code, nested lists). No fetch. Body: { "html": "...", "base_url"?: "https://...", "extract_main"?: false }. Price: $0.005 USDC per successf | typed |
image_info | Inspect an image without decoding pixels: format, dimensions (EXIF-orientation aware), megapixels, animation, sha256, EXIF summary (camera, exposure, GPS). Body: { "image": "<base64>" }. Max ~190KB in | typed |
image_resize | Resize / convert an image (GD): width/height up to 4096, fit contain|cover|fill|inside, output png|jpeg|webp|gif, quality, EXIF auto-orient, metadata stripped. Body: { "image": "<base64>", "width": 25 | typed |
treasury_rates | US Treasury rates: the daily par yield curve (1M-30Y, from treasury.gov) with day-over-day change in bp, 2s10s spread and 3m10y inversion flag, optional TIPS real yield curve, plus Debt to the Penny ( | typed |
sec_edgar_search | SEC EDGAR filings search: latest 10-K/10-Q/8-K (or any form) for a company by name, ticker or CIK, with direct document and filing-index links; or full-text search across all EDGAR filings since 2001 | typed |
sec_form4 | Insider trading from SEC Form 4: the latest Form 4 filings for a ticker or CIK parsed from EDGAR ownershipDocument XML. Reporting owner and role, every transaction (code + meaning, shares, price, valu | typed |
company_profile | Company profile from its own website: name, description, logo, social profiles, contact emails/phones, postal address, schema.org Organization JSON-LD, OpenGraph/Twitter cards, plus RDAP domain regist | typed |
weather_nws | US weather from the National Weather Service for a latitude/longitude: 7-day (or hourly) forecast periods with temperature, precipitation chance, wind and text forecast, plus all active NWS watches, w | typed |
arxiv_search | Search arXiv papers: title, authors, full abstract, categories, dates, DOI/journal ref and direct abs + PDF links. Plain keywords or arXiv field syntax (ti:, au:, abs:, cat:, AND/OR), optional categor | typed |
earthquakes | Recent earthquakes from the USGS: filter by bounding box or center point + radius, minimum magnitude and time window (last N days or start/end dates). Returns magnitude, place, time, coordinates, dept | typed |
holidays_business_days | Public holidays for 100+ countries (optionally one state/region) and business-day math in one call: list holidays for a year, add or subtract N business days, check if a date is a business day, or cou | typed |
hn_search | Search Hacker News stories and comments (Algolia HN index): by relevance or newest first, with date range, story/comment/Ask HN/Show HN filter, author and minimum points. Returns title, URL, points, c | typed |
dns_propagation | DNS propagation check: resolves one record type for a domain across Cloudflare 1.1.1.1, Google 8.8.8.8 and Quad9 9.9.9.9 (DNS-over-HTTPS, in parallel) and reports consensus, per-resolver answers, TTLs | typed |
ssl_cert_info | Inspect a live TLS certificate: subject, issuer, SANs, validity window, days to expiry, SHA-256 fingerprint, key type/size, full presented chain, negotiated TLS version/cipher, chain trust and RFC 612 | typed |
email_validate | Validate an email address without sending mail: RFC 5321/5322 syntax, MX/A lookup (null-MX aware), disposable-domain detection (~10k domains), role-account and free-provider flags, typo suggestion (gm | typed |
password_strength | Offline password strength audit (POST only, so the password never appears in a URL or access log; never echoed or stored): zxcvbn-style score 0-4, estimated guesses and entropy, crack-time estimates, | typed |
validate_batch | Offline format validator for up to 100 values: email, URL, IPv4/IPv6, domain, UUID (version/variant), credit card (Luhn + brand, number masked in output), IBAN (mod-97 + country length), phone (E.164) | typed |
sol_balance | SOL and SPL token balances (classic SPL Token + Token-2022) for a Solana wallet address, via public Solana RPC. Read-only. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: | typed |
sol_token_meta | Solana SPL / Token-2022 mint metadata: decimals, total supply, mint & freeze authority, Token-2022 extensions, and name/symbol/uri from on-chain metadata (Token-2022 or Metaplex), with Jupiter token l | typed |
sol_token_risk | Heuristic risk screen for a Solana token mint: mint/freeze authority, Token-2022 extensions (permanent delegate, transfer hook/fee, default-frozen, pausable...), metadata mutability, holder concentrat | typed |
evm_balance | Native ETH and ERC-20 token balances for an address on Ethereum, Base or Arbitrum via public RPC. Defaults to major tokens (USDC, USDT, WETH, DAI/ARB) or pass up to 20 token contracts. Read-only. Pric | typed |
evm_tx_info | Decode an EVM transaction (Ethereum, Base, Arbitrum): status, block, timestamp, confirmations, from/to, value, gas used, effective gas price, fee, method selector name, and decoded ERC-20 Transfer/App | typed |
fx_rate | Fiat currency exchange rate (ECB reference rates via Frankfurter, with ExchangeRate-API fallback for 150+ currencies), optional amount conversion and historical date. Read-only. Price: $0.005 USDC per | typed |
ens_resolve | Resolve an ENS name to its Ethereum address (plus optional text records like avatar, url, com.twitter), or reverse-resolve an address to its forward-verified primary ENS name. Read-only, public RPC. P | typed |
geocode | Geocode an address or place name to latitude/longitude (US Census Geocoder for US street addresses, Photon/OpenStreetMap worldwide), or reverse-geocode lat/lon to an address (with US county/tract). Re | typed |
wallet_risk_basic | Basic heuristic risk screen for a Solana or EVM (Ethereum/Base/Arbitrum) wallet: activity & age, bundled OFAC-SDN / mixer list matches for the address and recent counterparties, and (EVM) live token-a | typed |
sanctions_screen | Sanctions screening of a person or company NAME against the official consolidated lists: US OFAC SDN + non-SDN, UK Sanctions List (FCDO/OFSI), EU Financial Sanctions Files and the UN Security Council | typed |
sec_13f | Institutional holdings from a fund manager's latest SEC 13F-HR: the information table parsed from EDGAR, aggregated by CUSIP (issuer, class, shares, USD value, portfolio weight, put/call, voting autho | typed |
domain_availability | Bulk domain availability: for up to 20 domains, asks the authoritative registry over RDAP (server chosen from the IANA RDAP bootstrap). RDAP 404 = available; registered names return registrar, IANA id | typed |
eu_vat_validate | Validate an EU VAT number live against the European Commission VIES service: valid/invalid, plus registered trader name and address where the member state discloses them. Accepts IE6388047V style inpu | typed |
ip_reputation | IP blocklist reputation for up to 50 IPv4/IPv6 addresses: membership in the Tor exit list, Spamhaus DROP/DROPv6, abuse.ch Feodo Tracker botnet C2 and FireHOL level1 (cached published lists), with matc | typed |
cisa_kev | CISA Known Exploited Vulnerabilities check: is a CVE (or up to 100) in CISA's KEV catalog, with date added, federal remediation due date, past-due flag, known ransomware use, required action and CWEs. | typed |
epss_score | FIRST EPSS exploit-prediction scores for up to 100 CVEs: probability of exploitation in the next 30 days, percentile rank and a simple band, for the latest model run or a past date. Complements /v1/cv | typed |
hsts_preload | HSTS preload check for a domain: current status on the Chromium preload list (hstspreload.org), the official preloadable errors/warnings, and our own live checks of the site's HSTS header (max-age >= | typed |
macro_indicators | Macro indicators by country and year: GDP, real GDP growth, GDP per capita, inflation, unemployment, population, government debt and current account, side by side from the World Bank (WDI actuals) and | typed |
osv_scan | Known vulnerabilities for ONE package version from OSV.dev (GitHub Advisory DB, PyPA, Go, RustSec, OSS-Fuzz, distro feeds): advisory id + CVE aliases, severity (GHSA label or computed CVSS v3 base sco | typed |
vin_decode | Decode a 17-character Vehicle Identification Number: offline structure check (allowed characters, ISO 3779 check digit, region and WMI, model-year code) plus NHTSA vPIC decoding (make, model, model ye | typed |
osv_scan_batch | Dependency vulnerability scan (SCA) via OSV.dev querybatch: send up to 500 packages, or paste a lockfile (package-lock.json, yarn.lock, composer.lock, requirements.txt, Pipfile.lock, poetry.lock, uv.l | typed |
iban_validate | Validate an IBAN offline: ISO 7064 mod-97 checksum, per-country length and BBAN structure from the SWIFT IBAN registry (100+ countries plus national/experimental ones), national check digits for BE, E | typed |
wikipedia | Wikipedia in one call: search any of 340+ language editions (titles, descriptions, snippets, thumbnails) and get the top hit's summary, or fetch a summary by exact title. Returns title, short descript | typed |
pubmed_search | Search PubMed biomedical literature via NCBI E-utilities (esearch + esummary + efetch): PMID, title, authors, journal, publication date, volume/issue/pages, DOI, PMCID, publication types; abstracts on | typed |
feed_discover | Find a website's RSS/Atom/JSON feeds and read the latest items: parses <link rel="alternate"> tags, likely feed links and (if none) probes common feed paths, then parses the feed (RSS 2.0, RSS 1.0/RDF | typed |
evm_selector_decode | Decode EVM function selectors, calldata and event topics: looks up 4-byte selectors (or 32-byte event topics) in 4byte.directory plus a built-in table of well-known signatures, re-hashes every candida | typed |
readability_extract | Extract the main article from a web page (Readability-style content scoring, no headless browser): clean body text with paragraph breaks plus title, byline, site name, published/modified dates, langua | typed |
collatz_parity | The parity of each term on the Collatz trajectory from n through 1. 0 is even and 1 is odd. The parity of 6 is 010100001. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana | typed |
openalex_search | Scholarly search over OpenAlex (250M+ works): works with title, authors + ORCID + institutions, year, venue, DOI, citation count, open-access status + OA URL and reconstructed abstract; or authors (wo | typed |
format_convert | Convert data between CSV, TSV, JSON, YAML and XML in one call (auto-detects the input format). CSV header handling and delimiter detection, type inference (numbers, booleans, null), nested objects fla | typed |
repo_posture | Security posture of a public GitHub repository from the OpenSSF Scorecard API: aggregate 0-10 score and rating, every check (Code-Review, Branch-Protection, Dangerous-Workflow, Token-Permissions, Pinn | typed |
timezone_convert | Convert a time between IANA time zones with DST awareness: local time, UTC offset, abbreviation and DST flag on both sides, the offset difference and day shift, and each zone's next DST/offset transit | typed |
cron_explain | Explain a standard 5-field cron expression in plain English and list its next N run times (default 5, max 20) in any IANA zone, DST-correct. Supports lists, ranges, steps (*/n, a-b/n), month/weekday n | typed |
ticker_resolver | Resolve a stock ticker (or CIK) to the SEC CIK, registrant name, exchange and sibling share classes from SEC EDGAR's company_tickers_exchange list, plus the issuer's Legal Entity Identifier (LEI) from | typed |
jwt_decode | Decode a JWT (JWS or JWE header), POST only (token in the JSON body, never in a URL): header, claims, alg/kid, exp/nbf/iat status with leeway, aud/iss checks, and security findings (alg none, HMAC alg | typed |
usaspending_awards | Federal contracts, IDVs, grants, loans and direct payments from USAspending.gov by recipient, awarding agency (name or abbreviation such as DOD, NASA, HHS), NAICS code or keyword, for a date range (de | typed |
openfda_drug | FDA drug facts by brand/generic name or NDC from openFDA: label sections (boxed warning, indications, dosage, contraindications, warnings, adverse reactions, interactions, or any SPL field), FAERS adv | typed |
clinical_trials | Search ClinicalTrials.gov (API v2) by condition, keyword, location, sponsor, recruitment status (or open/closed) and phase. Returns NCT id, title, status, phases, study type, conditions, interventions | typed |
federal_register | Search the U.S. Federal Register (federalregister.gov) for rules, proposed rules, notices, presidential documents and executive orders by keyword, agency (name, short name such as EPA, or slug), type, | typed |
pii_detect | Detect and redact PII in text: emails, phone numbers (E.164, NANP, keyword-anchored national), credit cards (Luhn + issuer prefix/length, brand), US SSNs (SSA validity rules) and IBANs (registry lengt | typed |
food_barcode | Food product facts by barcode (EAN-13, EAN-8, UPC-A, UPC-E; GTIN check digit validated) from Open Food Facts (ODbL): name, brand, quantity, categories, ingredients text, allergens and traces, additive | typed |
text_diff | Diff two texts: unified line diff byte-compatible with GNU diff -u (hunks, context, "No newline at end of file"), or word-level / character-level diff with [-removed-]{+added+} inline markup and merge | typed |
contact_extract | Extract public business contact details from a website: email addresses (mailto, visible text incl. [at]/[dot] obfuscation, Cloudflare-protected, JSON-LD) tagged role/personal and same-domain, phone n | typed |
seo_audit | On-page SEO audit of one URL with a 0-100 score, letter grade and prioritised issues (high/medium/low): title and meta description length, robots meta and X-Robots-Tag noindex, canonical, lang, viewpo | typed |
weather_global | Worldwide weather forecast for any latitude/longitude from MET Norway Locationforecast 2.0 (the Norwegian Meteorological Institute; CC BY 4.0): current conditions (temperature, humidity, wind speed an | typed |
github_trending | Trending new GitHub repositories: repos created in the last day, week or month ranked by stars (GitHub REST search API), filterable by language, topic and minimum stars. Returns full name, URL, descri | typed |
json_repair | Repair broken or LLM-style JSON into valid JSON: strips markdown fences and surrounding prose, comments, trailing/missing commas, single or smart quotes, unquoted keys and values, Python/JS literals ( | typed |
sentiment | Sentiment analysis with VADER (Hutto & Gilbert 2014; MIT), the lexicon-and-rules model tuned for social media, reviews and short text: compound score (-1..1), positive/neutral/negative proportions and | typed |
eol_check | Is this software version still supported? End-of-life status from endoflife.date for 400+ products (languages, frameworks, databases, OSes, runtimes, cloud services): status (supported, security-only, | typed |
text_chunk | Split text into retrieval-ready chunks for RAG and embeddings: recursive (paragraph > line > sentence > clause > word), markdown-aware (splits on headings, keeps the heading path per chunk, respects c | typed |
hash_encode | Hashing, HMAC and encoding toolkit: digests (MD5, SHA-1/2/3, Keccak-256 as used by Ethereum, RIPEMD-160, Whirlpool, CRC32/CRC32C, Adler-32, FNV-1a, xxHash32/64/3/128, MurmurHash3), HMAC (SHA-1/2/3, MD | typed |
census_geographies | US Census Bureau geocoder: a one-line US street address (or a lat/lon) to matched address and coordinates plus Census geographies: state and county with FIPS codes, census tract, block group and block | typed |
evm_contract_info | EVM contract introspection on Ethereum, Base, Arbitrum, OP Mainnet, Polygon or BNB Chain via public RPC: bytecode size/hash, EIP-1167 / EIP-1967 / ZeppelinOS / EIP-7702 proxy detection, ERC-165/20/721 | typed |
evm_token_transfers | Latest ERC-20 or ERC-721 Transfer events for a token contract (optionally filtered to one wallet, in/out/both) on six EVM chains. Adaptive eth_getLogs window with automatic shrink on provider range ca | typed |
evm_allowance | ERC-20 allowance matrix for an owner across up to 10 tokens × 10 spenders (defaults: major stables/WETH × Uniswap Permit2, 1inch, CoW, 0x, OpenSea Seaport — verified deployed on-chain). Also reports E | typed |
evm_gas | Live gas tracker across Ethereum, Base, Arbitrum, OP Mainnet, Polygon and BNB Chain: head block age, base fee, 10th/50th/90th percentile priority fees from eth_feeHistory, suggested maxFeePerGas tiers | typed |
hof_h | The nth Hofstadter H term. H(0) is 0, and H(n) = n - H(H(H(n-1))). H(1) is 1, and H(10) is 7. n runs from 0 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST | typed |
nft_metadata | ERC-721 / ERC-1155 token metadata: tokenURI/uri (ipfs/arweave/data/https), ownerOf, collection name/symbol/supply, EIP-2981 royalty. Metadata JSON is fetched SSRF-safe via target_fetch (public-IP pinn | typed |
evm_read | Read-only eth_call of any view/pure function from a human signature (e.g. balanceOf(address)(uint256) or `function name() view returns (string)`). ABI-encodes args, decodes outputs (address/uint/int/b | typed |
prompt_injection_scan | Offline prompt-injection / jailbreak / exfiltration scanner: 10 rule families (ignore-instructions, reveal-system, role-hijack, delimiter-escape, tool/secret dump, encoding smuggle, policy bypass, aut | typed |
airport_status | US airport delay status from the FAA NAS Status feed (ground delay programs, ground stops, closures, arrival/departure delays) plus OurAirports metadata (name, city, ICAO/IATA, lat/lon). Pass ?airport | typed |
dockerfile_lint | Offline Dockerfile linter: parses stages/continuations and runs 20+ best-practice and security rules (latest tag, curl|bash, secrets in ENV/ARG, runs-as-root, chmod 777, ADD-vs-COPY, apt cache, no HEA | typed |
regex_test | Offline PCRE2 regex tester (JS-compatible i/m/s/u flags): match (with offsets + capture groups), replace, or split. Hard caps on backtracking/recursion and a structural ReDoS warning. Pattern max 2 KB | typed |
sec_financials | Normalized financial statements for any SEC filer by ticker or CIK, straight from EDGAR XBRL: revenue, gross profit, operating income, net income, EPS, assets, liabilities, equity, cash, debt, operati | typed |
fund_holdings | Mutual fund / ETF portfolio from its latest public SEC Form N-PORT: top holdings by value (name, CUSIP, ISIN, LEI, shares, USD value, % of net assets, asset and issuer category, country, maturity/coup | typed |
fda_adverse_events | FDA adverse-event reports (openFDA): drug FAERS, device MAUDE, food/supplement CAERS. Filter by drug, product, reaction, dates or raw openFDA search; compact reports or counts on any field (e.g. top r | typed |
jsonpath | Query JSON with JSONPath (RFC 9535): dot and bracket names, indexes, slices, wildcards, recursive descent (..) and filters with comparisons, && || !, and length() / count() / match() / search() / valu | incomplete |
fda_recalls | FDA recalls (openFDA): drug, device and food enforcement reports (class, status, firm, reason, distribution, lots) plus the device recall database (root cause). Filter by firm, product, class, status, | typed |
fda_device | FDA device records (openFDA): 510(k) clearances, PMA approvals, device classification (product code, class, regulation) and GUDID device identifiers. Search by name, product code, applicant, K/PMA num | typed |
bls_series | Any BLS time series by id (CPI, payrolls, unemployment, state/metro LAUS, PPI, JOLTS, ECI ...) for a year range: observations newest first with preliminary flags and footnotes, latest value, MoM / YoY | typed |
us_macro | US macro dashboard from BLS in one call: CPI and core CPI, unemployment, nonfarm payrolls, hourly earnings, participation, PPI and JOLTS openings. Latest value, month, MoM / YoY change and 13-month hi | typed |
ssl_blacklist | abuse.ch SSL Blacklist (SSLBL): check whether a TLS certificate SHA1 fingerprint is blacklisted as malware / botnet C&C infrastructure (listing date and reason, e.g. "QuasarRAT C&C"), check an IP agai | typed |
ping | Paid x402 test route for agents and client developers: the cheapest way to prove your x402 client signs a Solana USDC payment and the facilitator settles it before you call anything expensive. Returns | typed |
evm_block | One EVM block by number, tag (latest, safe, finalized, earliest, pending) or hash on Ethereum, Base, Arbitrum, OP Mainnet, Polygon or BNB Chain: timestamp and age, transaction count, gas used/limit an | typed |
evm_logs | Decoded event logs for any contract and event on Ethereum, Base, Arbitrum, OP Mainnet, Polygon or BNB Chain: give the event as a human signature (e.g. "Transfer(address indexed from, address indexed t | typed |
evm_address_activity | Where is this address used? One call checks an EVM address on Ethereum, Base, Arbitrum, OP Mainnet, Polygon and BNB Chain: native balance, nonce (transactions sent), contract or EOA, EIP-7702 delegati | typed |
sol_priority_fees | Solana priority-fee estimator from getRecentPrioritizationFees (last ~150 slots), globally or for the accounts your transaction writes to: min / p25 / median / p75 / p90 / p95 / max in micro-lamports | typed |
sol_network | Solana mainnet status in one call: current slot and block height, epoch with progress % and estimated time to the next epoch, average slot time, total and non-vote TPS from recent performance samples, | typed |
sol_signatures | Recent transaction signatures that touched a Solana address (wallet, token account, mint or program), newest first, via getSignaturesForAddress: signature, slot, block time and age, success or error, | typed |
sol_account | Inspect any Solana account: exists or not, SOL balance (lamports), owner program with a readable name, executable flag, data size, rent-exempt minimum and status, and a classification (wallet, token a | typed |
sol_tx_status | Fast confirmation check for up to 100 Solana transaction signatures in one call (getSignatureStatuses with history search): found or not, processed / confirmed / finalized, success or the on-chain err | typed |
sol_validators | Solana validator set from getVoteAccounts: active and delinquent counts, total active stake, Nakamoto coefficient (fewest validators controlling > 33.3% of stake), the top validators by stake with com | typed |
crypto_address_validate | Offline validator and chain detector for up to 50 crypto addresses: EVM (EIP-55 checksum, returns the checksummed form), Bitcoin (P2PKH, P2SH, SegWit v0 bech32, Taproot bech32m, testnet), Solana (32-b | typed |
token_units | Exact (string-math, no floating point) conversion between human token amounts and on-chain base units: wei / gwei / ether, lamports / SOL, sats / BTC, USDC/USDT (6 decimals) or any token with a decima | typed |
abi_encode | Build EVM calldata offline: function selector + ABI-encoded arguments from a human signature such as transfer(address,uint256) or exactInputSingle((address,address,uint24,address,uint256,uint256,uint1 | typed |
evm_create_address | Predict EVM contract addresses before deployment: CREATE (deployer + nonce, RLP-encoded; up to 50 consecutive nonces) or CREATE2 (deployer + salt + init code or its keccak256 hash, EIP-1014). Works fo | typed |
evm_verify_signature | Verify an Ethereum signature offline: recovers the signer address (secp256k1 ecrecover) from an EIP-191 personal_sign message (UTF-8 or hex) or a raw 32-byte digest (e.g. an EIP-712 hash), compares it | typed |
eip712_hash | EIP-712 typed-data hashing and signature check: returns encodeType, typeHash, domain separator, struct hash and the final digest a wallet signs (eth_signTypedData_v4), and with a signature recovers th | typed |
css_resolution | Convert a CSS resolution among dppx, dpi and dpcm. The alias x means dppx. One dppx is 96 dpi, and one inch is 2.54 cm, so one dpcm is 127/4800 dppx. Exact rationals. Price: $0.001 USDC per successful | typed |
sol_pda | Derive Solana program-derived addresses offline: findProgramAddress (canonical bump search) for any program and typed seeds (utf8, base58 pubkey, hex, u8/u16/u32/u64 little- or big-endian), or the ass | typed |
impermanent_loss | Impermanent loss calculator for AMM liquidity positions: full-range constant-product pools (Uniswap v2, Raydium, Orca classic) or concentrated ranges (Uniswap v3/v4, Orca Whirlpools, Raydium CLMM, Met | typed |
liquidation_price | Liquidation calculator. mode=perp: isolated-margin long/short liquidation and bankruptcy price from entry price, leverage and maintenance margin rate (optionally size and fees), with distance to liqui | typed |
position_size | Risk-based position sizing for trading agents: from account balance, risk per trade (percent or fixed amount), entry and stop price returns units to buy/sell, notional, leverage needed, stop distance, | typed |
loan_amortization | Loan / mortgage amortization: periodic payment, total interest, payoff date and a yearly or full payment schedule (principal, interest, balance) for any rate, term and payment frequency (monthly, bi-w | typed |
inet_checksum | RFC 1071 internet checksum. Big-endian 16-bit words are added with end-around carry, then inverted. An odd final byte is padded with zero. The RFC example 0001 F203 F4F5 F6F7 is 220d. Price: $0.001 US | typed |
npv_irr | Investment appraisal for a cash-flow series: NPV at a discount rate, IRR (all roots for non-conventional flows), MIRR, profitability index, simple and discounted payback; with dates gives Excel-compat | typed |
compound_interest | Compound growth / savings calculator: future value of a principal plus monthly contributions at any compounding frequency (incl. continuous), contributions at start or end of month, inflation-adjusted | typed |
black_scholes | European option pricing (Black-Scholes-Merton with continuous dividend yield): call and put prices, delta, gamma, vega, theta per day, rho, d1/d2 and probability of finishing in the money; with a mark | typed |
bond_calc | Fixed-coupon bond math: price from yield or yield to maturity from price (clean and dirty, with accrued interest for fractional periods), current yield, Macaulay and modified duration, convexity and D | typed |
technical_indicators | Technical analysis on a price series you supply: SMA, EMA, RSI (Wilder), MACD (line, signal, histogram), Bollinger Bands (%B, bandwidth), ATR, Stochastic %K/%D, OBV, VWAP and rate of change, with late | typed |
json_schema_infer | Infer a JSON Schema (draft 2020-12) from one JSON document or many samples: types (integer vs number), nested objects and arrays, required keys (present in every sample), nullable fields, string forma | incomplete |
portfolio_metrics | Portfolio and asset risk/return analytics from price or return series you supply: annualised return (CAGR) and volatility, Sharpe and Sortino ratios, max drawdown, historical and parametric 95% VaR, b | typed |
mortgage_affordability | How much house can I afford: maximum home price and loan from income, monthly debts, down payment and rate under front-end / back-end debt-to-income limits (default 28/36), with a full monthly PITI br | typed |
unit_economics | SaaS / subscription unit economics: customer lifetime value (margin-adjusted), LTV:CAC ratio, CAC payback months, average lifetime, MRR/ARR, break-even customer count and cash runway, with health rati | typed |
depreciation | Depreciation schedules: straight-line, declining balance (any factor, optional switch to straight-line), double-declining, sum-of-the-years-digits and US MACRS GDS (3/5/7/10/15/20-year, half-year conv | typed |
json_diff | Structural diff of two JSON documents: list of added / removed / changed values with JSON Pointer paths and old/new values, an RFC 6902 JSON Patch that turns a into b, and counts. Arrays are aligned b | incomplete |
json_patch | Apply a JSON Patch (RFC 6902: add, remove, replace, move, copy, test) or a JSON Merge Patch (RFC 7386) to a JSON document and return the result. Atomic: any failing operation or test returns 422 with | incomplete |
json_to_types | Generate typed models from sample JSON: TypeScript interfaces, Zod schemas, Python Pydantic models, Go structs (json tags) or Rust serde structs. Nested objects become named types, optional and nullab | incomplete |
csv_profile | Profile a CSV/TSV dataset: delimiter detection, row and column counts, per-column inferred type (integer, decimal, boolean, date, datetime, string), null/empty counts, distinct values, min/max/mean/me | typed |
csv_to_sql | Turn CSV/TSV into SQL: CREATE TABLE with inferred column types (integer/bigint, numeric, boolean, date, timestamp, varchar/text, NOT NULL where never empty, optional primary key) and batched INSERT st | typed |
sql_format | Format and lint SQL: consistent keyword case, one clause per line, indented select lists, joins, AND/OR conditions and subqueries, comments and string literals preserved; or minify. The linter flags U | typed |
json_canonicalize | RFC 8785 JSON Canonicalization Scheme (JCS): deterministic serialization with keys sorted by UTF-16 code units and ECMAScript number formatting, plus SHA-256 / SHA-512 digests of the canonical bytes f | incomplete |
xml_xpath | Run XPath 1.0 queries over XML you supply (RSS/Atom, SOAP, sitemaps, SVG, config) or over HTML for scraping: returns matched elements/attributes/text with their paths, text, attributes and outer marku | typed |
semver | Semantic versioning toolkit with npm (node-semver) semantics: validate and parse a version, compare two versions, test a range (^, ~, x-ranges, hyphen ranges, || unions, prerelease rules) and show its | typed |
radical | The radical of n, the product of its distinct prime factors. rad(1) is 1, rad(12) is 6, and rad(36) is 6. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same to | typed |
cidr_calc | IPv4 / IPv6 subnet calculator: network and broadcast/last address, netmask, wildcard, first/last usable host, address and host counts, address type (private, CGNAT, documentation, ULA, link-local...), | typed |
ip_range_merge | Aggregate IP allow/deny lists: merges any mix of IPv4/IPv6 addresses, CIDRs, "a-b" ranges and "ip netmask" entries into the minimal set of CIDR blocks, optionally subtracts an exclude list, reports ad | typed |
user_agent_parse | Parse User-Agent strings: browser and version, rendering engine, OS and version, device type (mobile, tablet, desktop, TV, console, bot) with vendor/model, and bot detection that names 100+ crawlers a | typed |
url_parse | Parse, normalize and clean URLs offline: scheme, credentials (redacted), host type, port, path segments, decoded query parameters and fragment; registrable domain / subdomain / public suffix; IDN to p | typed |
unit_convert | Unit conversion across 14 categories with exact defined factors: length, mass, volume (US and imperial), area, speed, time, data (SI kB vs IEC KiB, bits vs bytes), pressure, energy, power, angle, freq | typed |
color_convert | Convert a colour between HEX, RGB(A), HSL, HSV, CMYK, CIE Lab and OKLCH (any CSS colour syntax or one of the 148 CSS names in), with relative luminance, contrast against white and black, the readable | typed |
color_palette | Generate colour palettes from one base colour: complementary, analogous, triadic, split-complementary, tetradic and monochromatic schemes plus an 11-step 50-950 shade scale (Tailwind-style, perceptual | typed |
summarize_extractive | Extractive summary with TextRank (Mihalcea & Tarau 2004): sentences are split (abbreviation / initial / decimal aware), linked by stemmed content-word overlap, ranked with PageRank, and the top N are | typed |
timestamp_convert | Convert any timestamp: auto-detects Unix seconds / milliseconds / microseconds / nanoseconds, ISO 8601 / RFC 3339, RFC 2822, HTTP dates, Excel serial dates and "now", and returns all of them plus loca | typed |
string_case | Convert identifiers and phrases between naming conventions: camelCase, PascalCase, snake_case, SCREAMING_SNAKE_CASE, kebab-case, Train-Case, dot.case, path/case, Title Case (small words kept lower), S | typed |
x509_decode | Decode PEM/DER X.509 certificates, chains and CSRs offline: subject/issuer DN, serial, validity and days left, SANs, key type/size/curve, signature algorithm, key usage / EKU / basic constraints, AKI/ | typed |
ssh_key_info | Inspect SSH public keys and OpenSSH certificates from authorized_keys, known_hosts, .pub, RFC 4716 or PEM input: key type, size / curve, SHA256 and MD5 fingerprints exactly as ssh-keygen prints them, | typed |
secret_scan | Scan code, config, logs, diffs or prompts for leaked credentials before you commit, share or send them to an LLM: 50+ rules (AWS, GitHub, GitLab, Slack, Stripe, Google, OpenAI, Anthropic, xAI, Hugging | typed |
ioc_extract | Extract indicators of compromise from threat reports, alerts, logs or emails: IPv4/IPv6 (private ranges optional), domains (TLD-validated, file-name false positives suppressed), URLs, email addresses, | typed |
cvss_calc | Score and explain any CVSS vector: v4.0 (official FIRST macrovector algorithm, CVSS-B/BT/BE/BTE nomenclature, macrovector and severity breakdown), v3.1 and v3.0 (base, impact / exploitability subscore | typed |
midi_note | A written note or a MIDI number. Middle C is C4, which is 60. C-1 is 0 and G9 is 127. The name you pass keeps its spelling, so B#3 stays B#3 even though it is the same key as C4. sharp and flat are th | typed |
csp_evaluate | Evaluate a Content-Security-Policy string the way CSP Evaluator does, before you ship it: parses directives, catches typos, unquoted keywords and deprecated directives, then checks script execution (u | typed |
gha_workflow_lint | Security audit of a GitHub Actions workflow YAML (zizmor / actionlint style): pwn-request checkouts under pull_request_target / workflow_run, script injection from attacker-controlled ${{ github.event | typed |
k8s_manifest_lint | Security and reliability audit of Kubernetes YAML (multi-document, List kinds; kubesec / kube-score style): privileged containers, root users, privilege escalation, dangerous capabilities, host namesp | typed |
html_sanitize | Sanitize untrusted HTML (LLM output, user comments, scraped pages, email bodies) with a strict allowlist before rendering it: three profiles (strict inline formatting, basic with links and lists, rich | typed |
email_parse | Parse a raw email (.eml / RFC 5322 + MIME) for triage: decoded headers (RFC 2047), addresses, Received hop chain with relays, IPs, timestamps and delays, originating IP, Authentication-Results (SPF / | typed |
keyword_extract | Keyphrase extraction for tagging, SEO and RAG metadata: RAKE (rapid automatic keyword extraction: candidate phrases split at stopwords/punctuation, scored by word degree / frequency) or TextRank (co-o | typed |
music_interval | The interval between two written notes. The number comes from the letters and the quality from the semitones, so C to E is a major third and C to Fb is a diminished fourth. Direction follows the writt | typed |
fuzzy_match | Fuzzy string matching for entity resolution, dedupe and "did you mean": match one or many queries against up to 5,000 choices with RapidFuzz-style scorers (WRatio weighted blend, ratio / InDel similar | typed |
text_similarity | Document similarity and near-duplicate detection: compare two texts (a, b) or cluster up to 200 texts. Metrics: TF-IDF cosine on stemmed content words, word Jaccard, k-word shingle Jaccard and contain | typed |
entity_extract | Rule-based entity and value extraction with normalised values: dates (ISO, numeric with dmy/mdy, month names, relative "next Friday" / "in 3 days" resolved against a reference date), times with time z | typed |
profanity_filter | Profanity, sexual-language and slur filter for chat, usernames, reviews and LLM output: token-level matching (no Scunthorpe false positives) with obfuscation handling (leetspeak f4ck / sh1t, masked le | typed |
scam_text_score | Scam / fraud likelihood for messages, DMs, emails, posts and listings: 16 pattern families (crypto doubling giveaways, seed-phrase and private-key solicitation, wallet-connect / airdrop lures, fake su | typed |
music_transpose | Move a written note by a named interval. The letter moves with the interval number, then the accidental is chosen to hit the semitones. A perfect third is rejected, and so is a quality that would need | typed |
license_detect | Identify a software / content licence from a LICENSE file, source header or SPDX expression and explain what it allows: 40 licences incl. MIT, Apache-2.0, BSD-2/3/4, ISC, 0BSD, GPL/LGPL/AGPL v2/v3, MP | typed |
markdown_to_html | Render Markdown to safe HTML: CommonMark-style blocks (ATX / setext headings, paragraphs, block quotes, nested ordered / bullet lists, fenced and indented code with language classes, thematic breaks) | typed |
text_clean | Clean and normalise messy text before embedding, indexing or prompting: repairs mojibake (UTF-8 read as Windows-1252), strips control and invisible characters (zero-width, bidi overrides used in Troja | typed |
geo_distance | Geodesic distance and bearings on the WGS-84 ellipsoid: Vincenty (millimetre accuracy) plus great-circle haversine, initial / final bearing with 16-point compass, midpoint, multi-point path length wit | typed |
coord_convert | Convert a location between coordinate formats in one call: decimal degrees, DMS, degrees-decimal-minutes, UTM (Krüger series, WGS-84, Norway / Svalbard zones), MGRS military grid, geohash (with cell s | typed |
geo_polygon | Analyse GeoJSON polygons (Polygon, MultiPolygon, Feature or FeatureCollection): geodesic area (m², km², ha, acres; same spherical formula as Turf.js), perimeter, area-weighted centroid, bounding box, | typed |
sun_times | Sunrise, sunset, solar noon, day length, civil / nautical / astronomical twilight, golden hour and blue hour for any place and date (NOAA solar calculator equations, about a minute of accuracy), with | typed |
moon_phase | Moon phase for any moment: phase name and emoji, illuminated fraction, phase angle, age in days since new moon, waxing / waning, Earth-Moon distance and apparent size, the next new moon / first quarte | typed |
date_calc | Calendar-correct date arithmetic in any IANA zone: add or subtract durations (ISO 8601 or plain English, months clamp to month end so Jan 31 + 1 month = Feb 28/29), exact difference between two dates | typed |
duration_parse | Parse any duration into seconds and every common format: ISO 8601 (P1DT2H30M, PT1.5S, P2W), clock (1:02:03.5, 02:30), Go / compact (1h30m, 2d4h), and plain English ("an hour and a half", "2.5 days", " | typed |
rrule_expand | Expand an iCalendar RFC 5545 RRULE (recurring event rule, as used by Google Calendar, Outlook, CalDAV) into concrete occurrences in any IANA zone, DST-correct, with an English description. Supports FR | typed |
llms_txt | Read a site's llms.txt (the llmstxt.org convention that tells AI agents where the useful docs are), SSRF-safe: title, summary, details and every section's links (title, absolute URL, notes; "Optional" | typed |
quat_norm | Conjugate and squared length of a quaternion. (1, 2, 3, 4) has squared length 30 and conjugate (1, -2, -3, -4). Unit means the squared length is 1. Price: $0.001 USDC per successful call (x402, Solana | typed |
meeting_planner | Find the best meeting times across time zones: give 2-20 IANA zones (optionally with per-person hours like Asia/Tokyo@08:00-18:00) and a date; returns the windows where everyone is inside working hour | typed |
fitness_calc | Body and training calculator in one call, metric or imperial: BMI with WHO category and healthy-weight range, BMR (Mifflin-St Jeor, revised Harris-Benedict, Katch-McArdle), TDEE by activity level, cal | typed |
html_tables | Extract HTML tables from a public URL (SSRF-safe fetch) or an HTML string into clean JSON: header detection (thead or leading th rows, multi-row headers joined), rowspan / colspan expansion, captions, | typed |
html_select | Scrape a public page (SSRF-safe fetch) or an HTML string with a CSS selector (CSS3 plus :has, :contains, :nth-child(an+b), attribute operators) or raw XPath: returns each match's text, attributes and | typed |
schema_org_extract | Extract all schema.org structured data from a public page (SSRF-safe fetch) or HTML: JSON-LD (including @graph), microdata (nested itemscope / itemref) and RDFa Lite, normalised to typed items, plus a | typed |
security_txt | Fetch and validate a site's security.txt (RFC 9116) for vulnerability disclosure: tries /.well-known/security.txt then the legacy /security.txt (SSRF-safe), parses Contact / Expires / Encryption / Pol | typed |
openapi_summary | Summarise an OpenAPI 3.x or Swagger 2.0 API from a URL (SSRF-safe) or an inline JSON / YAML spec, so an agent can learn an API fast: title, version, servers / base URLs, auth schemes (API key, bearer, | typed |
ics_parse | Parse an iCalendar (.ics) feed from a URL (SSRF-safe; Google / Outlook / Apple calendar exports) or inline text into JSON: calendar name and zone, events with start / end in any IANA zone, all-day fla | typed |
link_check | Find broken links on a public web page (or in supplied HTML, e.g. a draft before publishing): fetches the page (SSRF-safe), extracts links (optionally images / scripts / stylesheets too), then checks | typed |
reverse_dns | Reverse DNS (PTR) for up to 20 IPv4 / IPv6 addresses with forward-confirmed reverse DNS (FCrDNS: does the PTR hostname resolve back to the same IP?), PTR name, TTL and NXDOMAIN / SERVFAIL status, over | typed |
dnssec_check | DNSSEC status of a domain over DNS-over-HTTPS: secure / insecure / bogus (validation failure) / island (signed but no DS at the parent), the zone apex, DS records (key tag, algorithm, digest type) and | typed |
barcode_generate | Generate a 1D barcode as SVG (plus base64 data URI and the raw module pattern): Code 128 (any ASCII, automatic A / B / C subset switching for the shortest symbol), GS1-128 shipping / logistics labels | typed |
music_scale | Spell a scale on letters from a tonic. Major, minor, harmonic minor, melodic minor (the ascending form), the church modes, pentatonic, minor pentatonic, and blues. G# major is written with E# and F##, | typed |
password_generate | Generate strong secrets with a CSPRNG (never stored or logged): random passwords (length, character classes, custom symbols, exclude look-alike characters, guarantee one of each class), diceware-style | typed |
id_generate | Generate unique IDs: UUID v4 (random), v7 (time-ordered, monotonic within a batch), v5 (deterministic from namespace + name), ULID, nanoid (custom size / alphabet), KSUID and MongoDB ObjectId, up to 1 | typed |
fake_data | Generate realistic, reproducible fake test data from a field schema: up to 1,000 records with 44 field types (names, usernames, emails consistent with the name, phones, companies, job titles, US addre | typed |
chart_svg | Render a chart to a standalone SVG (plus base64 data URI) for reports, dashboards, emails and agent answers: bar, horizontal bar, stacked bar, line, area, scatter, pie and donut. Multiple series with | typed |
file_type_detect | Identify what a file really is from its bytes (not its name): 80+ signatures (images, audio, video, archives, PDF / Office / OpenDocument / EPUB, executables ELF / PE / Mach-O / WASM, fonts, SQLite / | typed |
curl_to_code | Convert a curl command (copied from browser dev tools, API docs or a terminal) into ready-to-run code: Python requests, JavaScript fetch, Node axios, Go net/http, PHP curl, Rust reqwest, HTTPie and Po | typed |
markdown_table | Build or parse Markdown (GitHub-flavoured) tables. Build: from an array of objects, an array of arrays or CSV, with column selection / order / renaming, alignment (numeric columns right-aligned automa | incomplete |
dedupe_records | Find and remove duplicate records (CRM contacts, leads, customers, products) in a JSON array. Modes: exact, normalized (emails: case, Gmail dots and +tags; phones: punctuation and country prefix; URLs | typed |
ics_generate | Generate a standards-compliant iCalendar (.ics, RFC 5545) file from JSON events — ready for Google Calendar, Outlook and Apple Calendar invites or "add to calendar" links. Time zones with a generated | typed |
math_eval | Evaluate math expressions safely and exactly — the calculator agents should call instead of doing arithmetic in their heads. Exact rational arithmetic by default (0.1 + 0.2 = 3/10, 1/3 + 1/6 = 1/2, 2^ | typed |
equation_solve | Solve equations exactly where possible. Polynomials of any degree up to 100: exact rational roots, exact surd forms for quadratic factors ("(3 + √5)/2", complex "(-1 + i√3)/2"), multiplicities via squ | typed |
matrix_ops | Linear algebra on matrices, exactly where it matters. Determinant, inverse, RREF, rank, null space, linear solve (Ax = b), multiply, add / subtract, integer powers, trace and LU are computed with exac | typed |
stats_describe | Descriptive statistics for one or many numeric series: count / missing, mean, median, mode, range, sample and population variance / SD, standard error, CV, skewness and excess kurtosis (Excel SKEW / K | typed |
regression_fit | Fit a regression model and get the full statistical table, like R's summary(lm) or statsmodels. Linear, polynomial (degree 2–6), exponential (y = a·e^(bx)), logarithmic, power (y = a·x^b), multiple li | typed |
regex_explain | Explain, lint and test a regular expression before an agent ships it. Parses the pattern (PCRE, JavaScript, Python, Go/RE2, Java or .NET syntax) into a token-by-token plain-English explanation with ca | typed |
hypothesis_test | Run a statistical significance test and get the statistic, p-value, effect size, confidence interval and a plain-English verdict — results match scipy.stats. Tests: Welch / Student two-sample t, paire | typed |
number_to_words | Spell out numbers in words — cardinal, ordinal, currency amounts, cheque wording, years and Roman numerals — in English, Spanish, French, German, Italian, Portuguese (PT) and Brazilian Portuguese, wit | typed |
identicon_svg | Deterministic avatar SVG for any user id, email, wallet address or name — the same input always gives the same image, with no storage or external service. Styles: identicon (GitHub-style symmetric 5×5 | typed |
random_draw | Provably fair random draws for giveaways, raffles, games and A/B assignment. Pick winners from a list (unique or with replacement, optional weights), shuffle a list, split people into balanced teams, | typed |
jwk_convert | Convert public keys between PEM, JWK and OpenSSH formats and compute their identifiers — what an agent needs to publish a JWKS, configure an OIDC / JWT verifier or pin a key. Accepts SPKI or PKCS#1 PE | typed |
jwt_sign | Create or verify HMAC-signed JWTs (HS256 / HS384 / HS512) — for test fixtures, service-to-service tokens, webhook auth and debugging "invalid signature" errors. sign: builds header + claims with iat / | typed |
totp | TOTP / HOTP two-factor codes (RFC 6238 / 4226), compatible with Google Authenticator, Authy, 1Password and pyotp: generate the current code (plus previous / next and seconds remaining), verify a code | typed |
oauth_pkce | OAuth 2.0 PKCE helper (RFC 7636 / OAuth 2.1): generate a code_verifier with its S256 code_challenge plus random state and OIDC nonce, verify that a verifier matches a challenge, or build a complete au | typed |
webhook_verify | Verify (or create) webhook signatures for Stripe, GitHub, Slack, Shopify, Twilio, Standard Webhooks / Svix, Paddle, Square, Zoom, Mailgun, Intercom, Linear, Typeform and HubSpot v3, or any generic HMA | typed |
text_ellipsis | Cut one Helvetica line so it fits a width, ending with an ellipsis (…) when the text is too long. The ellipsis is the WinAnsi character. If the whole line already fits, it is returned unchanged. If ev | typed |
password_hash | Hash, verify and identify password hashes — for seeding users, migrating auth systems, writing htpasswd files and auditing leaked hash formats. hash: bcrypt, Argon2id / Argon2i (where the server has l | typed |
saml_decode | Decode and inspect SAML 2.0 messages for SSO debugging: paste a SAMLResponse / SAMLRequest (base64 from an HTTP-POST form, deflated + URL-encoded from an HTTP-Redirect URL, the whole redirect URL, or | typed |
dmarc_report_parse | Parse DMARC aggregate (RUA) reports and SMTP TLS reports (TLS-RPT, RFC 8460) into an actionable summary. Accepts the raw XML / JSON or the email attachment as base64 (.xml, .xml.gz, .zip). DMARC: repo | typed |
pgp_key_info | Inspect an OpenPGP public key (ASCII-armored or base64 binary) the way gpg --show-keys does, offline: primary key and subkey fingerprints and key IDs (v4, v5 and RFC 9580 v6 keys), algorithm and size | typed |
cipher_suite_info | Look up TLS cipher suites by IANA name, OpenSSL name, GnuTLS name or hex code (0x13,0x01 / 0xC02F) — one or a whole list from a scanner, server config or ClientHello — and get key exchange, authentica | typed |
meid_validate | MEID, the CDMA equipment id. Hex is 14 digits with an optional Luhn check in base 16. Decimal is 18 digits (manufacturer and serial) with an optional decimal Luhn check, and it converts to the hex for | typed |
currency_format | Money formatting and math with CLDR data (ICU 78 / CLDR 48, matches Intl.NumberFormat): format an amount for any of 60 locales and 154 active ISO 4217 currencies (symbol, narrow symbol or code; standa | typed |
day_count | Day-count conventions and accrued interest for bonds, loans and swaps: days and year fraction between two dates under ACT/360, ACT/365F, ACT/ACT ISDA, NL/365, 30/360 (ISDA bond basis), 30/360 US (SIA | typed |
loan_apr | True cost of a loan including fees: the US Truth in Lending APR (Regulation Z actuarial method) and the EU APRC (Consumer Credit Directive annual effective rate), plus the payment, amount financed, fi | typed |
card_validate | Payment card number checks without storing anything: Luhn checksum, brand / network from the IIN (Visa, Mastercard incl. 2-series, Amex, Discover, Diners, JCB, UnionPay, Maestro, Mir, Elo, Hipercard, | typed |
bank_id_validate | Validate bank routing identifiers offline (IBAN is covered by /v1/iban-validate): US ABA routing numbers (3-7-1 checksum, Federal Reserve district, thrift / electronic ranges), SWIFT / BIC (bank, ISO | typed |
css_length | Convert one CSS absolute length. An inch is 96px and 2.54 cm, so a centimetre is 4800/127 px, a millimetre is 480/127 px, and Q (a quarter-millimetre) is 120/127 px. A point is 4/3 px and a pica is 16 | typed |
credit_payoff | Credit-card and revolving-balance payoff in exact cents. Give a balance, an annual percentage rate, and a fixed payment (or a minimum that is the greater of a percent of the new balance and a floor). | typed |
invoice_total | Invoice math in exact cents. Each line is quantity × unit price, then an optional line discount, rounded half away from zero to the cent. An invoice-level discount comes off the subtotal, then tax is | typed |
wage_calc | Gross pay in exact cents. Hourly: regular hours at the rate, overtime hours at a multiplier (default 1.5) and double-time hours at a multiplier (default 2). Weekly: hours above the threshold (default | typed |
prorate | Prorate a money amount across a date range, in exact cents. The window is half-open: from the start date up to but not including the end date. The charge is amount × days used / days in the period, ro | typed |
markup_margin | Price, margin and markup in exact cents. Analyze a cost and a price (margin is profit / price, markup is profit / cost). Or set a price from a cost and a margin percent (price = cost / (1 − margin)), | typed |
text_width | Width of one line in Helvetica or Helvetica-Bold, in points. Glyph widths are the Adobe standard-14 AFM numbers in WinAnsi (the same numbers ReportLab ships). The width is the sum times the font size, | typed |
text_wrap | Wrap text to a measure in Helvetica or Helvetica-Bold. Hard breaks are LF, CR, or CRLF. Inside a paragraph, spaces collapse to one and leading and trailing spaces are dropped. A word moves to the next | typed |
text_fit | Largest Helvetica size, on a fixed step, at which one line still fits a width. Sizes run from minSize to maxSize in steps (defaults 6, 72 and 0.5 points). Empty text fits at maxSize. If the line does | typed |
text_block | Wrap a Helvetica block and give its height. Line breaking is the same as text-wrap. Leading defaults to 1.2 times the font size, rounded half away from zero to 0.001 pt. Block height is the line count | typed |
isbn_validate | ISBN-10 and ISBN-13 check digit. Spaces and hyphens are ignored, and a 9-digit number is read as an ISBN-10 with a leading zero. ISBN-13 must use the 978 or 979 prefix. A valid ISBN-10 is also returne | typed |
issn_validate | ISSN check digit (8 characters, the last may be X). Spaces and hyphens are ignored. The formatted form is the two groups of four. Price: $0.001 USDC per successful call (x402, Solana). Same tool over | typed |
imei_validate | IMEI and IMEISV. A 15-digit IMEI must pass the Luhn check. A 14-digit IMEI has no check digit, and a 16-digit IMEISV has none either. Spaces and hyphens are ignored. This does not look the number up w | typed |
ean_validate | GTIN check digit for EAN-8, UPC-A (12 digits), EAN-13 and GTIN-14. The weight alternates 3 and 1 from the right, starting with 3 on the digit beside the check. Spaces and hyphens are ignored. This doe | typed |
isin_validate | ISIN check digit (ISO 6166). Two letters, nine letters or digits, one check digit. Letters expand to their alphabet position (A = 10) and the Luhn sum of that digit string must be 0. The prefix must b | typed |
cusip_validate | CUSIP check digit. Nine characters from digits, letters, and * @ #. Spaces are ignored and hyphens are not. From the left, values are weighted 1, 2, 1, 2 and the digits of those products sum to the ch | typed |
figi_validate | FIGI check digit. Twelve characters with no vowels. The first two are letters and are not BS, BM, GG, GB or VG, and the third character is G. The check uses the full A–Z alphabet, weights 1 and 2 from | typed |
lei_validate | LEI check digits, ISO 17442 with ISO 7064 mod 97-10. Twenty letters or digits, and the whole number is 1 mod 97. Spaces and hyphens are ignored. This does not look the entity up at GLEIF. Price: $0.00 | typed |
creditor_ref | ISO 11649 creditor reference. RF, two check digits, then up to 21 letters or digits. Spaces, hyphens, dots, commas, slashes and colons are ignored. The check moves RF and the two digits to the end and | typed |
container_check | ISO 6346 container check digit. Four letters (the fourth is U, J, Z or R), six serial digits and a check digit. Letter values skip every multiple of 11, then each value is multiplied by 2 to the power | typed |
cas_validate | CAS Registry Number check digit. Two to seven digits, a hyphen, two digits, a hyphen and a check digit. No leading zero. From the right, digits are weighted 1, 2, 3 and the total mod 10 is the check. | typed |
resistor_code | IEC 60062 resistor color code. Decode 3 to 6 bands, or encode a resistance that lands exactly on a digit-and-multiplier value. Digits run black=0 through white=9. Multipliers run from silver (×0.01) a | typed |
ohm_law | Ohm's law for one passive resistor. Give any two of voltage (volts), current (amperes), resistance (ohms) and power (watts). The other two come back as exact rationals. A third or fourth value is chec | typed |
voltage_divider | Unloaded voltage divider. r1 is the top resistor, from the supply to the output. r2 is the bottom resistor, from the output to ground. Returns the output voltage, the string current, and the power in | typed |
resistor_network | Series or parallel equivalent of 2 to 24 resistances. Series adds them. Parallel is the reciprocal of the sum of the reciprocals. Exact rationals. Every value must be positive. One block only: a mixed | typed |
led_resistor | Series resistor for LEDs on one supply. Resistance is (supply − series × forward) / current, with volts and amperes. The part chosen is the next IEC 60063 E24 value at or above that resistance, so the | typed |
mac_address | Normalize a MAC-48 or EUI-64. Accepts colon, hyphen, Cisco dotted (groups of four) or plain hex, any case. Returns lowercase colon, hyphen, dotted and compact forms. multicast is the I/G bit, the low | typed |
eui64 | Modified EUI-64 from RFC 4291. A 48-bit MAC is expanded by flipping the U/L bit and inserting FF-FE in the middle. A 64-bit value with FF-FE in the middle is folded back to the MAC. Any other 64-bit v | typed |
slaac_address | IPv6 address a host builds for itself from a /64 prefix and a MAC (SLAAC, RFC 4862). The interface id is the modified EUI-64. The prefix must be exactly 64 bits and the low 64 bits of the prefix must | typed |
solicited_node | IPv6 solicited-node multicast address, ff02::1:ffXX:XXXX, from the low 24 bits of an IPv6 address or from the last three octets of a MAC. The U/L flip does not change those 24 bits, so the MAC and its | typed |
mac_local | A stable locally administered unicast MAC from a seed. SHA-256 of the seed, first six bytes, multicast bit cleared and the U/L bit set. The same seed always returns the same MAC. This is not a random | typed |
selector_specificity | Specificity of one CSS selector, from Selectors Level 4. a is IDs. b is classes, attributes and pseudo-classes. c is elements and pseudo-elements. :is(), :not() and :has() use only the most specific a | typed |
file_mode | Explain a POSIX file mode. Accepts octal (755, 0755, 4755) or the 9-character ls form, with an optional leading type character. s and t mean the execute bit is also set; S and T mean the special bit w | typed |
chmod_apply | Apply a chmod mode to a starting mode. The grammar is GNU chmod: symbolic [ugoa]*([-+=][rwxXst]* or one of ugo), comma separated, or =644 / +1, or a bare octal. No spaces. If who is omitted, bits set | typed |
umask_mode | Mode of a file or directory created under a umask. A file starts from 666 and a directory from 777, then the umask bits are cleared. 022 makes a file 644 and a directory 755. masked lists the bits the | typed |
permission_check | Whether one class may read, write, or execute under a mode. Pass the class that applies: on a real system the owner class is used for the owner even when the group bits differ. setuid, setgid and stic | typed |
mode_diff | Bits that differ between two POSIX modes. added and removed run from the special bits down through owner, group and other. same is true when nothing differs. Price: $0.001 USDC per successful call (x4 | typed |
float_bits | Explain an IEEE 754 binary32 or binary64 value. Pass bits as hex, or a decimal or fraction, which is rounded ties-to-even. Returns the class, sign, unbiased exponent, fraction bits, and the exact valu | typed |
float_round | Round an exact decimal or fraction to binary32 or binary64. Modes are nearestEven, towardZero, towardPositive, and towardNegative. Ties in nearestEven go to an even fraction bit. Overflow becomes infi | typed |
float_next | The next binary32 or binary64 value up or down. Positive zero and negative zero both step up to the smallest positive subnormal, and both step down to the smallest negative one. Infinity stays put at | typed |
float_ulp | Unit in the last place of a binary32 or binary64 value. A power of two uses the spacing of its own binade. Zero uses the smallest subnormal. Infinity uses positive infinity. A NaN is returned with its | typed |
float_order | IEEE 754 totalOrder on two binary32 or binary64 values. Negative zero is below positive zero. Negative NaNs are below minus infinity and positive NaNs are above plus infinity. A larger NaN payload is | typed |
music_chord | Spell a chord up from a root: major, minor, diminished, augmented, sus2, sus4, dom7, maj7, min7, dim7, half-dim7, and sixth. Letters stay in thirds except the suspensions and the sixth. A diminished s | typed |
paper_size | ISO 216 A, B and C sizes, plus the DL envelope, in millimeters. Portrait, so the width is the shorter side. Inches are exact millimeters divided by 25.4. A4 is 210 by 297. Set landscape to swap the si | typed |
paper_next | The next larger and smaller sheet in the same ISO series. A4 sits between A3 and A5. A0 has no larger size and A10 has no smaller one. DL is not in a series. Price: $0.001 USDC per successful call (x4 | typed |
paper_fit | How many copies of one sheet fit on another at full size. The copy may be turned. Two A4 pages fill an A3 and the waste is zero. count is 0 when it does not fit. orientation is how the copy sits, or n | typed |
paper_scale | The largest scale that places one sheet on another, turning it when that lets it be larger. The scale is an exact ratio of the millimeter sides. Below one, the sheet has to shrink. Price: $0.001 USDC | typed |
envelope_fit | The smallest ISO C envelope that holds a sheet flat, and whether a DL envelope holds it flat or folded in exact thirds. C4 holds A4. DL does not hold A4 flat; it holds A4 folded in thirds. A sheet big | typed |
timecode_frames | Count the frames in an SMPTE timecode from midnight. Rates are 24, 25 and 30. A colon is non-drop and a semicolon is drop-frame, which is only legal at 30. Drop-frame skips 00 and 01 at the start of e | typed |
frames_timecode | Write a frame count since midnight as SMPTE timecode. Set drop for 30 fps drop-frame. The count has to land inside one day. 30 frames at 30 fps is 00:00:01:00. Price: $0.001 USDC per successful call ( | typed |
timecode_add | Add a signed frame count to a timecode and stay inside the same day. A result before midnight or at the next midnight is rejected. The semicolon, if present, keeps the result in drop-frame. Price: $0. | typed |
timecode_diff | How many frames from one timecode to another, at the same rate. Positive means to is later. Both codes use a colon, or both use a semicolon. Mixing drop-frame with non-drop is rejected. Price: $0.001 | typed |
timecode_duration | Exact length of a frame count. 24, 25 and non-drop 30 use 1/rate second per frame. Drop-frame 30 uses the NTSC frame, 1001/30000 second. Pass a timecode or a frame count, not both. The semicolon selec | typed |
crc16 | CRC-16 over text or hex bytes. Algorithms are CCITT-FALSE, ARC, XMODEM, KERMIT and MODBUS. The check string 123456789 is 29b1 in CCITT-FALSE. This is not CRC-32. Price: $0.001 USDC per successful call | typed |
fletcher16 | Fletcher-16 checksum, modulus 255. The two sums are packed with the second sum in the high byte. "abcde" is c8f0. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST http | typed |
fletcher32 | Fletcher-32 checksum, modulus 65535. Bytes are big-endian 16-bit words. An odd final byte is padded with zero. "abcde" is 4ff029c7. Price: $0.001 USDC per successful call (x402, Solana). Same tool ove | typed |
byte_sum | The two historic Unix sums, matching GNU sum. bsd rotates the 16-bit sum right and counts 1024-byte blocks. sysv reduces modulo 65535, keeps 65535 when the total is a positive multiple of it, and coun | typed |
cf_expand | Continued fraction of a non-negative rational, by the Euclidean algorithm. 13/8 is [1; 1, 1, 1, 2]. 355/113 is [3; 7, 16]. A trailing 1 is folded into the previous term, so this is the short form. Pri | typed |
cf_value | Exact value of a continued fraction [a0; a1, a2, ...]. Later terms are at least 1. [3; 7, 15, 1] and [3; 7, 16] are both 355/113. The canonical field is the short Euclidean form. Price: $0.001 USDC pe | typed |
cf_convergent | One convergent of a continued fraction. Index 0 is a0/1. The last index is the value itself. 13/8 at index 3 is 5/3. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST h | typed |
cf_best | Best rational approximation with a denominator up to maxDen. It searches the convergents and the intermediate fractions. 355/113 with maxDen 7 is 22/7. With maxDen 100 it is 311/99. Price: $0.001 USDC | typed |
cf_sqrt | Continued fraction of a square root. sqrt(2) is [1; 2, 2, 2, ...] and the period is 1. sqrt(3) has period 2. A perfect square is one term and period 0. The period is the repeating length, even when fe | typed |
morse_encode | Encode text as international Morse (ITU-R M.1677). Letters are separated by one space and words by " / ". SOS is ... --- ... Digits and the recommendation punctuation are included. Other characters ar | typed |
morse_decode | Decode international Morse. Letters are separated by one space and words by " / ". The result is capitals. ... --- ... is SOS. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTT | typed |
morse_timing | How long a Morse message takes at a given speed. The dit is 1200/wpm milliseconds. PARIS is 43 units, or 50 units once the trailing 7-unit word gap of a stream is added. SOS is 27 units. Price: $0.001 | typed |
bezier_cubic | Point on a cubic Bezier at t, as an exact fraction. t is between 0 and 1. The arch (0,0), (0,1), (1,1), (1,0) at one half is (1/2, 3/4). Price: $0.001 USDC per successful call (x402, Solana). Same too | typed |
bezier_quadratic | Point on a quadratic Bezier at t, as an exact fraction. (0,0), (1,1), (2,0) at one half is (1, 1/2). Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech | typed |
bezier_split | Split a quadratic or cubic Bezier at t by de Casteljau. Left and right are the two new control polygons, and they meet at the point on the curve. Price: $0.001 USDC per successful call (x402, Solana). | typed |
bezier_derivative | Control points of the derivative of a quadratic or cubic Bezier. A cubic derivative is a quadratic, and each control is the degree times the step to the next point. Price: $0.001 USDC per successful c | typed |
bezier_tangent | Tangent vector of a quadratic or cubic Bezier at t. It is the derivative curve evaluated at t. The arch (0,0), (0,1), (1,1), (1,0) at one half has tangent (3/2, 0). Price: $0.001 USDC per successful c | typed |
quat_mul | Hamilton product of two quaternions, scalar first. i times j is k, and j times i is minus k. Components are exact fractions. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS | typed |
quat_rotate | Rotate a vector by a quaternion, q v q inverse. k sends (1, 0, 0) to (-1, 0, 0), a half turn about z. Scaling q does not change the turn. Price: $0.001 USDC per successful call (x402, Solana). Same to | typed |
quat_pow | Integer power of a quaternion. i squared is -1, and i to the fourth is 1. Exponent 0 is 1, including zero to the 0. A negative power inverts first. Price: $0.001 USDC per successful call (x402, Solana | typed |
perm_sign | Sign of a permutation of 0..n-1, from the number of inversions. [2, 1, 0] has three inversions and sign -1. The identity has sign 1. Price: $0.001 USDC per successful call (x402, Solana). Same tool ov | typed |
perm_inverse | Inverse of a permutation of 0..n-1. The inverse of [1, 2, 0] is [2, 0, 1]. Applying both is the identity. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scor | typed |
perm_compose | Compose two permutations of the same length. a is applied first, then b, so the result at i is b[a[i]]. Both must use 0..n-1 once each. Price: $0.001 USDC per successful call (x402, Solana). Same tool | typed |
perm_next | The next permutation in lexicographic order. After [0, 1, 2] comes [0, 2, 1]. The reverse, [2, 1, 0], is the last and has no successor. Price: $0.001 USDC per successful call (x402, Solana). Same tool | typed |
perm_rank | Lexicographic rank of a permutation, or the permutation at a rank. [0, 1, 2] is rank 0 and [2, 0, 1] is rank 4. Give the permutation, or n and a rank, not both. n is at most 10. Price: $0.001 USDC per | typed |
pell | The nth Pell number. P0 is 0, P1 is 1, and each later term is twice the previous one plus the one before that. An optional modulus reduces the term, and zero is rejected. n runs from 0 to 8192. Past 1 | typed |
pell_lucas | The nth companion Pell-Lucas number. Q0 and Q1 are both 2, and later terms use the Pell recurrence. An optional modulus reduces the term, and zero is rejected. n runs from 0 to 8192. Past 15 digits th | typed |
pell_equation | The nth solution of the Pell equation x^2 - 2y^2 = (-1)^n. x is half the companion Pell-Lucas number and y is the Pell number. A supplied norm must equal that sign. n runs from 0 to 8192. Price: $0.00 | typed |
pell_sum | The sum of Pell numbers, or companion Pell-Lucas numbers, from lo through hi inclusive. seq is p or q. lo must not pass hi. Each index runs from 0 to 8192. Price: $0.001 USDC per successful call (x402 | typed |
pell_compose | Compose two solutions of x^2 - 2y^2 = ±1. The unit for index a multiplied by the unit for index b is the unit for a+b. a+b must be at most 8192. Price: $0.001 USDC per successful call (x402, Solana). | typed |
binom | The binomial coefficient C(n, k). k must not exceed n, and both indexes run up to 4096. An optional modulus reduces the coefficient; zero is rejected. Past 15 digits the value is a decimal string. Pri | typed |
catalan | The nth Catalan number. C0 and C1 are 1, C2 is 2, C3 is 5, and C_n = binom(2n, n) / (n+1). n runs from 0 to 2048. An optional modulus reduces the term; zero is rejected. Price: $0.001 USDC per success | typed |
ballot | The ballot number B(n, k) = (n-k+1)/(n+1) * binom(n+k, k), for 0 <= k <= n. B(n, n) is the nth Catalan number. k above n is rejected. Both indexes run up to 2048. Price: $0.001 USDC per successful cal | typed |
dyck_word | Check a Dyck word of parentheses and report its semilength and height. The empty word is valid. A prefix that goes negative, or a word that does not close, is rejected. Price: $0.001 USDC per successf | typed |
motzkin | The nth Motzkin number. M0 and M1 are 1, M2 is 2, M4 is 9, from M_n = sum binom(n, 2k) C_k. n runs from 0 to 512. An optional modulus reduces the term; zero is rejected. Price: $0.001 USDC per success | typed |
mod_pow | base^exp mod m, exact, for a non-negative exponent. The modulus must be at least 1. A negative exponent is rejected. Decimals have no leading zeros and at most 200 digits. Price: $0.001 USDC per succe | typed |
mod_inv | The modular inverse of a modulo m, as a residue from 0 up to m-1. The modulus must be at least 1. A value that is not coprime to m is rejected. Price: $0.001 USDC per successful call (x402, Solana). S | typed |
crt | Solve simultaneous congruences x ≡ a_i (mod m_i). Shared factors are allowed when the system is consistent; an inconsistent system is rejected. The result is the smallest non-negative solution and the | typed |
jacobi | The Jacobi symbol (a/n). n must be odd and positive. The value is -1, 0, or 1. An even or non-positive n is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST | typed |
egcd | Extended gcd of a and b. Returns g, x, and y with g = a*x + b*y and g >= 0. gcd(0, 0) is rejected. Decimals have no leading zeros. Price: $0.001 USDC per successful call (x402, Solana). Same tool over | typed |
pythag_gen | The Pythagorean triple from m > n >= 1 and scale k >= 1. a is k(m^2-n^2), b is k(2mn), and c is k(m^2+n^2). primitive is true when k is 1, m and n are coprime, and they have opposite parity. Price: $0 | typed |
pythag_check | Check a^2 + b^2 = c^2 for positive integers, with c the hypotenuse. primitive is true when the three sides are coprime. A side triple that fails the equation is rejected. Price: $0.001 USDC per succes | typed |
heron_area | Exact area data for a strict integer triangle. sixteen is 16 times the squared area. When sixteen is a perfect square, area is the reduced value of its square root over 4. A degenerate triple is rejec | typed |
cosine_law | The cosine of the angle opposite side c, as a reduced rational (a^2+b^2-c^2)/(2ab). The sides must form a strict triangle. A right angle returns 0. Price: $0.001 USDC per successful call (x402, Solana | typed |
triangle_shape | Classify a strict integer triangle. sides is equilateral, isosceles, or scalene. angles is acute, right, or obtuse, from comparing the squares of the sides. A degenerate triple is rejected. Price: $0. | typed |
stern | Stern's diatomic sequence. s(0) is 0, s(1) is 1, even terms repeat s(n/2), and an odd term is the sum of its two neighbors in the previous row. An optional modulus reduces the term; zero is rejected. | typed |
calkin_wilf | The Calkin-Wilf tree. Give n to get the nth positive rational, starting at 1/1, or give a reduced num and den to get its index. The two answers must agree when both are sent. An unreduced fraction is | typed |
mediant | The mediant of a/b and c/d, which is (a+c)/(b+d) reduced by their gcd. Numerators may be zero. A non-positive denominator is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool | typed |
farey_adjacent | Whether a/b and c/d are Farey neighbors. They are adjacent when the determinant ad-bc is 1 or -1. A non-positive denominator is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same to | typed |
farey_child | The mediant child of a Farey-neighbor pair. a/b and c/d must satisfy |ad-bc| = 1. A pair that is not adjacent is rejected, as is a non-positive denominator. Price: $0.001 USDC per successful call (x40 | typed |
partition | The number of integer partitions p(n), from the pentagonal recurrence. p(0) is 1, p(5) is 7, and p(10) is 42. n runs from 0 to 2000. An optional modulus reduces the count; zero is rejected. Price: $0. | typed |
partition_distinct | The number of partitions of n into distinct positive parts. This equals the number of partitions into odd parts. q(0) is 1 and q(5) is 3. n runs from 0 to 2000. An optional modulus reduces the count; | typed |
pentagonal | The generalized pentagonal number n(3n-1)/2. n may be negative. n = 1 gives 1, n = -1 gives 2, and n = 0 is rejected. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful ca | typed |
partition_conjugate | The conjugate of an integer partition, read down the columns of its Ferrers diagram. Parts must be positive and nonincreasing. The empty partition is its own conjugate. Price: $0.001 USDC per successf | typed |
partition_parts | Check an integer partition and return its sum and length. Parts must be positive and nonincreasing. The empty list is the partition of zero. A rise or a zero part is rejected. Price: $0.001 USDC per s | typed |
base_convert | Convert an integer from one base to another. Bases run from 2 to 36, and letters may be any case. A digit that is not valid in the source base is rejected. The result is the digit string in the target | typed |
digit_sum | The sum of the decimal digits of an integer, ignoring the sign. 199 sums to 19. The decimal has no leading zeros. A malformed integer is rejected. Price: $0.001 USDC per successful call (x402, Solana) | typed |
digital_root | The digital root of a decimal integer. Zero stays zero, and any other magnitude is 1 + (n-1) mod 9, so multiples of 9 have root 9. The sign is ignored. A malformed integer is rejected. Price: $0.001 U | typed |
digit_rev | Reverse the decimal digits of an integer. Leading zeros of the reversal are dropped, so 1200 becomes 21. The sign is kept. A malformed integer is rejected. Price: $0.001 USDC per successful call (x402 | typed |
repunit | The repunit of length n, (10^n - 1)/9. R1 is 1 and R2 is 11. n = 0 is rejected. n runs up to 500. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). S | typed |
gray_encode | Encode a non-negative integer as a binary reflected Gray code. The code is n xor (n shifted right by one). Zero stays zero, and a negative integer is rejected. Price: $0.001 USDC per successful call ( | typed |
gray_decode | Decode a binary reflected Gray code back to its index. The walk xors the code with each of its right shifts. A negative code is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same to | typed |
gray_next | The next binary reflected Gray code after g. It is the code of the index one past the index of g. A negative code is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTT | typed |
gray_flip | The single bit that flips in the binary reflected Gray code when the index goes from n to n+1. Bit 0 is the least significant bit. A negative index is rejected. Price: $0.001 USDC per successful call | typed |
gray_bits | The binary reflected Gray code of n, written in exactly width bits. Bit 0 is on the right. n must be smaller than 2^width. A width that cannot hold n is rejected. Price: $0.001 USDC per successful cal | typed |
poly_add | Add two integer polynomials, lowest degree first. Trailing zeros are dropped, and the zero polynomial is an empty list. An optional modulus reduces each coefficient; zero is rejected. Price: $0.001 US | typed |
poly_mul | Multiply two integer polynomials, lowest degree first. The zero polynomial is an empty list. An optional modulus reduces each coefficient; zero is rejected. A coefficient past 15 digits is a decimal s | typed |
poly_eval | Evaluate an integer polynomial at an integer point, by Horner. The zero polynomial evaluates to 0. An optional modulus reduces the result; zero is rejected. Price: $0.001 USDC per successful call (x40 | typed |
poly_deriv | Differentiate an integer polynomial. The derivative of a constant is the zero polynomial, which is an empty list. An optional modulus reduces each coefficient; zero is rejected. Price: $0.001 USDC per | typed |
poly_div | Exact quotient of two integer polynomials. The divisor must be non-zero, and every leading step must divide in the integers. A zero divisor or a non-integral quotient is rejected. Price: $0.001 USDC p | typed |
totient | Euler totient phi(n), the count of integers from 1 to n that are coprime to n. phi(1) is 1. n = 0 is rejected. n runs up to 10^12. Price: $0.001 USDC per successful call (x402, Solana). Same tool over | typed |
mobius | The Mobius function mu(n). It is 0 when n has a squared prime factor, and otherwise (-1)^k for k distinct primes. mu(1) is 1. n = 0 is rejected. Price: $0.001 USDC per successful call (x402, Solana). | typed |
divisor_count | The number of positive divisors of n. A prime has 2, and d(1) is 1. n = 0 is rejected. n runs up to 10^12. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://sco | typed |
divisor_sum | The sum of the positive divisors of n. sigma(6) is 12 and sigma(28) is 56. n = 0 is rejected. A value past 15 digits is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same to | typed |
prime_check | Whether n is prime, by trial division. 1 is not prime. n < 1 is rejected. n runs up to 10^12. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com | typed |
egypt_greedy | The greedy Egyptian fraction for a proper positive fraction a/b. 5/6 is 1/2 + 1/3. A fraction that is not strictly between 0 and 1 is rejected. Price: $0.001 USDC per successful call (x402, Solana). S | typed |
unit_sum | The reduced sum of unit fractions 1/d. Dens must be positive. An empty list or a non-positive denominator is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST | typed |
harmonic | The nth harmonic number as a reduced fraction. H1 is 1/1, H2 is 3/2, and H6 is 49/20. n < 1 is rejected. n runs up to 200. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: | typed |
sylvester | The nth Sylvester number. s(0) is 2, and each later term is s*(s-1)+1. A negative index is rejected. n runs up to 8. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful cal | typed |
egypt_check | Check that a sum of unit fractions equals the fraction a/b. A match returns the reduced sum. A sum that differs, or a non-positive denominator, is rejected. Price: $0.001 USDC per successful call (x40 | typed |
jacobsthal | The nth Jacobsthal number. J0 is 0, J1 is 1, and each later term is the previous one plus twice the one before that. An optional modulus reduces the term, and zero is rejected. n runs from 0 to 8192. | typed |
jacobsthal_lucas | The nth Jacobsthal-Lucas number. L0 is 2, L1 is 1, and later terms use the Jacobsthal recurrence. An optional modulus reduces the term, and zero is rejected. n runs from 0 to 8192. Past 15 digits the | typed |
jacobsthal_sum | The sum of Jacobsthal numbers, or Jacobsthal-Lucas numbers, from lo through hi inclusive. seq is j or l. lo must not pass hi. Each index runs from 0 to 8192. Price: $0.001 USDC per successful call (x4 | typed |
jacobsthal_add | The Jacobsthal addition rule. (L(a)*J(b) + J(a)*L(b)) / 2 is J(a+b). a+b must be at most 8192. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.co | typed |
jacobsthal_power | The power identity J(n) + J(n+1) = 2^n. left is J(n), right is J(n+1), and value is their sum. n runs from 0 to 8191 so that n+1 stays in range. Past 15 digits the value is a decimal string. Price: $0 | typed |
padovan | The nth Padovan number. P0, P1, and P2 are 1, and each later term is the sum of the term two back and the term three back. An optional modulus reduces the term, and zero is rejected. n runs from 0 to | typed |
perrin | The nth Perrin number. R0 is 3, R1 is 0, R2 is 2, and later terms use the Padovan recurrence. An optional modulus reduces the term, and zero is rejected. n runs from 0 to 8192. Past 15 digits the valu | typed |
padovan_sum | The sum of Padovan numbers, or Perrin numbers, from lo through hi inclusive. seq is p or r. lo must not pass hi. Each index runs from 0 to 8192. Price: $0.001 USDC per successful call (x402, Solana). | typed |
perrin_divide | The remainder of the nth Perrin number divided by n. A prime n divides R(n), so the remainder is 0. n runs from 1 to 8192. Past 15 digits the Perrin number is a decimal string. Price: $0.001 USDC per | typed |
padovan_step | The Padovan step identity P(n) = P(n-1) + P(n-5). left is P(n-1) and right is P(n-5). n runs from 5 to 8192. Past 15 digits a term is a decimal string. Price: $0.001 USDC per successful call (x402, So | typed |
stirling2 | The Stirling number of the second kind S(n,k), the number of ways to partition n objects into k nonempty unlabeled sets. S(5,2) is 15. S(n,k) is 0 when k is greater than n. n and k run from 0 to 80. P | typed |
bell | The nth Bell number, the number of partitions of a set of n objects. B(0) and B(1) are 1, and B(5) is 52. n runs from 0 to 80. Past 15 digits the value is a decimal string. Price: $0.001 USDC per succ | typed |
stirling2_row | Row n of Stirling numbers of the second kind, from S(n,0) through S(n,n), plus the Bell number that sums the row. n runs from 0 to 80. Past 15 digits an entry is a decimal string. Price: $0.001 USDC p | typed |
bell_sum | The sum of Bell numbers from lo through hi inclusive. lo must not pass hi. Each index runs from 0 to 80. Past 15 digits the sum is a decimal string. Price: $0.001 USDC per successful call (x402, Solan | typed |
stirling2_rec | The Stirling recurrence S(n,k) = k*S(n-1,k) + S(n-1,k-1). term is the first summand and diag is the second. n and k run from 1 to 80. Past 15 digits a part is a decimal string. Price: $0.001 USDC per | typed |
delannoy | The Delannoy number D(m,n), the number of paths from (0,0) to (m,n) using steps (1,0), (0,1), and (1,1). D(3,5) is 231. m and n run from 0 to 64. Past 15 digits the value is a decimal string. Price: $ | typed |
delannoy_central | The central Delannoy number D(n,n). D(0,0) is 1 and D(3,3) is 63. n runs from 0 to 64. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool ov | typed |
schroder | The nth large Schröder number. S(0) is 1, S(1) is 2, and S(5) is 394. n runs from 0 to 64. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same too | typed |
schroder_little | The nth little Schröder number. It is 1 at n = 0 and half the large Schröder number for n > 0. s(5) is 197. n runs from 0 to 64. Past 15 digits the value is a decimal string. Price: $0.001 USDC per su | typed |
delannoy_sum | The sum of Delannoy numbers D(m,0) through D(m,hi). The sum through D(4,4) is 501. m and hi run from 0 to 64. Past 15 digits the sum is a decimal string. Price: $0.001 USDC per successful call (x402, | typed |
narayana | The Narayana number N(n,k). N(5,3) is 20. A k outside 1..n yields 0. n runs from 1 to 60 and k from 0 to 60. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, | typed |
narayana_row | Narayana numbers N(n,1) through N(n,n). Their sum is the Catalan number C(n). The row for n = 4 is 1, 6, 6, 1 and sums to 14. n runs from 1 to 60. Price: $0.001 USDC per successful call (x402, Solana) | typed |
narayana_check | The Narayana product C(n,k)*C(n,k-1). It is exactly n times N(n,k). product is that binomial product and value is the Narayana number. n runs from 1 to 60. Price: $0.001 USDC per successful call (x402 | typed |
fuss_catalan | The Fuss-Catalan number C(p*n+1, n) / (p*n+1). FC(2,n) is the Catalan number, so FC(2,5) is 42. p runs from 1 to 8 and n from 0 to 30. Past 15 digits the value is a decimal string. Price: $0.001 USDC | typed |
fuss_check | The Fuss-Catalan division. num is C(p*n+1, n), den is p*n+1, and value is the exact quotient. p runs from 1 to 8 and n from 0 to 30. Past 15 digits a part is a decimal string. Price: $0.001 USDC per s | typed |
chebyshev_t | The Chebyshev polynomial of the first kind T(n,x) at an integer x. T(0,x) is 1, T(1,x) is x, and T(2,3) is 17. n runs from 0 to 64 and x from -1000 to 1000. Past 15 digits the value is a decimal strin | typed |
chebyshev_u | The Chebyshev polynomial of the second kind U(n,x) at an integer x. U(0,x) is 1, U(1,x) is 2*x, and U(3,2) is 56. n runs from 0 to 64 and x from -1000 to 1000. Past 15 digits the value is a decimal st | typed |
chebyshev_disc | The Chebyshev discriminant identity T(n,x)^2 - (x^2-1)*U(n-1,x)^2 = 1. gap is that difference. n runs from 1 to 64. Past 15 digits t or u is a decimal string. Price: $0.001 USDC per successful call (x | typed |
chebyshev_prod | The product identity 2*T(a,x)*T(b,x) = T(a+b,x) + T(|a-b|,x). twice is the left side and sum is the right side. a+b must be at most 64. Price: $0.001 USDC per successful call (x402, Solana). Same tool | typed |
chebyshev_rec | One step of the Chebyshev recurrence. kind is t or u. prev is degree n-1, older is degree n-2, and value is 2*x*prev - older. n runs from 2 to 64. Price: $0.001 USDC per successful call (x402, Solana) | typed |
tribonacci | The nth Tribonacci number. T0 and T1 are 0, T2 is 1, and each later term is the sum of the previous three. An optional modulus reduces the term, and zero is rejected. n runs from 0 to 4096. Past 15 di | typed |
trib_sum | The sum of Tribonacci numbers from lo through hi inclusive. The sum from T0 through T10 is 177. lo must not pass hi. Each index runs from 0 to 4096. Price: $0.001 USDC per successful call (x402, Solan | typed |
trib_step | The Tribonacci step T(n) = T(n-1) + T(n-2) + T(n-3). left is T(n-3), mid is T(n-2), and right is T(n-1). n runs from 3 to 4096. Past 15 digits a term is a decimal string. Price: $0.001 USDC per succes | typed |
trib_index | The smallest index n with T(n) equal to value. 0 is index 0, and 1 is index 2. A number that is not a Tribonacci term, or a leading zero, is rejected. value is a decimal integer of at most 600 digits. | typed |
trib_mod | T(n) mod m. The modulus is a positive decimal integer, and zero is rejected. n runs from 0 to 4096. The residue is smaller than the modulus. Price: $0.001 USDC per successful call (x402, Solana). Same | typed |
thue_morse | The nth Thue-Morse bit, the parity of the number of 1-bits in n. t(0) is 0, t(1) is 1, and t(2) is 1. n runs from 0 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HT | typed |
thue_sum | The number of 1-bits in the Thue-Morse sequence from lo through hi inclusive. The sum from t(0) through t(7) is 4. lo must not pass hi. Each index runs from 0 to 1000000. Price: $0.001 USDC per succes | typed |
thue_prefix | The first n Thue-Morse bits as a string of 0 and 1. The first 8 bits are 01101001. n runs from 1 to 4096. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scor | typed |
thue_cube | Find a cube in a 0/1 string, a block xxx. 000 is a cube at index 0 of length 1. A Thue-Morse prefix has no cube. An empty string or a character other than 0 or 1 is rejected. The string stops at 512 c | typed |
thue_weight | The number of 1s in t(0) through t(n), and the bit t(n) itself. Through n = 7 the weight is 4. n runs from 0 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: PO | typed |
rudin_shapiro | The Rudin-Shapiro bit of n, the parity of the number of overlapping 11 blocks in its binary expansion. n = 3 is 11, so the bit is 1 and the sign is -1. n = 0 is 0. n runs from 0 to 1000000. Price: $0. | typed |
baum_sweet | The Baum-Sweet bit of n. It is 1 when every run of 0s in the binary expansion has even length, and 0 when some run of 0s has odd length. b(0) is 1 and b(2) is 0. n runs from 0 to 1000000. Price: $0.00 | typed |
paperfold | The regular paperfolding bit of n. Write n = m * 2^k with m odd. The bit is 1 when m is 1 mod 4, and 0 when m is 3 mod 4. The first three bits, from n = 1, are 1, 1, 0. n runs from 1 to 1000000. Price | typed |
golay_rudin | The Golay-Rudin-Shapiro partial sum. Each term is +1 or -1 as the Rudin-Shapiro sign of k, and the value is the sum from k = 0 through n. The sum through n = 3 is 2. n runs from 0 to 100000. Price: $0 | typed |
morse_run | The Thue-Morse run that contains n. The bit is the parity of the 1-bits of n. A run has length 1 or 2. Index 0 is a run of one 0, and index 1 starts a run of two 1s. n runs from 0 to 1000000. Price: $ | typed |
lucas | The nth Lucas number. L0 is 2, L1 is 1, and each later term is the sum of the previous two. L5 is 11 and L10 is 123. An optional modulus reduces the term, and zero is rejected. n runs from 0 to 4096. | typed |
lucas_sum | The sum of Lucas numbers from lo through hi inclusive. The sum from L0 through L5 is 28. The sum equals L(hi+2) - L(lo+1). lo must not pass hi. Each index runs from 0 to 4096. Price: $0.001 USDC per s | typed |
lucas_index | The smallest index n with L(n) equal to value. 2 is index 0, and 1 is index 1. A number that is not a Lucas number, or a leading zero, is rejected. value is a decimal integer of at most 600 digits. Pr | typed |
lucas_mod | L(n) mod m. The modulus is a positive decimal integer, and zero is rejected. n runs from 0 to 4096. The residue is smaller than the modulus. Price: $0.001 USDC per successful call (x402, Solana). Same | typed |
lucas_disc | The Lucas discriminant L(n)^2 - 5*F(n)^2, which equals 4*(-1)^n. F is the Fibonacci sequence with F0 = 0 and F1 = 1. For n = 5 the value is -4. n runs from 0 to 4096. Price: $0.001 USDC per successful | typed |
ruler | The ruler value of n, the exponent of 2 in n. v2(1) is 0, v2(8) is 3, and v2(12) is 2. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST | typed |
ruler_sum | The sum of the ruler values v2(1) through v2(n). It equals n minus the number of 1-bits in n. The sum through 15 is 11. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, So | typed |
ruler_prefix | The ruler values v2(1) through v2(n), written as comma-separated integers. The first 8 values are 0,1,0,2,0,1,0,3. n runs from 1 to 4096. Price: $0.001 USDC per successful call (x402, Solana). Same to | typed |
ruler_max | The largest ruler value on 1 through n, and the smallest index where it occurs. That index is the greatest power of 2 that does not exceed n. On 1 through 20 the maximum is 4, at 16. n runs from 1 to | typed |
ruler_odd | Remove every factor of 2 from n. The odd part of 12 is 3 and the valuation is 2. The odd part of 7 is 7. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same too | typed |
collatz_step | One Collatz step. An even n is halved and an odd n becomes 3n+1. 6 goes to 3, and 1 goes to 4. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: PO | typed |
collatz_length | The number of Collatz steps from n until 1. The length of 1 is 0, the length of 6 is 8, and the length of 27 is 111. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Sa | typed |
collatz_peak | The largest value on the Collatz trajectory from n through 1, including n. The peak of 1 is 1, the peak of 6 is 16, and the peak of 27 is 9232. n runs from 1 to 1000000. Price: $0.001 USDC per success | typed |
collatz_glide | The Collatz glide of n, the number of steps until a value strictly below n. The glide of 1 is 0, the glide of 6 is 1, and the glide of 7 is 11. n runs from 1 to 1000000. Price: $0.001 USDC per success | typed |
wythoff | The nth lower Wythoff number, floor(n*phi), where phi is (1+sqrt(5))/2. A(1) is 1, A(2) is 3, and A(5) is 8. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool | typed |
wythoff_upper | The nth upper Wythoff number, floor(n*phi^2), which is A(n)+n. B(1) is 2, B(2) is 5, and B(5) is 13. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTT | typed |
wythoff_pair | The nth Wythoff pair. lower is floor(n*phi) and upper is lower+n. The pair for n = 1 is 1 and 2. The pair for n = 5 is 8 and 13. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, | typed |
wythoff_inverse | Which Wythoff sequence contains m, and at which index. 1 is the lower number at index 1. 2 is the upper number at index 1. Every positive integer is in exactly one sequence. m runs from 1 to 1600000. | typed |
beatty | The Beatty term floor(n*sqrt(d)). floor(5*sqrt(2)) is 7, and floor(2*sqrt(3)) is 3. n runs from 0 to 1000000 and d runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same t | typed |
kolakoski | The nth Kolakoski term, using a 1-based index. The sequence is 1s and 2s, and it starts 1, 2, 2, 1, 1. Term 7 is 1. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same | typed |
kolakoski_prefix | The first n Kolakoski terms as a string of the digits 1 and 2. The first 10 terms are 1221121221. n runs from 1 to 4096. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: PO | typed |
kolakoski_sum | The sum of the first n Kolakoski terms. The sum of the first 10 terms is 15. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptec | typed |
kolakoski_run | The Kolakoski run that contains the 1-based index n. A run has length 1 or 2. Index 1 is a single 1. Index 2 starts two 2s. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solan | typed |
kolakoski_check | Whether a string of the digits 1 and 2 is a prefix of the Kolakoski sequence. 122112 is a prefix. An empty string, or any other character, is rejected. The string stops at 512 characters. Price: $0.00 | typed |
carmichael | Carmichael's lambda of n, the exponent of the multiplicative group mod n. lambda(1) is 1, lambda(8) is 2, lambda(p) is p-1, and lambda(15) is 4. n runs from 1 to 1000000000000. Price: $0.001 USDC per | typed |
jordan_totient | The Jordan totient J(k, n). J(1, n) is Euler's totient. J(1, 6) is 2 and J(2, 6) is 24. k runs from 1 to 12 and n runs from 1 to 1000000. Past 15 digits the value is a decimal string. Price: $0.001 US | typed |
dedekind_psi | Dedekind's psi function, n times the product of (1+1/p) over the distinct prime factors of n. psi(1) is 1, psi(2) is 3, and psi(6) is 12. n runs from 1 to 1000000000000. Price: $0.001 USDC per success | typed |
aliquot | The aliquot part of n, the sum of proper divisors. The aliquot part of 1 is 0, of 9 is 4, and of 6 is 6. n runs from 1 to 1000000000000. Past 15 digits the value is a decimal string. Price: $0.001 USD | typed |
perfect_check | Classify n from its divisor sum. 6 and 28 are perfect. 12 is abundant. 8 is deficient. The class is perfect, abundant, or deficient. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful c | typed |
hermite | The physicist Hermite polynomial H(n, x) at an integer x. H(0, x) is 1, H(1, x) is 2x, H(2, 1) is 2, and H(3, 1) is -4. n runs from 0 to 32 and x from -1000 to 1000. Past 15 digits the value is a deci | typed |
hermite_prob | The probabilist Hermite polynomial He(n, x) at an integer x. He(0, x) is 1, He(1, x) is x, and He(2, 1) is 0. n runs from 0 to 32 and x from -1000 to 1000. Past 15 digits the value is a decimal string | typed |
laguerre | The Laguerre polynomial L(n, x) at an integer x, as a reduced fraction. L(n, 0) is 1, L(1, 1) is 0, and L(2, 1) is -1/2. n runs from 0 to 32 and x from -1000 to 1000. Price: $0.001 USDC per successful | typed |
legendre_pol | The Legendre polynomial P(n, x) at an integer x, as a reduced fraction. P(n, 1) is 1, and P(2, 2) is 11/2. n runs from 0 to 32 and x from -1000 to 1000. Price: $0.001 USDC per successful call (x402, S | typed |
hermite_deriv | The derivative of the physicist Hermite polynomial, H'(n, x) = 2*n*H(n-1, x). At n = 3 and x = 1 the derivative is 12. n runs from 1 to 32 and x from -1000 to 1000. Price: $0.001 USDC per successful c | typed |
stirling1 | The signed Stirling number of the first kind s(n, k). s(4, 2) is 11 and s(5, 2) is -50. s(n, 0) is 0 for n > 0. n runs from 0 to 64, and k must not pass n. Past 15 digits the value is a decimal string | typed |
stirling1_unsigned | The unsigned Stirling number of the first kind, the absolute value of s(n, k). It counts permutations of n with k cycles. c(5, 2) is 50 and c(5, 1) is 24. n runs from 0 to 64. Price: $0.001 USDC per s | typed |
stirling1_row | Row n of the signed Stirling numbers of the first kind, from s(n, 0) through s(n, n). The absolute values sum to n!. Row 4 is 0, -6, 11, -6, 1. n runs from 0 to 64. Price: $0.001 USDC per successful c | typed |
stirling1_rec | One step of s(n, k) = s(n-1, k-1) - (n-1)*s(n-1, k). For n = 5 and k = 2, the previous term is -6, the scaled term is 44, and the value is -50. n runs from 1 to 64 and k from 1 to n. Price: $0.001 USD | typed |
subfactorial | The subfactorial !n, the number of derangements of n objects. !0 is 1, !1 is 0, !2 is 1, and !5 is 44. n runs from 0 to 4096. Past 15 digits the value is a decimal string. Price: $0.001 USDC per succe | typed |
zeckendorf | The Zeckendorf representation of n. Fibonacci numbers start F1 = 1, F2 = 1, F3 = 2, and no two used indices are consecutive. 4 is F4 + F2, and 100 is F11 + F6 + F4. n runs from 1 to 1000000000000. Pri | typed |
zeckendorf_sum | Sum Fibonacci numbers by index, using F1 = 1 and F2 = 1. Indices must be at least 2 and no two may be consecutive. Indices 11, 6, and 4 sum to 100. An empty list is rejected. At most 64 indices, each | typed |
zeckendorf_bits | The Zeckendorf bit string of n, from the largest used Fibonacci index down to F2. The bit string of 1 is 1, of 4 is 101, and of 100 is 1000010100. n runs from 1 to 1000000000000. Price: $0.001 USDC pe | typed |
fibword | The nth bit of the infinite Fibonacci word, starting at n = 0. The word is the fixed point of 0 to 01 and 1 to 0, and it starts 01001010. n runs from 0 to 99999. Price: $0.001 USDC per successful call | typed |
fibword_prefix | The first n bits of the Fibonacci word. The first 8 bits are 01001010, and the first 16 bits are 0100101001001010. n runs from 1 to 4096. Price: $0.001 USDC per successful call (x402, Solana). Same to | typed |
little_omega | The number of distinct prime factors of n. omega(1) is 0, omega(4) is 1, and omega(30) is 3. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS | typed |
big_omega | The number of prime factors of n counted with multiplicity. Omega(1) is 0, Omega(4) is 2, and Omega(12) is 3. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Sam | typed |
squarefree | Whether n is squarefree, together with its radical. 1 and 30 are squarefree. 4 and 12 are not. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTT | typed |
bernoulli | The nth Bernoulli number as a reduced fraction, from the Akiyama-Tanigawa algorithm. B0 is 1, B1 is 1/2, B2 is 1/6, and B4 is -1/30. Odd indices after 1 are 0. n runs from 0 to 40. Price: $0.001 USDC | typed |
bernoulli_denom | The von Staudt denominator of B(m) for even m at least 2: the product of primes p such that p-1 divides m. The denominator of B2 is 6, and of B4 is 30. An odd m is rejected. m runs from 2 to 40. Price | typed |
von_staudt | The von Staudt-Clausen integer. For even m at least 2, B(m) plus the sum of 1/p over primes p with p-1 dividing m is an integer. For m = 2, 4, 6, and 10 that integer is 1. An odd m is rejected. Price: | typed |
tangent_number | The nth tangent number. T1 is 1, T2 is 2, T3 is 16, and T4 is 272. It is read from the Bernoulli number B(2n). n runs from 1 to 20. Past 15 digits the value is a decimal string. Price: $0.001 USDC per | typed |
bernoulli_sum | The sum of Bernoulli numbers B0 through Bn, as a reduced fraction. The sum through B1 is 3/2, and through B2 is 5/3. n runs from 0 to 40. Price: $0.001 USDC per successful call (x402, Solana). Same to | typed |
isqrt | The integer square root of a non-negative decimal integer, the greatest r with r^2 not exceeding n. isqrt(0) is 0 and isqrt(10) is 3. A leading zero is rejected. n has at most 600 digits. Price: $0.00 | typed |
icbrt | The integer cube root of a non-negative decimal integer, the greatest r with r^3 not exceeding n. icbrt(26) is 2 and icbrt(27) is 3. A leading zero is rejected. n has at most 600 digits. Price: $0.001 | typed |
isquare | Whether a non-negative decimal integer is a perfect square, and the root when it is. 16 is 4 squared. 15 is not a square. A leading zero is rejected. n has at most 600 digits. Price: $0.001 USDC per s | typed |
ipow | The integer power base^exp. 2^10 is 1024, and (-2)^5 is -32. 0^0 is 1. exp runs from 0 to 256. The base has at most 80 digits. Past 15 digits the value is a decimal string. Price: $0.001 USDC per succ | typed |
perfect_power | Whether n is a perfect power a^k with k at least 2. The base is the smallest such a, so the exponent is the largest. 16 is 2^4, 36 is 6^2, and 7 is not a perfect power. 0 and 1 use exponent 2. A leadi | typed |
recaman | The nth Recamán term. a(0) is 0. Each later term steps back by n when that value is positive and new, and otherwise steps forward by n. a(4) is 2 and a(6) is 13. n runs from 0 to 100000. Price: $0.001 | typed |
recaman_seen | Whether value appears in Recamán's sequence from a(0) through a(limit), and the smallest index if it does. 2 appears at index 4. 4 does not appear by index 20. limit runs from 0 to 100000. Price: $0.0 | typed |
golomb | The nth Golomb term, 1-based. a(1) is 1, a(n) counts how often n will appear, and a(6) is 4. The sequence starts 1, 2, 2, 3, 3, 4. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402 | typed |
golomb_sum | The sum of the first n Golomb terms, from a(1) through a(n). The sum of the first 5 terms is 11. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: P | typed |
golomb_inverse | The smallest index n with Golomb a(n) equal to k. Index 1 holds 1, index 4 holds 3, and index 6 holds 4. k runs from 1 to 5000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HT | typed |
hockey_stick | The hockey-stick sum of binomial coefficients C(i, r) from i = r through n. It equals C(n+1, r+1). The sum for r = 2 and n = 5 is 20. r must not pass n. Both run from 0 to 1024. Price: $0.001 USDC per | typed |
vandermonde | The Vandermonde convolution. The sum of C(m, k)*C(n, r-k) equals C(m+n, r). For m = 3, n = 3, and r = 2 the value is 15. m and n run from 0 to 256, and r must not pass m+n. Price: $0.001 USDC per succ | typed |
stars_bars | The number of ways to place n identical items into k distinct bins, which is C(n+k-1, n). Three items in two bins can be placed in 4 ways. n runs from 0 to 1024 and k runs from 1 to 1024. Price: $0.00 | typed |
multichoose | The number of ways to choose k elements from n types with repetition, which is C(n+k-1, k). Choosing 2 from 3 types can be done in 6 ways. Choosing nothing can be done in 1 way. n and k run from 0 to | typed |
kummer | The number of carries when a and b are added in prime base p. By Kummer, that is the exponent of p in C(a+b, a). Adding 5 and 3 in base 2 makes 3 carries. A composite base is rejected. a and b run fro | typed |
double_factorial | The double factorial n!!. Even n uses the even factors down to 2, and odd n uses the odd factors down to 1. 0!! is 1, 6!! is 48, and 7!! is 105. n runs from 0 to 4096. Past 15 digits the value is a de | typed |
primorial | The primorial of n, the product of the primes less than or equal to n. The primorial of 1 is 1, of 10 is 210, and of 11 is 2310. n runs from 1 to 5000. Past 15 digits the value is a decimal string. Pr | typed |
falling | The falling factorial (n)_k = n*(n-1)*...*(n-k+1). (5)_3 is 60, (5)_0 is 1, and (5)_6 is 0. n runs from 0 to 100000 and k runs from 0 to 512. Past 15 digits the value is a decimal string. Price: $0.00 | typed |
rising | The rising factorial n^(k) = n*(n+1)*...*(n+k-1). 5^(3) is 210, and 5^(0) is 1. n runs from 0 to 100000 and k runs from 0 to 512. Past 15 digits the value is a decimal string. Price: $0.001 USDC per s | typed |
factorial_mod | n! mod m. 0! is 1, so 0! mod 5 is 1. 10! mod 97 is 30. The modulus is a positive decimal integer, and zero is rejected. n runs from 0 to 100000. Price: $0.001 USDC per successful call (x402, Solana). | typed |
sl2_mul | The product of two integer 2 by 2 matrices, each written as [a, b, c, d]. [1, 1, 0, 1] times [1, 0, 1, 1] is [2, 1, 1, 1]. Each entry runs from -1000000 to 1000000. Price: $0.001 USDC per successful c | typed |
sl2_pow | The non-negative integer power of a 2 by 2 integer matrix. The exponent 0 is the identity [1, 0, 0, 1]. [1, 1, 0, 1] to the fifth is [1, 5, 0, 1]. [1, 1, 1, 0] to the fifth is [8, 5, 5, 3]. The expone | typed |
sl2_det | The determinant ad-bc of a 2 by 2 integer matrix [a, b, c, d]. The determinant of [1, 1, 0, 1] is 1, and the determinant of [2, 0, 0, 3] is 6. Price: $0.001 USDC per successful call (x402, Solana). Sa | typed |
sl2_inv | The inverse of a 2 by 2 integer matrix whose determinant is 1 or -1. The inverse of [1, 1, 0, 1] is [1, -1, 0, 1]. Any other determinant is rejected. Price: $0.001 USDC per successful call (x402, Sola | typed |
sl2_trace | The trace a+d of a 2 by 2 integer matrix [a, b, c, d]. The trace of [1, 1, 0, 1] is 2, and the trace of [8, 5, 5, 3] is 11. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: | typed |
frobenius | The Frobenius number of two coprime integers a and b, each at least 2. It is ab-a-b, the largest integer that cannot be made with non-negative combinations. For 2 and 5 it is 3. For 4 and 7 it is 17. | typed |
coin_count | How many positive integers cannot be made with coprime denominations a and b. The count is (a-1)*(b-1)/2. For 2 and 5 it is 2. For 4 and 7 it is 9. A pair that is not coprime is rejected. Price: $0.00 | typed |
coin_check | Whether n can be made with non-negative counts of coins a and b. 10 can be made with 2 and 5. 3 cannot. 0 can. a and b run from 1 to 10000, and n runs from 0 to 100000. Price: $0.001 USDC per successf | typed |
coin_ways | The number of non-negative integer solutions of a*x + b*y = n. Order of summands does not matter. There are 2 ways to make 10 with 2 and 5, and 0 ways to make 3. a and b run from 1 to 10000, and n run | typed |
coin_min | The fewest coins of denominations a and b that sum to n. Making 10 with 2 and 5 takes 2 coins. An amount that cannot be made is rejected. a and b run from 1 to 10000, and n runs from 0 to 100000. Pric | typed |
look_say | The nth look-and-say term, starting from 1. Term 1 is 1, term 4 is 1211, and term 5 is 111221. Each run of k copies of a digit d becomes the digits of k followed by d. n runs from 1 to 25. Price: $0.0 | typed |
look_say_step | One look-and-say step on a digit string. 1 becomes 11, and 1211 becomes 111221. Two 2s become 22. An empty string, or a character that is not a digit, is rejected. The string stops at 4096 characters. | typed |
look_say_len | The number of digits in the nth look-and-say term, starting from 1. Term 1 has length 1, term 5 has length 6, and term 8 has length 10. n runs from 1 to 25. Price: $0.001 USDC per successful call (x40 | typed |
look_say_digit | One digit of the nth look-and-say term. The index starts at 0. Term 5 is 111221, so index 3 is 2. An index past the end is rejected. n runs from 1 to 25. Price: $0.001 USDC per successful call (x402, | typed |
look_say_count | How many times a digit occurs in the nth look-and-say term. Term 5 is 111221, so it has four 1s and two 2s. A digit from 4 through 9 occurs zero times in the classic sequence. n runs from 1 to 25, and | typed |
hof_q | The nth Hofstadter Q term. Q(1) and Q(2) are 1, and Q(n) = Q(n-Q(n-1)) + Q(n-Q(n-2)). Q(10) is 6, and Q(16) is 9. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same t | typed |
hof_q_sum | The sum of Hofstadter Q terms Q(1) through Q(n). The sum through Q(10) is 36, and the sum through Q(20) is 129. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same too | typed |
hof_q_prefix | The first n Hofstadter Q terms, from Q(1) through Q(n), written as comma-separated integers. The first 10 terms are 1,1,2,3,3,4,5,5,6,6. n runs from 1 to 4096. Price: $0.001 USDC per successful call ( | typed |
hof_g | The nth Hofstadter G term. G(0) is 0, and G(n) = n - G(G(n-1)). G(1) is 1, and G(10) is 6. n runs from 0 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST ht | typed |
hof_conway | The nth Hofstadter-Conway term. a(1) and a(2) are 1, and a(n) = a(a(n-1)) + a(n-a(n-1)). a(5) is 3, and a(10) is 6. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same | typed |
hof_conway_sum | The sum of Hofstadter-Conway terms a(1) through a(n). The sum through a(10) is 32, and the sum through a(30) is 266. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Sam | typed |
hof_male | The nth Hofstadter male term. M(0) is 0, F(0) is 1, M(n) = n - F(M(n-1)), and F(n) = n - M(F(n-1)). M(2) is 1, and M(5) is 3. n runs from 0 to 100000. Price: $0.001 USDC per successful call (x402, Sol | typed |
hof_female | The nth Hofstadter female term. F(0) is 1, M(0) is 0, F(n) = n - M(F(n-1)), and M(n) = n - F(M(n-1)). F(1) is 1, and F(5) is 3. n runs from 0 to 100000. Price: $0.001 USDC per successful call (x402, S | typed |
hof_pair | The Hofstadter male and female terms at the same index. M(0) is 0 and F(0) is 1. At n = 5 both terms are 3. n runs from 0 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool ov | typed |
tetranacci | The nth Tetranacci number. T0, T1, and T2 are 0, T3 is 1, and each later term is the sum of the previous four. T(10) is 56. An optional modulus reduces the term, and zero is rejected. n runs from 0 to | typed |
tetranacci_sum | The sum of Tetranacci numbers from lo through hi inclusive. The sum from T0 through T10 is 116. lo must not pass hi. Each index runs from 0 to 4096. Past 15 digits the value is a decimal string. Price | typed |
tetranacci_mod | T(n) mod m for the Tetranacci sequence. The modulus is a positive decimal integer, and zero is rejected. n runs from 0 to 4096. The residue is smaller than the modulus. Price: $0.001 USDC per successf | typed |
tetranacci_index | The smallest index n with T(n) equal to value. 0 is index 0, and 1 is index 3. A number that is not a Tetranacci term, or a leading zero, is rejected. value is a decimal integer of at most 600 digits. | typed |
tetranacci_step | The Tetranacci step T(n) = T(n-1) + T(n-2) + T(n-3) + T(n-4). a is T(n-4), b is T(n-3), c is T(n-2), and d is T(n-1). n runs from 4 to 4096. Past 15 digits a term is a decimal string. Price: $0.001 US | typed |
pentanacci | The nth Pentanacci number. P0 through P3 are 0, P4 is 1, and each later term is the sum of the previous five. P(10) is 31. An optional modulus reduces the term, and zero is rejected. n runs from 0 to | typed |
pentanacci_sum | The sum of Pentanacci numbers from lo through hi inclusive. The sum from P0 through P12 is 244. lo must not pass hi. Each index runs from 0 to 4096. Past 15 digits the value is a decimal string. Price | typed |
pentanacci_mod | P(n) mod m for the Pentanacci sequence. The modulus is a positive decimal integer, and zero is rejected. n runs from 0 to 4096. The residue is smaller than the modulus. Price: $0.001 USDC per successf | typed |
pentanacci_index | The smallest index n with P(n) equal to value. 0 is index 0, and 1 is index 4. A number that is not a Pentanacci term, or a leading zero, is rejected. value is a decimal integer of at most 600 digits. | typed |
pentanacci_step | The Pentanacci step P(n) = P(n-1) + P(n-2) + P(n-3) + P(n-4) + P(n-5). a is P(n-5), b is P(n-4), c is P(n-3), d is P(n-2), and e is P(n-1). n runs from 5 to 4096. Past 15 digits a term is a decimal st | typed |
leonardo | The nth Leonardo number. L(0) and L(1) are 1, and L(n) = L(n-1) + L(n-2) + 1. L(4) is 9, and L(10) is 177. An optional modulus reduces the term, and zero is rejected. n runs from 0 to 4096. Past 15 di | typed |
leonardo_sum | The sum of Leonardo numbers from lo through hi inclusive. The sum from L(0) through L(5) is 34. lo must not pass hi. Each index runs from 0 to 4096. Past 15 digits the value is a decimal string. Price | typed |
leonardo_mod | L(n) mod m for the Leonardo sequence. The modulus is a positive decimal integer, and zero is rejected. n runs from 0 to 4096. The residue is smaller than the modulus. Price: $0.001 USDC per successful | typed |
leonardo_index | The smallest index n with L(n) equal to value. 1 is index 0, and 9 is index 4. A number that is not a Leonardo number, or a leading zero, is rejected. value is a decimal integer of at most 600 digits. | typed |
leonardo_fib | The Leonardo identity L(n) = 2*F(n+1) - 1. F is the Fibonacci sequence with F(0) = 0 and F(1) = 1. For n = 10, L is 177 and F(11) is 89, so the difference is 0. n runs from 0 to 4096. Past 15 digits a | typed |
euler_zigzag | The nth Euler zigzag number, the number of up-down permutations of n. a(0) is 1, a(3) is 2, a(4) is 5, and a(5) is 16. For n at least 1 it is the Entringer number E(n, n). n runs from 0 to 40. Past 15 | typed |
euler_zigzag_sum | The sum of Euler zigzag numbers a(0) through a(n). The sum through a(5) is 26, and the sum through a(10) is 60201. n runs from 0 to 40. Past 15 digits the value is a decimal string. Price: $0.001 USDC | typed |
entringer | The Entringer number E(n, k). E(1, 1) is 1, and E(n, k) = E(n, k-1) + E(n-1, n-k). E(5, 2) is 10, and E(6, 3) is 46. The last entry E(n, n) is the zigzag number a(n). n and k run from 1 to 40, and k m | typed |
genocchi | The nth Genocchi number |G(2n)|, from G(2n) = 2*(1-4^n)*B(2n) with B(1) = +1/2. The first four absolute values are 1, 1, 3, and 17. signed is (-1)^n times that value. n runs from 1 to 20. Past 15 digi | typed |
euler_secant | The nth secant number, the signed Euler number E(2n) = (-1)^n * a(2n). E(0) is 1, E(2) is -1, E(4) is 5, and E(6) is -61. n runs from 0 to 20. Past 15 digits the value is a decimal string. Price: $0.0 | typed |
involution | The number of involutions of n objects. I(0) and I(1) are 1, and I(n) = I(n-1) + (n-1)*I(n-2). I(5) is 26, and I(10) is 9496. n runs from 0 to 100. Past 15 digits the value is a decimal string. Price: | typed |
involution_sum | The sum of involution numbers from lo through hi inclusive. The sum from I(0) through I(10) is 13232. lo must not pass hi. Each index runs from 0 to 100. Past 15 digits the value is a decimal string. | typed |
involution_mod | I(n) mod m, the involution number reduced by a positive modulus. Zero is rejected. n runs from 0 to 100. The residue is smaller than the modulus. Price: $0.001 USDC per successful call (x402, Solana). | typed |
rencontres | The rencontres number D(n, k), the permutations of n objects with k fixed points. D(n, k) = C(n, k) * !(n-k). D(5, 0) is 44, and D(5, 2) is 20. n runs from 0 to 100, and k runs from 0 to n. Price: $0. | typed |
cantor_count | How many integers from 0 through n have only the digits 0 and 1 in base 3. The count through 0 is 1, through 2 is 2, and through 8 is 4. n runs from 0 to 999999999999999. Price: $0.001 USDC per succes | typed |
involution_fixed | The number of involutions of n objects with exactly k fixed points. It is 0 when n-k is odd. For n = 5 and k = 1 the count is 15, and for n = 5 and k = 5 it is 1. n runs from 0 to 100, and k runs from | typed |
fubini | The nth Fubini number, the ordered partitions of an n-element set. a(0) is 1, a(2) is 3, a(3) is 13, and a(5) is 541. n runs from 0 to 20. Past 15 digits the value is a decimal string. Price: $0.001 U | typed |
fubini_sum | The sum of Fubini numbers from lo through hi inclusive. The sum from a(0) through a(5) is 634. lo must not pass hi. Each index runs from 0 to 20. Past 15 digits the value is a decimal string. Price: $ | typed |
fubini_mod | The nth Fubini number mod m. The modulus is a positive decimal integer, and zero is rejected. n runs from 0 to 20. The residue is smaller than the modulus. Price: $0.001 USDC per successful call (x402 | typed |
lah | The unsigned Lah number L(n, k). L(0, 0) is 1, L(n, 0) is 0 for n > 0, and L(n, 1) is n!. L(5, 2) is 240, and L(6, 3) is 1200. n and k run from 0 to 20, and k must not pass n. Past 15 digits the value | typed |
lah_row | Row n of the unsigned Lah numbers, from L(n, 0) through L(n, n), written as comma-separated integers. Row 5 is 0,120,240,120,20,1. n runs from 0 to 12. Past 15 digits a term inside the row is still wr | typed |
riordan | The nth Riordan number. R(0) is 1, R(1) is 0, and (n+1)*R(n) = (n-1)*(2*R(n-1) + 3*R(n-2)) for n at least 2. R(4) is 3, and R(6) is 15. n runs from 0 to 80. Past 15 digits the value is a decimal strin | typed |
riordan_sum | The sum of Riordan numbers from lo through hi inclusive. The sum from R(0) through R(10) is 989. lo must not pass hi. Each index runs from 0 to 80. Past 15 digits the value is a decimal string. Price: | typed |
riordan_mod | R(n) mod m for the Riordan numbers. The modulus is a positive decimal integer, and zero is rejected. n runs from 0 to 80. The residue is smaller than the modulus. Price: $0.001 USDC per successful cal | typed |
fine | The nth Fine number. F(0) is 1, F(1) is 0, F(2) is 1, and F(6) is 57. For n at least 1, F(n) = C(n) - sum of C(i)*F(n-1-i) over i from 0 to n-1, with C the Catalan numbers. n runs from 0 to 80. Past 1 | typed |
fine_sum | The sum of Fine numbers from lo through hi inclusive. The sum from F(0) through F(6) is 85. lo must not pass hi. Each index runs from 0 to 80. Past 15 digits the value is a decimal string. Price: $0.0 | typed |
period_double | The period-doubling bit at index n, starting at 0. It is the parity of the exponent of 2 in n+1. Bit 0 is 0, bit 1 is 1, and the first 8 bits are 01000101. n runs from 0 to 999999999999999. Price: $0. | typed |
period_double_prefix | The first n period-doubling bits, as a string of the digits 0 and 1. The first 8 bits are 01000101. n runs from 1 to 4096. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: | typed |
period_double_sum | The number of 1s in the first n period-doubling bits, from index 0 through n-1. The first 8 bits have three 1s, and the first 100 bits have 33. n runs from 0 to 999999999999999. Price: $0.001 USDC per | typed |
cantor_bit | The Cantor bit of n. It is 1 when every base-3 digit of n is 0 or 1, and 0 when a digit is 2. Bit 0 is 1, bit 2 is 0, and bit 4 is 1. n runs from 0 to 999999999999999. Price: $0.001 USDC per successfu | typed |
two_squares | How many integer pairs (x, y), counting order and signs, satisfy x^2 + y^2 = n. There is 1 for 0, 4 for 1, and 8 for 5. n runs from 0 to 1000000000000. Price: $0.001 USDC per successful call (x402, So | typed |
two_squares_pair | Nonnegative integers x and y with x <= y and x^2 + y^2 = n, choosing the greatest y. 5 is 1 and 2. 25 is 0 and 5. A number that is not a sum of two squares is rejected. n runs from 0 to 1000000000000. | typed |
three_squares | Whether n is a sum of three integer squares, and one nonnegative witness x <= y <= z when it is. It is impossible exactly when n = 4^power * odd with odd congruent to 7 mod 8. 3 is 1, 1, 1. 7 is impos | typed |
four_squares | Four nonnegative integers w <= x <= y <= z with w^2 + x^2 + y^2 + z^2 = n. Every nonnegative integer has one. 7 is 1, 1, 1, 2. n runs from 0 to 1000000. Price: $0.001 USDC per successful call (x402, S | typed |
square_obstruction | Write n = 4^power * odd, with odd not divisible by 4. blocked is true when odd is congruent to 7 mod 8, which is exactly when n is not a sum of three squares. 7 and 28 are blocked. 6 is not. n runs fr | typed |
liouville | Liouville's function lambda(n) = (-1) to the number of prime factors of n, counted with multiplicity. lambda(1) is 1, lambda(2) is -1, and lambda(4) is 1. n runs from 1 to 1000000000000. Price: $0.001 | typed |
liouville_sum | The sum of Liouville's lambda(k) from 1 through n. The sum through 10 is 0, and the sum through 30 is -4. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool ove | typed |
mertens | The Mertens function M(n), the sum of the Mobius function mu(k) from 1 through n. M(1) is 1, M(10) is -1, and M(100) is 1. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solan | typed |
mertens_max | The largest absolute value of the Mertens function M(k) for k from 1 through n, and the smallest k where it occurs. Through 10 the maximum is 2 at k = 5. Through 100 it is 4 at k = 31. n runs from 1 t | typed |
prime_power | If n is a prime power p^k with k at least 1, return that prime and the exponent. Otherwise the prime and the exponent are 0. 8 is 2^3, 49 is 7^2, and 12 is not a prime power. n runs from 1 to 10000000 | typed |
square_part | The largest square dividing n. 1 gives 1, 8 gives 4, 12 gives 4, and 18 gives 9. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https | typed |
square_free_part | n divided by its largest square factor. 12 gives 3, 18 gives 2, 36 gives 1, and 45 gives 5. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: | typed |
powerful | Whether n is powerful: 1, or every prime factor's exponent is at least 2. 1, 8, and 36 are powerful. 12 is not. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). S | typed |
cubefull | Whether n is cubefull: 1, or every prime factor's exponent is at least 3. 1 and 8 are cubefull. 36 is powerful but not cubefull. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call | typed |
achilles | Whether n is an Achilles number: powerful, but not a perfect power. 72 and 108 are Achilles. 36 is a square, and 1 is a perfect power, so neither is Achilles. n runs from 1 to 1000000000000. Price: $0 | typed |
sigma_k | The sum of the kth powers of the divisors of n. sigma_2(1) is 1, sigma_2(6) is 50, and sigma_2(12) is 210. n runs from 1 to 1000000000000, and k runs from 2 to 12. Past 15 digits the value is a decima | typed |
abundancy | The abundancy sigma(n)/n as a reduced fraction. 1 is 1/1, 4 is 7/4, 6 is 2/1, and 12 is 7/3. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS | typed |
deficiency | The deficiency 2n - sigma(n). A deficient number is positive, a perfect number is 0, and an abundant number is negative. 4 is 1, 6 is 0, and 12 is -4. n runs from 1 to 1000000000000. Price: $0.001 USD | typed |
unitary_sigma | The sum of the unitary divisors of n. A unitary divisor shares no prime factor with the complementary divisor. The sum is 1 for 1, 12 for 6, 20 for 12, and 72 for 30. n runs from 1 to 1000000000000. P | typed |
unitary_count | How many unitary divisors n has. The count is 2 to the number of distinct prime factors, and 1 has one unitary divisor. 7 has 2, 12 has 4, and 30 has 8. n runs from 1 to 1000000000000. Price: $0.001 U | typed |
happy | Follow the happy-number map: replace n by the sum of the squares of its decimal digits. 1 is already happy. 7 reaches 1 in 5 steps. 4 is unhappy and the repeat is 4. n runs from 0 to 999999999999999. | typed |
harshad | Whether n is a base-10 Harshad number: n is divisible by the sum of its decimal digits. 18 is Harshad, and 11 is not. n runs from 1 to 999999999999999. Price: $0.001 USDC per successful call (x402, So | typed |
harshad_base | Whether n is a Harshad number in base b: n is divisible by the sum of its base-b digits. 10 is Harshad in base 2. 13 is not Harshad in base 10. n runs from 1 to 999999999999999, and b runs from 2 to 3 | typed |
additive_persistence | Additive persistence: how many times the decimal digits of n must be summed to reach a single digit, and that digit. 199 takes 3 steps and ends at 1. A single digit takes 0 steps. n runs from 0 to 999 | typed |
multiplicative_persistence | Multiplicative persistence: how many times the decimal digits of n must be multiplied to reach a single digit, and that digit. 39 takes 3 steps and ends at 4. 10 ends at 0 in 1 step. n runs from 0 to | typed |
wedderburn | The nth Wedderburn-Etherington number. a(1) is 1, and a(1) through a(6) are 1, 1, 1, 2, 3, 6. Even and odd indices use the binary-tree split, with the middle term only on an even index. n runs from 1 | typed |
wedderburn_sum | The sum of Wedderburn-Etherington numbers from lo through hi inclusive. The sum from a(1) through a(6) is 14. lo must not pass hi. Each index runs from 1 to 80. Past 15 digits the value is a decimal s | typed |
wedderburn_mod | a(n) mod m for the Wedderburn-Etherington numbers. The modulus is a positive decimal integer, and zero is rejected. n runs from 1 to 80. The residue is smaller than the modulus. Price: $0.001 USDC per | typed |
wedderburn_index | The smallest index n with Wedderburn-Etherington number a(n) equal to value. 1 is index 1, and 6 is index 6. A number that is not a term, or a leading zero, is rejected. value is a decimal integer of | typed |
wedderburn_split | The Wedderburn-Etherington split of n. cross is the sum of a(i)*a(n-i) over the pairs below the middle, and middle is a(k)*(a(k)+1)/2 when n = 2k and 0 when n is odd. n = 6 gives cross 5, middle 1, an | typed |
alt_factorial | The alternating factorial af(n) = n! - (n-1)! + (n-2)! - ... ending at 1. af(1) is 1, af(3) is 5, and af(4) is 19. n runs from 1 to 200. Past 15 digits the value is a decimal string. Price: $0.001 USD | typed |
alt_sum | The sum of alternating factorials from lo through hi inclusive. The sum from af(1) through af(5) is 127. lo must not pass hi. Each index runs from 1 to 200. Past 15 digits the value is a decimal strin | typed |
kurepa | The Kurepa function K(n), the sum of k! for k from 0 through n-1. K(1) is 1, K(2) is 2, and K(5) is 34. This is the left factorial, not the subfactorial. n runs from 1 to 200. Past 15 digits the value | typed |
superfactorial | The superfactorial sf(n), the product of k! for k from 1 through n. sf(1) is 1, sf(3) is 12, and sf(4) is 288. n runs from 1 to 20. Past 15 digits the value is a decimal string. Price: $0.001 USDC per | typed |
kurepa_mod | K(n) mod m for the Kurepa function, the sum of k! from 0 through n-1. The modulus is a positive decimal integer, and zero is rejected. n runs from 1 to 200. The residue is smaller than the modulus. Pr | typed |
next_prime | The least prime greater than or equal to n. 0, 1, and 2 all give 2. 14 gives 17. 10000000 gives 10000019. n runs from 0 to 10000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool ov | typed |
prev_prime | The greatest prime less than or equal to n. 2 gives 2, 10 gives 7, and 10000000 gives 9999991. n runs from 2 to 10000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: P | typed |
prime_count | pi(n), the number of primes less than or equal to n. pi(0) and pi(1) are 0, pi(10) is 4, pi(100) is 25, and pi(10000000) is 664579. n runs from 0 to 10000000. Price: $0.001 USDC per successful call (x | typed |
prime_nth | The kth prime. The 1st is 2, the 10th is 29, the 100th is 541, and the 664579th is 9999991. k runs from 1 to 664579. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST h | typed |
prime_gap | The prime at or below n, the next prime after that one, and the difference. At 10 the prime is 7, the next is 11, and the gap is 4. At 11 the gap from 11 to 13 is 2. n runs from 2 to 10000000. Price: | typed |
popcount | The number of 1 bits in n. 0 has none, 255 has 8, and 256 has 1. n runs from 0 to 999999999999999. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.i | typed |
bit_length | The bit length of n: 0 for 0, and one more than the position of the highest 1 bit otherwise. 1 has length 1, 255 has length 8, and 256 has length 9. n runs from 0 to 999999999999999. Price: $0.001 USD | typed |
bit_reverse | Reverse the lowest width bits of n. 13 reversed in width 4 is 11. 1 reversed in width 8 is 128. n must be smaller than 2^width. width runs from 1 to 62, and n runs from 0 to 999999999999999. Price: $0 | typed |
hamming_dist | The Hamming distance of a and b: how many bit positions differ. 13 and 7 differ in 2 places. 0 and 0 differ in none. Both run from 0 to 999999999999999. Price: $0.001 USDC per successful call (x402, S | typed |
bit_subset | Whether every 1 bit of a is also a 1 bit of b. 3 is a bit-subset of 7. 3 is not a bit-subset of 5. 0 is a bit-subset of 0. Both run from 0 to 999999999999999. Price: $0.001 USDC per successful call (x | typed |
kronecker | The Kronecker symbol (a/n) for any integers a and n. (2/7) is 1, (3/7) is -1, (2/4) is 0, and (1/0) is 1. Both a and n run from -1000000000000 to 1000000000000. Price: $0.001 USDC per successful call | typed |
legendre_symbol | The Legendre symbol (a/p) for an odd prime p. (2/7) is 1, (3/7) is -1, and (-1/5) is 1. p must be an odd prime. a runs from -1000000000000 to 1000000000000, and p runs from 0 to 1000000000000. Price: | typed |
quadratic_residue | Whether a is a square modulo an odd prime p, counting 0 as a square. 2 is a square mod 7, and 3 is not. -1 is a square mod 5 and not mod 7. p must be an odd prime. Price: $0.001 USDC per successful ca | typed |
padic | The p-adic valuation v_p(n): how many times the prime p divides n. v_2(12) is 2, v_3(12) is 1, and v_5(12) is 0. p must be prime. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call | typed |
factorial_valuation | The p-adic valuation of n!, the exponent of the prime p in n!. v_2(10!) is 8, v_3(10!) is 4, and v_2(100!) is 97. p must be prime. n runs from 0 to 1000000000000. Price: $0.001 USDC per successful cal | typed |
mult_order | The multiplicative order of a modulo n: the least positive k with a^k = 1 mod n. The order of 2 mod 7 is 3, and the order of 3 mod 7 is 6. a must be coprime to n. n runs from 2 to 1000000. Price: $0.0 | typed |
primitive_root | Whether g is a primitive root modulo the prime p. 3 is a primitive root mod 7, and 2 is not. 1 is a primitive root mod 2. p must be prime and runs from 2 to 1000000. Price: $0.001 USDC per successful | typed |
least_primitive_root | The least primitive root modulo the prime p. It is 1 for 2, 3 for 7, 5 for 23, and 6 for 41. p must be prime and runs from 2 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same too | typed |
mod_inverse | The inverse of a modulo m, the residue from 0 to m-1 with a*inverse = 1 mod m. The inverse of 3 mod 7 is 5, and the inverse of -1 mod 7 is 6. There is no inverse when a and m share a factor. m runs fr | typed |
power_mod | a to the power e, reduced modulo m. 2^10 mod 1000 is 24, 3^5 mod 7 is 5, and (-2)^3 mod 7 is 6. A zero exponent gives 1, including 0^0, except modulo 1 where every power is 0. e runs from 0 to 1000000 | typed |
eulerian | The Eulerian number A(n, k), the number of permutations of n with k ascents. A(4, 1) is 11, A(5, 2) is 66, and A(n, 0) is 1. k runs from 0 through n-1. n runs from 1 to 60. Past 15 digits the value is | typed |
eulerian_row | The Eulerian row A(n, 0) through A(n, n-1), comma-separated. The row for 5 is 1,26,66,26,1. It is symmetric and sums to n!. n runs from 1 to 12. Price: $0.001 USDC per successful call (x402, Solana). | typed |
eulerian_sum | The sum of Eulerian numbers A(n, k) for k from lo through hi. The whole row sums to n!. A(4, 0) through A(4, 1) is 12. lo must not pass hi, and hi must be an ascent of n. n runs from 1 to 60. Price: $ | typed |
eulerian_mod | A(n, k) mod m for the Eulerian numbers. The modulus is a positive decimal integer, and zero is rejected. k must be an ascent of n. n runs from 1 to 60. The residue is smaller than the modulus. Price: | typed |
eulerian_poly | The Eulerian polynomial A_n(x) = sum A(n, k) * x^k. A_3(2) is 13, A_4(1) is 24, and A_5(0) is 1. n runs from 1 to 20, and x runs from 0 to 10. Past 15 digits the value is a decimal string. Price: $0.0 | typed |
central_binomial | The nth central binomial coefficient (2n)!/(n!)^2. C(0) is 1, C(1) is 2, C(5) is 252, and C(10) is 184756. n runs from 0 to 200. Past 15 digits the value is a decimal string. Price: $0.001 USDC per su | typed |
central_sum | The sum of central binomial coefficients from lo through hi. The sum from C(0) through C(5) is 351. lo must not pass hi. Each index runs from 0 to 200. Past 15 digits the value is a decimal string. Pr | typed |
central_mod | C(n) mod m for the central binomial coefficients. C(10) mod 7 is 5. The modulus is a positive decimal integer, and zero is rejected. n runs from 0 to 200. Price: $0.001 USDC per successful call (x402, | typed |
central_index | The index n with central binomial coefficient C(n) equal to value. 1 is index 0, and 2 is index 1. A number that is not a term, or a leading zero, is rejected. value is a decimal integer of at most 60 | typed |
central_ratio | The ratio C(n)/C(n-1) = (4n-2)/n in lowest terms. For 1 it is 2/1, for 2 it is 3/1, and for 3 it is 10/3. n runs from 1 to 200. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HT | typed |
practical | Whether n is practical: every integer from 1 to n is a sum of distinct divisors of n. 1, 2, 6, and 12 are practical. 3 and 10 are not. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful | typed |
practical_count | How many practical numbers are from 1 through n. There are 5 through 10, and 15 through 40. n runs from 1 to 5000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST htt | typed |
semiperfect | Whether some subset of the proper divisors of n sums to n. 6 and 12 are semiperfect. 10 and 70 are not. n runs from 1 to 20000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HT | typed |
weird | Whether n is weird: abundant, but not semiperfect. 70 is weird, and so is 836. 12 is abundant but semiperfect, so it is not weird. n runs from 1 to 20000. Price: $0.001 USDC per successful call (x402, | typed |
amicable | Whether n is amicable, and its partner when it is. The partner of 220 is 284, and the partner of 284 is 220. A perfect number such as 6 is not amicable, and then the partner is 0. n runs from 1 to 100 | typed |
landau | Landau's function g(n), the largest least common multiple of the parts of a partition of n. g(0) is 1, g(5) is 6, g(7) is 12, and g(10) is 30. n runs from 0 to 25. Price: $0.001 USDC per successful ca | typed |
landau_sum | The sum of Landau's function from lo through hi. The sum from g(0) through g(10) is 100. lo must not pass hi. Each index runs from 0 to 25. Price: $0.001 USDC per successful call (x402, Solana). Same | typed |
landau_mod | g(n) mod m for Landau's function. g(12) mod 7 is 4, and g(25) mod 97 is 96. The modulus is a positive decimal integer, and zero is rejected. n runs from 0 to 25. Price: $0.001 USDC per successful call | typed |
landau_index | The smallest n with Landau value g(n) equal to value. 1 is index 0, and 6 is index 5. A number that is not a value, or a leading zero, is rejected. value is a decimal integer of at most 12 digits. Pri | typed |
range_lcm | The least common multiple of the integers from lo through hi. The LCM of 1 through 10 is 2520, and the LCM of 1 through 11 is 27720. lo must not pass hi. Each end runs from 1 to 40. Price: $0.001 USDC | typed |
lucky | Whether n is a lucky number. The list begins 1, 3, 7, 9, 13, 15, 21. 5 and every even number are not lucky. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool ov | typed |
lucky_nth | The kth lucky number. The 1st is 1, the 10th is 33, and the 20th is 79. k runs from 1 to 8772, which is the count of lucky numbers through 100000. Price: $0.001 USDC per successful call (x402, Solana) | typed |
lucky_next | The least lucky number greater than or equal to n. 2 gives 3, 20 gives 21, and 49 gives 49. n runs from 1 to 99987, the last lucky number through 100000. Price: $0.001 USDC per successful call (x402, | typed |
lucky_twin | Whether n and n+2 are both lucky. 1, 7, and 13 start a lucky pair. 3 does not, because 5 is not lucky. n runs from 1 to 99985. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTT | typed |
hexanacci | The nth hexanacci number. H(0) through H(4) are 0, H(5) is 1, and H(10) is 16. Each later term adds the previous six. n runs from 0 to 512. Past 15 digits the value is a decimal string. Price: $0.001 | typed |
hexanacci_sum | The sum of hexanacci numbers from lo through hi. The sum from H(0) through H(10) is 32. lo must not pass hi. Each index runs from 0 to 512. Past 15 digits the value is a decimal string. Price: $0.001 | typed |
hexanacci_mod | H(n) mod m for the hexanacci numbers. H(10) mod 7 is 2, and H(57) mod 97 is 61. The modulus is a positive decimal integer, and zero is rejected. n runs from 0 to 512. Price: $0.001 USDC per successful | typed |
hexanacci_index | The smallest index n with hexanacci number H(n) equal to value. 0 is index 0, and 1 is index 5. A number that is not a term, or a leading zero, is rejected. value is a decimal integer of at most 600 d | typed |
hexanacci_step | The hexanacci step H(n) = H(n-1) + H(n-2) + H(n-3) + H(n-4) + H(n-5) + H(n-6). a through f are those six earlier terms, from oldest to newest. n runs from 6 to 512. Past 15 digits a term is a decimal | typed |
largest_prime_factor | The largest prime factor of n. It is 1 for 1, 3 for 12, 5 for 30, and 7 for 35. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https: | typed |
smallest_prime_factor | The smallest prime factor of n. It is 1 for 1, 2 for 12, 5 for 35, and 7 for 49. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https | typed |
smooth | Whether n is y-smooth: its largest prime factor is at most y. 12 is 3-smooth and not 2-smooth. 1 is 1-smooth. n and y run from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana) | typed |
rough | Whether n is y-rough: its smallest prime factor is at least y. 35 is 5-rough and not 7-rough. 1 is 1-rough and not 2-rough. n and y run from 1 to 1000000000000. Price: $0.001 USDC per successful call | typed |
powersmooth | Whether n is y-power-smooth: every maximal prime-power factor p^k is at most y. 12 is 4-power-smooth and not 3-power-smooth. 8 is 8-power-smooth and not 4-power-smooth. n and y run from 1 to 100000000 | typed |
highly_composite | Whether n is highly composite: it has strictly more divisors than every smaller positive integer. 1, 2, 6, 12, 60, and 5040 are. 3 and 30 are not. n runs from 1 to 20000. Price: $0.001 USDC per succes | typed |
highly_composite_next | The least highly composite number greater than or equal to n. 1 gives 1, 3 gives 4, 7 gives 12, and 5041 gives 7560. n runs from 1 to 7560. Price: $0.001 USDC per successful call (x402, Solana). Same | typed |
highly_composite_count | How many highly composite numbers are from 1 through n. There are 4 through 10, 9 through 60, and 10 through 120. n runs from 1 to 20000. Price: $0.001 USDC per successful call (x402, Solana). Same to | typed |
divisor_record | The largest number of divisors attained by any integer from 1 through n, and the smallest integer that attains it. Through 10 the record is 4 at 6. Through 12 it is 6 at 12. n runs from 1 to 20000. Pr | typed |
refactorable | Whether n is refactorable: the number of positive divisors of n divides n. 1, 2, 8, 9, and 12 are refactorable. 4 and 6 are not. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call | typed |
subtraction_grundy | The Grundy value of a heap of n in the subtraction game with the given move sizes. With moves 1, 2, and 3, the value of n is n mod 4. n runs from 0 to 500, and there are 1 to 8 moves, each from 1 to 1 | typed |
subtraction_win | Whether the player to move wins a subtraction game on a heap of n with perfect play. A win is a nonzero Grundy value. With moves 1, 2, and 3, 5 is a win and 4 is a loss. n runs from 0 to 500. Price: $ | typed |
subtraction_row | Grundy values from heap 0 through heap n in a subtraction game, comma-separated. With moves 1, 2, and 3, the row through 8 is 0,1,2,3,0,1,2,3,0. n runs from 0 to 32. Price: $0.001 USDC per successful | typed |
nim_sum | The nim-sum of a and b, their bitwise exclusive or. 13 xor 7 is 10, and 255 xor 256 is 511. Both run from 0 to 999999999999999. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HT | typed |
mex | The mex of a list: the smallest missing nonnegative integer. The mex of 0, 1, 3 is 2. The mex of 1, 2, 3 is 0. The mex of an empty list is 0. The list has at most 64 integers, each from 0 to 1000. Pri | typed |
cayley | The number of trees on n labeled vertices, n^(n-2). One vertex gives 1, two give 1, three give 3, and four give 16. n runs from 1 to 30. Past 15 digits the value is a decimal string. Price: $0.001 USD | typed |
cayley_rooted | The number of rooted trees on n labeled vertices, n^(n-1). Four vertices give 64. n runs from 1 to 30. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solan | typed |
prufer_encode | The Prüfer code of a tree on vertices 1..n. Edges are a flat list of pairs. The path 1-2-3-4 gives 2,3. The star with center 1 and leaves 2,3,4 gives 1,1. Two vertices give an empty code. Vertices run | typed |
prufer_decode | The tree edges for a Prüfer code, as a flat list of sorted pairs. Code 2,3 is the path 1-2-3-4. Code 1,1 is the star at 1. An empty code is the edge 1-2. Code entries run from 1 to 30. Price: $0.001 U | typed |
prufer_degree | The degree of a vertex in the tree described by a Prüfer code. Degree is one plus the number of times the vertex appears. In code 2,3, vertex 2 has degree 2 and vertex 1 has degree 1. The vertex must | typed |
polygonal | The nth s-gonal number, n*((s-2)*n - (s-4))/2. Triangular 4 is 10, square 5 is 25, pentagonal 5 is 35, and hexagonal 5 is 45. s runs from 3 to 20 and n from 0 to 1000000. The 0th number is 0 and the 1 | typed |
polygonal_index | The index n of an s-gonal number. Triangular 10 is index 4, and square 25 is index 5. 0 is index 0. A value that is not s-gonal is rejected. s runs from 3 to 20 and the value from 0 to 999999999999999 | typed |
centered_polygonal | The nth centered s-gonal number, s*n*(n-1)/2 + 1. Centered triangular 4 is 19, centered square 2 is 5, and centered hexagonal 3 is 19. s runs from 3 to 20 and n from 1 to 1000000. Price: $0.001 USDC p | typed |
twin_prime | Whether n and n+2 are both prime. 3 pairs with 5, 5 pairs with 7, and 7 does not pair with 9. n runs from 1 to 1000000000000. The partner is n+2. Price: $0.001 USDC per successful call (x402, Solana). | typed |
cousin_prime | Whether n and n+4 are both prime. 3 pairs with 7, and 7 pairs with 11. 5 does not pair with 9. n runs from 1 to 1000000000000. The partner is n+4. Price: $0.001 USDC per successful call (x402, Solana) | typed |
sexy_prime | Whether n and n+6 are both prime. 5 pairs with 11, 7 pairs with 13, and 3 does not pair with 9. n runs from 1 to 1000000000000. The partner is n+6. Price: $0.001 USDC per successful call (x402, Solana | typed |
sophie_germain | Whether n and 2*n+1 are both prime. 2 gives the safeprime 5, 11 gives 23, and 7 gives 15, which is not prime. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Sam | typed |
safeprime | Whether n and (n-1)/2 are both prime. 5 comes from 2, 7 comes from 3, and 23 comes from 11. 3 and 17 are not safeprimes. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, S | typed |
goldbach | The Goldbach split of an even n with the smallest prime p, so n = p+q and p <= q. 10 gives 3 and 7. 20 gives 3 and 17. 4 gives 2 and 2. n is even, from 4 to 10000. Price: $0.001 USDC per successful ca | typed |
goldbach_count | How many Goldbach splits an even n has, with p <= q. 10 has 2, 20 has 2, and 100 has 6. n is even, from 4 to 10000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST ht | typed |
goldbach_check | Whether p and n-p are both prime. For n=10, p=3 and p=5 work, and p=2 does not. n is even, from 4 to 10000, and p runs from 2 to 10000. Price: $0.001 USDC per successful call (x402, Solana). Same tool | typed |
levy | Levy writes an odd n as p+2q with p and q prime, choosing the smallest p. 7 is 3+2*2, 27 is 5+2*11, and 21 is 7+2*7. n is odd, from 7 to 9999. Price: $0.001 USDC per successful call (x402, Solana). Sa | typed |
odd_goldbach | The lexicographically smallest triple of primes adding to an odd n. 7 is 2+2+3, 9 is 2+2+5, and 27 is 2+2+23. n is odd, from 7 to 9999. Price: $0.001 USDC per successful call (x402, Solana). Same tool | typed |
kaprekar | Whether n is a Kaprekar number. Split n^2 so the right part has as many digits as n; the two parts add to n, and the right part is not 0. 1, 9, 45, 297, and 9999 are. 10 is not. n runs from 1 to 10000 | typed |
automorphic | Whether n^2 ends with n. 1, 5, 6, 25, 76, 376, 625, and 9376 do. 10 does not. n runs from 1 to 10000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptec | typed |
trimorphic | Whether n^3 ends with n. 1, 4, 5, 6, 9, 25, 49, 76, 125, and 999 do. 10 does not. n runs from 1 to 10000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scor | typed |
narcissistic | Whether n equals the sum of its digits each raised to the number of digits. 153, 370, 371, and 407 do, and so does every one-digit number. 10 does not. n runs from 1 to 100000. Price: $0.001 USDC per | typed |
dudeney | Whether n is a perfect cube and its digits add to the cube root. 1, 512, 4913, 5832, 17576, and 19683 are. 100 is not a cube. n runs from 1 to 200000. The root is 0 when n is not a Dudeney number. Pri | typed |
factorion | Whether n equals the sum of the factorials of its digits. 1, 2, 145, and 40585 do. 24 and 10 do not. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTP | typed |
smith | Whether n is a composite Smith number: its digit sum equals the digit sum of its prime factors with multiplicity. 4, 22, 27, and 121 are. 6 and every prime are not. n runs from 1 to 1000000. Price: $0 | typed |
cake_number | The cake number, the most pieces of space cut by n planes: (n^3 + 5*n + 6)/6. Zero planes give 1, three give 8, and five give 26. n runs from 0 to 100000. Price: $0.001 USDC per successful call (x402, | typed |
hoax | Whether n is a composite hoax number: its digit sum equals the digit sum of its distinct prime factors. 22, 58, and 84 are. 4 is Smith but not hoax. Primes are not. n runs from 1 to 1000000. Price: $0 | typed |
sphenic | Whether n is a product of three distinct primes. 30, 42, 66, and 70 are. 12 and 60 are not, because of the square factor. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana | typed |
almost_perfect | Whether sigma(n) = 2*n - 1. Powers of two, including 1, are almost perfect. 16 gives sigma 31. 6 and 10 are not. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same t | typed |
mersenne | The Mersenne number 2^n - 1. Exponent 1 gives 1, 2 gives 3, and 31 gives 2147483647. n runs from 1 to 128. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, S | typed |
mersenne_prime | Whether 2^n - 1 is prime. Exponents 2, 3, 5, 7, 13, 17, 19, and 31 are, inside this cap. Exponent 11 is not, because 2047 = 23*89. n runs from 2 to 31. This checks the given exponent. Price: $0.001 US | typed |
fermat_number | The Fermat number 2^(2^n) + 1. n=0 gives 3, n=4 gives 65537, and n=5 gives 4294967297. n runs from 0 to 12. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, | typed |
fermat_prime | Whether the Fermat number 2^(2^n) + 1 is prime. n from 0 through 4 gives a prime. n=5 does not: 4294967297 = 641*6700417. n runs from 0 to 5. This checks the given n. Price: $0.001 USDC per successful | typed |
proth | The Proth number k*2^n + 1. k must be odd and strictly less than 2^n. 1*2^1+1 is 3, and 3*2^5+1 is 97. An even k, or a k that is not below 2^n, is rejected. n runs from 1 to 40. Price: $0.001 USDC per | typed |
wilson_quotient | The Wilson quotient ((p-1)! + 1) / p for a prime p. The quotient of 5 is 5, of 7 is 103, and of 13 is 36846277. A composite is rejected. p runs from 2 to 100. This checks the given prime. Price: $0.00 | typed |
wilson_prime | Whether p^2 divides (p-1)! + 1. Inside this cap, 5 and 13 do, and 2, 3, 7, 11, and 17 do not. A composite is rejected. p runs from 2 to 100. This checks the given prime. Price: $0.001 USDC per success | typed |
factorial_prime | Whether n! + 1 and n! - 1 are prime. Both are prime for n=3. For n=11, only n! + 1 is prime. For n=12, only n! - 1 is prime. n! - 1 is not prime for n=0 or 1. n runs from 0 to 12. Price: $0.001 USDC p | typed |
primorial_prime | Whether n# + 1 and n# - 1 are prime, where n# is the product of the primes up to n. 5# is 30, and both neighbors are prime. 7# is 210, and only 211 is prime. n runs from 2 to 30. Price: $0.001 USDC pe | typed |
brocard | Whether n! + 1 is a perfect square. 4! + 1 = 5^2, 5! + 1 = 11^2, and 7! + 1 = 71^2. The root is 0 when it is not a square. n runs from 1 to 12. Price: $0.001 USDC per successful call (x402, Solana). S | typed |
square_sum | The sum of the first n squares, n*(n+1)*(2n+1)/6. The sum through 1 is 1, and through 10 is 385. n runs from 0 to 1000000. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successf | typed |
cube_sum | The sum of the first n cubes, (n*(n+1)/2)^2. The sum through 2 is 9, and through 10 is 3025. n runs from 0 to 100000. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful ca | typed |
tetrahedral | The nth tetrahedral number, n*(n+1)*(n+2)/6. The 5th is 35 and the 8th is 120. n runs from 0 to 1000000. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Sol | typed |
lazy_caterer | The lazy caterer number, the most pieces of a pancake cut by n straight cuts: n*(n+1)/2 + 1. Zero cuts give 1, three give 7, and five give 16. n runs from 0 to 10000000. Price: $0.001 USDC per success | typed |
cullen | The nth Cullen number, n*2^n + 1. The 1st is 3, the 2nd is 9, and the 5th is 161. n runs from 1 to 256. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Sola | typed |
woodall | The nth Woodall number, n*2^n - 1. The 1st is 1, the 2nd is 7, and the 3rd is 23. n runs from 1 to 256. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Sola | typed |
thabit | The nth Thabit number, 3*2^n - 1. n=0 gives 2, n=1 gives 5, and n=2 gives 11. n runs from 0 to 256. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). | typed |
carol | The nth Carol number, (2^n - 1)^2 - 2. n=1 gives -1, n=2 gives 7, and n=3 gives 47. n runs from 1 to 128. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, So | typed |
kynea | The nth Kynea number, (2^n + 1)^2 - 2. n=1 gives 7, n=2 gives 23, and n=3 gives 79. n runs from 1 to 128. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, So | typed |
hyperperfect | Whether n = 1 + k*(sigma(n) - n - 1) for a positive integer k, and that k. 6 and 28 give k=1. 21 gives k=2. 12 and 120 do not. k is 0 when n is not hyperperfect. n runs from 1 to 100000. Price: $0.001 | typed |
multiperfect | Whether sigma(n) is a multiple of n, with multiplicity k at least 2. 6 and 28 give k=2. 120 and 672 give k=3. 1 and 12 do not. k is 0 when n is not multiperfect. n runs from 1 to 100000. Price: $0.001 | typed |
triperfect | Whether sigma(n) = 3*n. 120 and 672 are triperfect. 6 and 28 are perfect, so they are not. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST ht | typed |
betrothed | Whether n and m are betrothed: the sum of proper divisors of n is m+1, and the sum for m is n+1, with m different from n. 48 pairs with 75, and 140 pairs with 195. The partner is 0 when n is not betro | typed |
ore | Whether n is an Ore number: n times the divisor count is divisible by sigma(n), so the harmonic mean of the divisors is an integer. 1 gives 1, 6 gives 2, and 140 gives 5. 10 does not. The mean is 0 wh | typed |
leyland | The Leyland number x^y + y^x. 2 and 2 give 8, 2 and 3 give 17, and 3 and 3 give 54. x and y each run from 2 to 20. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call | typed |
wagstaff | The Wagstaff number (2^p + 1)/3 for an odd prime p. p=3 gives 3, p=5 gives 11, and p=7 gives 43. An even number or a composite is rejected. p runs from 3 to 127. Price: $0.001 USDC per successful call | typed |
wagstaff_prime | Whether the Wagstaff number (2^p + 1)/3 is prime. p=3, 5, 7, and 31 are. p=29 is not. An even number or a composite is rejected. p runs from 3 to 31. This checks the given prime. Price: $0.001 USDC pe | typed |
polite | Whether n is polite: it is a sum of two or more consecutive positive integers. Every number that is not a power of two is polite. 3, 6, and 9 are. 1, 2, 4, and 8 are not. n runs from 1 to 1000000. Pri | typed |
polite_split | The shortest sum of consecutive positive integers equal to n. 9 is 4+5, so it starts at 4 and has length 2. 6 is 1+2+3. 100 starts at 18 and has length 5. A power of two is rejected. n runs from 1 to | typed |
totient_sum | The sum of Euler totients from 1 through n. Through 1 it is 1, through 5 it is 10, and through 10 it is 32. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool ov | typed |
farey_count | How many reduced fractions lie in the Farey sequence of order n, from 0/1 through 1/1. Order 1 has 2, order 5 has 11, and order 6 has 13. The count is one more than the totient sum. n runs from 1 to 1 | typed |
visible_points | How many lattice points (x, y) with 1 <= x,y <= n are visible from the origin, meaning gcd(x, y) = 1. The 1-square has 1, the 2-square has 3, and the 5-square has 19. n runs from 1 to 100000. Price: $ | typed |
gcd_sum | The sum of gcd(x, y) over 1 <= x,y <= n. Through 1 it is 1, through 5 it is 37, and through 10 it is 189. n runs from 1 to 5000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over H | typed |
cototient | The cototient n - totient(n): how many integers from 1 to n share a factor with n. 1 gives 0, 6 gives 4, 9 gives 3, and 10 gives 6. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x40 | typed |
josephus | The surviving seat in the Josephus circle. Seats are 1 through n, counting starts at 1, and every k-th remaining person leaves. 5 people and every 2nd leave seat 3. 41 people and every 3rd leave seat | typed |
josephus_k2 | The Josephus survivor when every 2nd person is eliminated. Write n = 2^m + l with l < 2^m. The survivor is 2*l + 1. 5 gives 3, 10 gives 5, and 41 gives 19. n runs from 1 to 1000000. Price: $0.001 USDC | typed |
josephus_first | The first person eliminated in the Josephus circle. With 5 people and every 2nd, person 2 leaves first. With every 3rd, person 3 leaves first. A circle of one person has nobody to eliminate. n runs fr | typed |
josephus_order | The elimination order in the Josephus circle, comma-separated, not including the survivor. With 5 people and every 2nd, the order is 2,4,1,5. n runs from 2 to 24 and k from 1 to 100. Price: $0.001 USD | typed |
josephus_place | When a seat is eliminated. Place 1 is the first person out. The survivor has place n. With 5 people and every 2nd, seat 2 has place 1 and seat 3 has place 5. The seat must be from 1 to n. n runs from | typed |
fourth_sum | The sum of the first n fourth powers, n(n+1)(2n+1)(3n^2+3n-1)/30. The sum through 0 is 0, through 1 is 1, and through 10 is 25333. n runs from 0 to 10000. Past 15 digits the value is a decimal string. | typed |
fifth_sum | The sum of the first n fifth powers, n^2(n+1)^2(2n^2+2n-1)/12. The sum through 10 is 220825. n runs from 0 to 10000. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful cal | typed |
sixth_sum | The sum of the first n sixth powers, n(n+1)(2n+1)(3n^4+6n^3-3n+1)/42. The sum through 10 is 1978405. n runs from 0 to 10000. Past 15 digits the value is a decimal string. Price: $0.001 USDC per succes | typed |
seventh_sum | The sum of the first n seventh powers, n^2(n+1)^2(3n^4+6n^3-n^2-4n+2)/24. The sum through 10 is 18080425. n runs from 0 to 10000. Past 15 digits the value is a decimal string. Price: $0.001 USDC per s | typed |
odd_square_sum | The sum of the first n odd squares: 1^2 + 3^2 + ... + (2n-1)^2 = n(4n^2-1)/3. One term is 1, two terms are 10, and four terms are 84. n runs from 0 to 1000000. Past 15 digits the value is a decimal st | typed |
cyclotomic | The cyclotomic value Phi_n(a) for an integer a at least 2. Phi_1(2) is 1, Phi_5(2) is 31, Phi_6(3) is 7, and Phi_1(5) is 4. n runs from 1 to 40 and a from 2 to 20. Past 15 digits the value is a decima | typed |
cyclotomic_one | Phi_n(1). It is 0 when n is 1. When n is a power of a prime p, it is p. Otherwise it is 1. Phi_4(1) is 2, Phi_6(1) is 1, and Phi_9(1) is 3. n runs from 1 to 1000000. Price: $0.001 USDC per successful | typed |
cyclotomic_neg | Phi_n(-1). n=1 gives -2, n=2 gives 0, n=6 gives 3, and n=10 gives 5. n runs from 1 to 120. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/ap | typed |
cyclotomic_coeff | The coefficient of x^k in Phi_n. Phi_6 has coefficients 1, -1, 1, so k=1 is -1. The coefficient of x^7 in Phi_105 is -2. k past the degree is rejected. n runs from 1 to 120. Price: $0.001 USDC per suc | typed |
cyclotomic_height | The largest absolute coefficient of Phi_n. Phi_1 through Phi_15 have height 1. Phi_105 has height 2. n runs from 1 to 120. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: | typed |
sqrt_period | The period of the continued fraction of sqrt(d). sqrt(2) has period 1, sqrt(3) has period 2, sqrt(7) has period 4, and sqrt(13) has period 5. A square is rejected. d runs from 1 to 100000. Price: $0.0 | typed |
sqrt_cf | The continued fraction of sqrt(d): the integer part a0 and the repeating block, comma-separated. sqrt(2) is 1 with block 2. sqrt(19) is 4 with block 2,1,3,1,2,8. A square is rejected. d runs from 1 to | typed |
neg_pell | Whether x^2 - d*y^2 = -1 has a positive integer solution. It does exactly when the continued-fraction period of sqrt(d) is odd. d=2, 5, and 13 do. d=3, 6, and 7 do not. A square is rejected. d runs fr | typed |
sqrt_tail | The last term of the repeating block of sqrt(d), which is twice the integer part. sqrt(2) ends in 2, sqrt(3) ends in 2, and sqrt(10) ends in 6. A square is rejected. d runs from 1 to 100000. Price: $0 | typed |
neg_pell_count | How many nonsquares from 1 through n have an odd continued-fraction period, so the negative Pell equation is solvable. Through 2 there is 1, through 10 there are 3, and through 13 there are 4. n runs | typed |
self_number | Whether n is a self number: no m has m plus its digit sum equal to n. 1, 20, and 108 are. 2, 10, and 21 are not. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same t | typed |
self_count | How many self numbers are at most n. Through 1 there is 1, through 10 there are 5, through 20 there are 6, and through 100 there are 13. n runs from 1 to 20000. Price: $0.001 USDC per successful call | typed |
self_next | The smallest self number that is at least n. 1 stays 1, 2 gives 3, 10 gives 20, and 21 gives 31. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: P | typed |
self_nth | The kth self number. The 1st is 1, the 5th is 9, the 10th is 64, and the 20th is 165. k runs from 1 to 2000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://s | typed |
self_seed | m plus the sum of its decimal digits. 1 gives 2, 5 gives 10, 19 gives 29, and 99 gives 117. A self number is a number this map never hits. m runs from 0 to 1000000000000. Price: $0.001 USDC per succes | typed |
factoradic | The factorial-base digits of n, from the highest place down through the 0! place, comma-separated. The last digit is always 0. 0 is "0", 5 is "2,1,0", 23 is "3,2,1,0", and 463 is "3,4,1,0,1,0". n runs | typed |
factoradic_decode | The integer value of factorial-base digits. The last entry is the 0! place. [2, 1, 0] is 5 and [3, 2, 1, 0] is 23. A digit in the k! place must be from 0 through k. At most 20 digits. Price: $0.001 US | typed |
factoradic_digit | The digit of the k! place of n. It is floor(n / k!) mod (k+1), and it is 0 when k! exceeds n. The 0! digit is always 0. For 463 the 5! digit is 3 and the 4! digit is 4. k runs from 0 to 20. Price: $0. | typed |
factoradic_length | How many factorial-base digits n has, including the 0! place. 0 has 1, 5 has 3, 23 has 4, and 24 has 5. n runs from 0 to 999999999999999. Price: $0.001 USDC per successful call (x402, Solana). Same to | typed |
factoradic_sum | The sum of the factorial-base digits of n. 0 sums to 0, 5 sums to 3, 23 sums to 6, and 463 sums to 9. n runs from 0 to 999999999999999. Price: $0.001 USDC per successful call (x402, Solana). Same tool | typed |
binary_partition | The number of binary partitions of n, partitions into powers of two. b(0) is 1. Odd n copies b(n-1). Even n is b(n-1) plus b(n/2). b(1) is 1, b(4) is 4, and b(10) is 14. n runs from 0 to 1000. Price: | typed |
binary_partition_sum | The sum of the binary partition numbers from b(0) through b(n). Through 0 it is 1, through 4 it is 10, through 10 it is 60, and through 20 it is 390. n runs from 0 to 1000. Price: $0.001 USDC per succ | typed |
plane_partition | The number of plane partitions of n. The values begin 1, 1, 3, 6, 13, 24, so n=5 is 24, n=9 is 282, and n=10 is 500. n runs from 0 to 80. Price: $0.001 USDC per successful call (x402, Solana). Same to | typed |
plane_partition_sum | The sum of the plane partition numbers from 0 through n. Through 0 it is 1, through 2 it is 5, through 4 it is 24, and through 5 it is 48. n runs from 0 to 80. Price: $0.001 USDC per successful call ( | typed |
overpartition | The number of overpartitions of n. The first part may be overlined. The values begin 1, 2, 4, 8, 14, 24, so n=4 is 14 and n=10 is 232. n runs from 0 to 80. Price: $0.001 USDC per successful call (x402 | typed |
highly_abundant | Whether sigma(n) is strictly larger than sigma(m) for every m below n. 1, 6, 8, and 16 are. 5 and 9 are not. n runs from 1 to 10000. Price: $0.001 USDC per successful call (x402, Solana). Same tool ov | typed |
superabundant | Whether sigma(n)/n is strictly larger than sigma(m)/m for every m below n. The ratio is compared as sigma(n)*m against sigma(m)*n. 1, 2, 4, 6, and 12 are. 3, 8, and 16 are not. n runs from 1 to 10000. | typed |
primitive_abundant | Whether n is abundant and no proper divisor is abundant. 12, 18, 20, and 70 are. 24 is not, because 12 divides it. 6 is perfect, so it is not. n runs from 1 to 10000. Price: $0.001 USDC per successful | typed |
abundance | sigma(n) minus 2n. A perfect number gives 0, an abundant number gives a positive value, and a deficient number gives a negative value. 12 gives 4, 6 gives 0, 10 gives -2, and 1 gives -1. n runs from 1 | typed |
perfect_totient | Whether n equals the sum of its iterated totients down to 1. The sum includes the final 1 and excludes n. 3, 9, 15, and 27 are. 1, 2, and 6 are not. n runs from 1 to 100000. Price: $0.001 USDC per suc | typed |
balanced_prime | Whether n is prime and equal to the average of the previous prime and the next prime. 5, 53, 157, and 1103 are. 2, 3, 7, and 11 are not. n runs from 1 to 5000. Price: $0.001 USDC per successful call ( | typed |
prime_triplet | Whether n starts a prime triplet: n, n+2, and n+6 are prime, or n, n+4, and n+6 are prime. 5, 7, 11, and 13 do. 3 and 19 do not. n runs from 1 to 10000. Price: $0.001 USDC per successful call (x402, S | typed |
prime_triplet_count | How many prime-triplet starters are at most n. Through 3 there are none, through 5 there is 1, through 13 there are 4, and through 17 there are 5. n runs from 1 to 5000. Price: $0.001 USDC per success | typed |
chen_prime | Whether n is prime and n+2 is either prime or a product of two primes, counted with multiplicity. 2, 41, and 47 are. 43 is not, because 45 has three prime factors. n runs from 1 to 10000. Price: $0.00 | typed |
depolignac | Whether odd n is never a prime plus a power of two, counting 2^0. 1 qualifies, because nothing smaller works. 3 is 2+1, so it does not. 127 is the next, and 905 is another. Even n is rejected. n runs | typed |
arithmetic_derivative | The arithmetic derivative of n. 0 and 1 give 0, a prime gives 1, 4 gives 4, 6 gives 5, 8 gives 12, and 12 gives 16. n runs from 0 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Sam | typed |
arithmetic_second | The second arithmetic derivative of n. 6 goes 5 then 1. 8 goes 12 then 16. 4 stays 4. 0 and 1 stay 0. n runs from 0 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HT | typed |
derivative_fixed | Whether n equals its arithmetic derivative. 0, 4, 27, and 3125 do. 1, 6, and 16 do not. n runs from 0 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST http | typed |
sopf | The sum of the distinct prime factors of n. 1 gives 0, 8 gives 2, 12 gives 5, and 30 gives 10. A prime gives itself. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Sa | typed |
ruth_aaron | Whether n and n+1 have the same sum of prime factors, counted with repetition. 5, 8, 15, and 714 do. 6 and 9 do not. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Sa | typed |
mcnugget | Whether n nuggets can be ordered in boxes of 6, 9, and 20. 0, 6, and 44 can. 1, 11, and 43 cannot. n runs from 0 to 5000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: P | typed |
mcnugget_ways | How many combinations of 6, 9, and 20 boxes add to n. 0 has 1 empty order, 6 has 1, 18 has 2, 43 has 0, and 44 has 2. n runs from 0 to 5000. Price: $0.001 USDC per successful call (x402, Solana). Same | typed |
mcnugget_min | The fewest boxes of 6, 9, and 20 that add to n. 0 takes 0, 6 takes 1, 12 takes 2, and 44 takes 4. An amount that cannot be ordered is rejected. n runs from 0 to 5000. Price: $0.001 USDC per successful | typed |
mcnugget_count | How many integers from 0 through n can be ordered in boxes of 6, 9, and 20. Through 0 there is 1, through 6 there are 2, through 43 there are 22, and through 100 there are 79. n runs from 0 to 5000. P | typed |
mcnugget_miss | How many positive integers through n cannot be ordered in boxes of 6, 9, and 20. Through 1 there is 1, through 6 there are 5, and from 43 onward there are 22. n runs from 0 to 5000. Price: $0.001 USDC | typed |
collatz_steps | How many Collatz steps it takes to reach 1. 1 takes 0, 2 takes 1, 3 takes 7, 6 takes 8, 7 takes 16, and 27 takes 111. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Sa | typed |
collatz_max | The largest value on the Collatz path from n through 1, including n. 1 peaks at 1, 3 peaks at 16, 7 peaks at 52, and 27 peaks at 9232. n runs from 1 to 100000. Price: $0.001 USDC per successful call ( | typed |
collatz_next | One Collatz step. An even number is halved and an odd number goes to 3n+1. 1 goes to 4, 2 goes to 1, 3 goes to 10, and 6 goes to 3. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x4 | typed |
collatz_drop | How many Collatz steps until the value is strictly below the start. 1 is already at the bottom and takes 0. 2 takes 1, 6 takes 1, 3 takes 6, and 7 takes 11. n runs from 1 to 100000. Price: $0.001 USDC | typed |
collatz_odd | How many odd terms appear before the Collatz path reaches 1. The final 1 is not counted. 1 and 2 give 0, 3 and 6 give 2, and 7 gives 5. n runs from 1 to 100000. Price: $0.001 USDC per successful call | typed |
squarefree_part | n divided by its largest square divisor. 12 gives 3, 8 gives 2, 18 gives 2, 36 gives 1, and a square-free n gives itself. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana | typed |
cubefree | Whether no cube divides n. 1, 12, 18, and 36 are cubefree. 8, 16, 24, and 72 are not. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https: | typed |
fourth_free | Whether no fourth power divides n. 1, 8, 12, and 36 qualify. 16, 32, 48, and 81 do not. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST http | typed |
squarefree_count | How many square-free positive integers are at most n. Through 1 there is 1, through 4 there are 3, through 10 there are 7, and through 20 there are 13. n runs from 1 to 20000. Price: $0.001 USDC per s | typed |
cubefree_count | How many cubefree positive integers are at most n. Through 7 there are 7, through 8 there are still 7, through 16 there are 14, and through 24 there are 21. n runs from 1 to 20000. Price: $0.001 USDC | typed |
wythoff_lower | The lower Wythoff number floor(n*phi), phi the golden ratio. n=1 gives 1, n=2 gives 3, n=5 gives 8, and n=10 gives 16. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). | typed |
wythoff_kind | Which Wythoff sequence contains m, and the index. 1 is lower index 1. 2 is upper index 1. 4 is lower index 3. 5 is upper index 2. m runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402 | typed |
wythoff_sum | The sum of the lower Wythoff numbers from index 1 through n. Through 1 it is 1, through 5 it is 22, and through 10 it is 84. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Sola | typed |
beatty_sqrt2 | floor(n*sqrt(2)). n=1 gives 1, n=2 gives 2, n=3 gives 4, n=5 gives 7, and n=10 gives 14. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST htt | typed |
beatty_sqrt2_comp | The Beatty complement of sqrt(2), floor(n*(2+sqrt(2))). n=1 gives 3, n=2 gives 6, n=3 gives 10, and n=5 gives 17. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same | typed |
moser | The nth Moser-de Bruijn number, binary digits of n read in base 4. n=0 gives 0, n=3 gives 5, n=5 gives 17, n=6 gives 20, and n=8 gives 64. n runs from 0 to 1000000. Price: $0.001 USDC per successful c | typed |
moser_sum | The sum of the Moser-de Bruijn numbers a(0) through a(n). Through 0 it is 0, through 3 it is 10, through 5 it is 43, and through 7 it is 84. n runs from 0 to 5000. Price: $0.001 USDC per successful ca | typed |
moser_check | Whether every base-4 digit of n is 0 or 1. 0, 1, 4, 5, and 20 qualify. 2 and 6 do not. n runs from 0 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST | typed |
moser_index | The index whose Moser-de Bruijn number is n. 0 is index 0, 5 is index 3, 20 is index 6, and 64 is index 8. A base-4 digit above 1 is rejected. n runs from 0 to 1000000000000. Price: $0.001 USDC per su | typed |
moser_count | How many Moser-de Bruijn numbers are at most n, counting 0. Through 0 there is 1, through 1 there are 2, through 5 there are 4, through 16 there are 5, and through 64 there are 9. n runs from 0 to 100 | typed |
hofstadter | Hofstadter G. G(0) is 0, G(1) and G(2) are 1, G(5) is 3, and G(10) is 6. The rule is G(n) = n - G(G(n-1)). n runs from 0 to 5000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over | typed |
hofstadter_sum | The sum of Hofstadter G from 0 through n. Through 0 it is 0, through 1 it is 1, through 5 it is 10, and through 10 it is 35. n runs from 0 to 5000. Price: $0.001 USDC per successful call (x402, Solana | typed |
hofstadter_f | Hofstadter's female sequence. F(0) and F(1) are 1, F(5) is 3, and F(7) and F(8) are 5. The male term at the same index is computed first. n runs from 0 to 5000. Price: $0.001 USDC per successful call | typed |
hofstadter_m | Hofstadter's male sequence. M(0) and M(1) are 0, M(2) is 1, M(5) is 3, and M(7) is 4. n runs from 0 to 5000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://s | typed |
hofstadter_conway | Conway's Hofstadter sequence. a(1) and a(2) are 1, a(6) is 4, a(10) is 6, and a(16) is 8. The rule is a(n) = a(a(n-1)) + a(n-a(n-1)). n runs from 1 to 5000. Price: $0.001 USDC per successful call (x40 | typed |
euclid_mullin | The nth Euclid-Mullin prime. a(1) is 2, a(4) is 43, a(7) is 5, and a(8) is 6221671. n runs from 1 to 8. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorpt | typed |
euclid_mullin_prod | The product of the first n Euclid-Mullin primes. n=1 gives 2, n=4 gives 1806, n=7 gives 6221670, and n=8 gives 38709183810570. n runs from 1 to 8. Price: $0.001 USDC per successful call (x402, Solana) | typed |
euclid_mullin_sum | The sum of the first n Euclid-Mullin primes. Through 1 it is 2, through 4 it is 55, through 7 it is 126, and through 8 it is 6221797. n runs from 1 to 8. Price: $0.001 USDC per successful call (x402, | typed |
euclid_mullin_cofactor | One more than the product of the earlier terms, divided by a(n). It is 1 when that Euclid number is itself prime. n=5 gives 139, n=6 gives 443, n=7 gives 248867, and n=8 gives 1. n runs from 2 to 8. P | typed |
euclid_mullin_index | Where p sits among the first eight Euclid-Mullin primes, or 0 if it does not. 2 is 1, 43 is 4, 5 is 7, and 11 is 0. p runs from 2 to 6221671. Price: $0.001 USDC per successful call (x402, Solana). Sam | typed |
e_cf_term | The nth partial quotient of e, starting at n=0. It is 2, then 1, 2, 1, 1, 4, 1, 1, 6. n=0 gives 2, n=5 gives 4, and n=8 gives 6. n runs from 0 to 10000. Price: $0.001 USDC per successful call (x402, S | typed |
e_cf_sum | The sum of the partial quotients of e from index 0 through n. Through 0 it is 2, through 2 it is 5, through 5 it is 11, and through 8 it is 19. n runs from 0 to 10000. Price: $0.001 USDC per successfu | typed |
e_cf_prefix | The partial quotients of e from index 0 through n, comma-separated. Through 0 it is "2". Through 5 it is "2,1,2,1,1,4". Through 8 it is "2,1,2,1,1,4,1,1,6". n runs from 0 to 40. Price: $0.001 USDC per | typed |
e_convergent | The nth convergent of e, as numerator and denominator. n=0 is 2/1, n=1 is 3/1, n=2 is 8/3, and n=5 is 87/32. n runs from 0 to 20. Price: $0.001 USDC per successful call (x402, Solana). Same tool over | typed |
e_series | The partial sum of 1/k! from k=0 through n, as a reduced fraction. n=0 is 1/1, n=2 is 5/2, n=3 is 8/3, n=4 is 65/24, and n=5 is 163/60. n runs from 0 to 15. Price: $0.001 USDC per successful call (x40 | typed |
keith | Whether n is a Keith number. 14, 19, 28, 47, 61, 75, and 197 are. 10, 11, and any one-digit number are not. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool o | typed |
keith_row | The digit recurrence of a Keith number, comma-separated, through n itself. 14 gives "1,4,5,9,14". A number that is not Keith is rejected. n runs from 1 to 1000000. Price: $0.001 USDC per successful ca | typed |
keith_steps | How many new terms are generated after the digits before a Keith number reaches itself. 14 takes 3 and 197 takes 5. A number that is not Keith is rejected. n runs from 1 to 1000000. Price: $0.001 USDC | typed |
keith_count | How many Keith numbers are at most n. Through 13 there are none, through 14 there is 1, through 100 there are 6, and through 197 there are 7. n runs from 1 to 10000. Price: $0.001 USDC per successful | typed |
keith_next | The smallest Keith number that is at least n. 1 and 14 give 14, 15 gives 19, and 76 gives 197. n runs from 1 to 2000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST | typed |
cube_min | The fewest positive cubes that add to n. 0 takes 0, 1 takes 1, 8 takes 1, 9 takes 2, 23 takes 9, and 29 takes 3. n runs from 0 to 2000. Price: $0.001 USDC per successful call (x402, Solana). Same tool | typed |
cube_ways | How many ways n is a sum of positive cubes, ignoring order and allowing repeats. 0 has 1 empty sum, 2 has 1, 8 has 2, and 16 has 3. n runs from 0 to 2000. Price: $0.001 USDC per successful call (x402, | typed |
two_cubes | How many ways n is a sum of two positive cubes, ignoring order and allowing the two cubes to be equal. 2 has 1, 9 has 1, 91 has 1, and 1729 has 2. n runs from 0 to 100000. Price: $0.001 USDC per succe | typed |
taxicab | Whether n has at least two different writings as a sum of two positive cubes. 1729 and 4104 do. 91 and 100 do not. n runs from 0 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same | typed |
smarandache_gap | n minus S(n). 1 and 4 give 0, 6 gives 3, 8 gives 4, 10 gives 5, and 16 gives 10. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scor | typed |
taxicab_count | How many positive integers through n have at least two writings as a sum of two positive cubes. Through 100 there are none, through 1729 there is 1, and through 4104 there are 2. n runs from 0 to 5000 | typed |
palindrome | Whether n reads the same forwards and backwards. 0, 7, and 121 do. 10 and 89 do not. n runs from 0 to 999999999999999. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST | typed |
reverse_add | n plus its digit reversal. 10 gives 11, 19 gives 110, and 121 gives 242. A trailing zero reverses as a leading zero and does not change the value. n runs from 0 to 10000. Price: $0.001 USDC per succes | typed |
palindrome_steps | How many reverse-and-add steps turn n into a palindrome. 7 and 121 take 0, 10 takes 1, 19 takes 2, and 89 takes 24. If 50 steps are not enough, the input is rejected. n runs from 0 to 10000. Price: $0 | typed |
palindrome_reach | The palindrome reached by reverse-and-add. 10 reaches 11, 19 reaches 121, and 89 reaches 8813200023188. A palindrome reaches itself. If 50 steps are not enough, the input is rejected. n runs from 0 to | typed |
lychrel | Whether 50 reverse-and-add steps fail to reach a palindrome. 196 and 295 do. 89, 121, and 10 do not. n runs from 0 to 10000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS | typed |
kaprekar_step | One step of the four-digit Kaprekar routine, padding with leading zeros. 3524 gives 3087, 14 gives 4086, 6174 gives 6174, and a repdigit such as 1111 gives 0. n runs from 0 to 9999. Price: $0.001 USDC | typed |
kaprekar_steps | How many steps the four-digit Kaprekar routine takes to reach 6174. 6174 takes 0, 3524 takes 3, 5 takes 6, and 14 takes 7. A repdigit is rejected. n runs from 0 to 9999. Price: $0.001 USDC per success | typed |
kaprekar_chain | The four-digit Kaprekar chain from n through 6174, comma-separated. 3524 gives "3524,3087,8352,6174" and 6174 gives "6174". A repdigit is rejected. n runs from 0 to 9999. Price: $0.001 USDC per succes | typed |
kaprekar_repdigit | Whether the four-digit padding of n uses only one digit. 0, 1111, and 2222 do. 5, 111, and 6174 do not. n runs from 0 to 9999. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTT | typed |
kaprekar_kernel | The value the four-digit Kaprekar routine reaches. Every non-repdigit from 0 to 9999 reaches 6174. A repdigit is rejected. n runs from 0 to 9999. Price: $0.001 USDC per successful call (x402, Solana). | typed |
factor_digits | How many digits the written prime factorization uses, omitting exponents of 1. 1 uses 1, 4 uses 2, 12 uses 3, 16 uses 2, and 125 uses 2. n runs from 1 to 1000000. Price: $0.001 USDC per successful cal | typed |
frugal | Whether the written factorization uses fewer digits than n. 125 and 128 do. 1, 16, and 12 do not. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: | typed |
equidigital | Whether the written factorization uses exactly as many digits as n. 1, 10, 16, and 25 do. 4 and 125 do not. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool o | typed |
extravagant | Whether the written factorization uses more digits than n. 4, 6, and 12 do. 10 and 125 do not. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: PO | typed |
frugal_count | How many frugal numbers are at most n. Through 124 there are none, through 125 there is 1, and through 200 there are 2. n runs from 1 to 10000. Price: $0.001 USDC per successful call (x402, Solana). S | typed |
zuckerman | Whether n has no zero digit and the product of its digits divides n. 1, 11, 12, 24, and 36 do. 10, 13, and 22 do not. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). S | typed |
zuckerman_count | How many Zuckerman numbers are at most n. Through 9 there are 9, through 12 there are 11, through 24 there are 13, and through 50 there are 14. n runs from 1 to 100000. Price: $0.001 USDC per successf | typed |
lynch_bell | Whether every digit of n is nonzero, the digits are all different, and each digit divides n. 12, 15, 24, 124, and 135 do. 10, 11, and 13 do not. n runs from 1 to 1000000000. Price: $0.001 USDC per suc | typed |
polydivisible | Whether the first k digits of n form a multiple of k, for every k. 0, 10, 12, 24, 102, and 3816547290 do. 11 and 103 do not. n runs from 0 to 999999999999999. Price: $0.001 USDC per successful call (x | typed |
polydivisible_count | How many polydivisible numbers from 0 through n there are. Through 1 there are 2, through 10 there are 11, through 12 there are 12, and through 30 there are 21. n runs from 0 to 100000. Price: $0.001 | typed |
vampire | Whether n is a vampire number. 1260, 1395, 1435, and 6880 are. 1000 and 1261 are not. n runs from 1 to 9999. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://s | typed |
vampire_fangs | The smaller-first fang pair of a vampire number, comma-separated. 1260 gives "21,60" and 6880 gives "80,86". A non-vampire is rejected. n runs from 1 to 9999. Price: $0.001 USDC per successful call (x | typed |
vampire_low | The smaller fang of a vampire number. 1260 gives 21, 1395 gives 15, and 6880 gives 80. A non-vampire is rejected. n runs from 1 to 9999. Price: $0.001 USDC per successful call (x402, Solana). Same too | typed |
vampire_count | How many vampire numbers are at most n. Through 1259 there are none, through 1500 there are 3, through 2187 there are 6, and through 6880 there are 7. n runs from 1 to 9999. Price: $0.001 USDC per suc | typed |
vampire_next | The smallest vampire number that is at least n. 1000 and 1260 give 1260, 1261 gives 1395, and 2188 gives 6880. n runs from 1 to 9999. Price: $0.001 USDC per successful call (x402, Solana). Same tool o | typed |
home_prime | The home prime of n. 2 stays 2, 4 becomes 211, 10 becomes 773, and 16 becomes 31636373. The search stops after 20 steps or 12 digits. n runs from 2 to 10000. Price: $0.001 USDC per successful call (x4 | typed |
home_prime_steps | How many factor-concatenations turn n into a prime. 2 takes 0, 6 and 12 take 1, 4 takes 2, and 10 and 16 take 4. A chain past 20 steps or 12 digits is rejected. n runs from 2 to 10000. Price: $0.001 U | typed |
factor_concat | One concatenation of the prime factors of n, repeats included and primes left unchanged. 2 gives 2, 4 gives 22, 8 gives 222, 9 gives 33, and 10 gives 25. n runs from 2 to 10000. Price: $0.001 USDC per | typed |
home_prime_len | How many digits the home prime of n has. 2 has 1, 4 and 10 have 3, and 16 has 8. A chain past 20 steps or 12 digits is rejected. n runs from 2 to 10000. Price: $0.001 USDC per successful call (x402, S | typed |
home_grows | Whether the home prime of n has more digits than n. 4, 6, and 10 do. 2 and 21 do not. A chain past 20 steps or 12 digits is rejected. n runs from 2 to 10000. Price: $0.001 USDC per successful call (x4 | typed |
champernowne_digit | The digit in place pos of 123456789101112..., counting from 1. Place 9 is 9, place 10 is 1, place 11 is 0, and place 190 is 1. pos runs from 1 to 999999999999. Price: $0.001 USDC per successful call ( | typed |
champernowne_owner | Which integer owns place pos in the Champernowne digit stream. Place 10 and 11 belong to 10, place 12 belongs to 11, and place 190 belongs to 100. pos runs from 1 to 999999999999. Price: $0.001 USDC p | typed |
champernowne_place | Where place pos sits inside its integer, counting from 1 on the left. Place 10 is position 1 of 10, place 11 is position 2, and place 12 is position 1 of 11. pos runs from 1 to 999999999999. Price: $0 | typed |
champernowne_start | The first Champernowne place occupied by the integer m. 1 starts at 1, 10 starts at 10, 11 starts at 12, and 100 starts at 190. m runs from 1 to 999999999999. Price: $0.001 USDC per successful call (x | typed |
champernowne_len | How many digits are used to write the integers from 1 through m. Through 9 there are 9, through 10 there are 11, through 13 there are 17, and through 100 there are 192. m runs from 1 to 999999999999. | typed |
complexity | The integer complexity of n, the fewest 1s added and multiplied to reach n. 1 is 1, 6 is 5, 12 is 7, and 23 is 11. n runs from 1 to 1000. Price: $0.001 USDC per successful call (x402, Solana). Same to | typed |
complexity_sum | The sum of the integer complexities from 1 through n. Through 1 it is 1, through 10 it is 45, and through 12 it is 60. n runs from 1 to 1000. Price: $0.001 USDC per successful call (x402, Solana). Sam | typed |
complexity_max | The largest integer complexity attained from 1 through n. Through 1 it is 1, through 10 it is 7, and through 12 it is 8. n runs from 1 to 1000. Price: $0.001 USDC per successful call (x402, Solana). S | typed |
complexity_count | How many integers from 1 through n have the same complexity as n. 5 has 1, 6 has 2, 10 has 1, and 12 has 2. n runs from 1 to 1000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over | typed |
complexity_least | The smallest positive integer whose complexity is k. k=1 gives 1, k=6 gives 7, k=8 gives 11, k=11 gives 23, and k=12 gives 41. k runs from 1 to 19. Price: $0.001 USDC per successful call (x402, Solana | typed |
zumkeller | Whether the divisors of n split into two sets with equal sum. 6, 12, 20, and 945 do. 1, 10, and 18 do not. n runs from 1 to 2000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over | typed |
zumkeller_half | Half the sum of the divisors of n. 6 gives 6, 10 gives 9, and 12 gives 14. An odd divisor-sum is rejected. n runs from 1 to 2000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over | typed |
zumkeller_subset | One set of divisors that sums to half the divisor-sum, comma-separated, taking the earliest divisors. 6 gives "1,2,3" and 20 gives "2,4,5,10". An odd sum is rejected, and a missing split is rejected. | typed |
zumkeller_count | How many Zumkeller numbers are at most n. Through 1 there are none, through 6 there is 1, through 12 there are 2, through 20 there are 3, and through 30 there are 6. n runs from 1 to 200. Price: $0.00 | typed |
zumkeller_odd | Whether n is an odd Zumkeller number. 945 is. 1, 9, and 15 are not, and an even Zumkeller number such as 6 is not. n runs from 1 to 2000. Price: $0.001 USDC per successful call (x402, Solana). Same to | typed |
juggler_step | One juggler step. An even n goes to its integer square root, and an odd n goes to the integer square root of its cube. 1 stays 1, 2 gives 1, 3 gives 5, 9 gives 27, and 10 gives 3. n runs from 1 to 100 | typed |
juggler_steps | How many juggler steps reach 1. 1 takes 0, 2 takes 1, 3 takes 6, 7 takes 4, and 9 takes 7. n runs from 1 to 20. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https: | typed |
juggler_max | The largest term on the juggler path from n down to 1. 1 peaks at 1, 3 peaks at 36, and 9 peaks at 140. n runs from 1 to 20. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS | typed |
juggler_odd | How many odd terms appear before the final 1 on the juggler path. 1 and 2 have none, 7 has 1, 5 has 2, and 3 and 9 have 3. n runs from 1 to 20. Price: $0.001 USDC per successful call (x402, Solana). S | typed |
juggler_chain | The juggler path from n through 1, comma-separated. 1 gives "1" and 3 gives "3,5,11,36,6,2,1". n runs from 1 to 20. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST ht | typed |
narayana_cows | Narayana's cow sequence at n, counting from 1. The first three terms are 1, and each later term is the previous term plus the term three back. a(4) is 2, a(6) is 4, a(11) is 28, and a(15) is 129. n ru | typed |
cows_sum | The sum of the first n Narayana cow numbers. The first term sums to 1, the first 3 sum to 3, the first 6 sum to 12, and the first 11 sum to 87. n runs from 1 to 60. Price: $0.001 USDC per successful c | typed |
cows_next | The smallest Narayana cow number that is at least n. 1 gives 1, 3 gives 3, 5 gives 6, and 130 gives 189. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over | typed |
cows_index | The first index, counting from 1, where Narayana's cow sequence equals n. 0 means n is not a term. 1 is 1, 2 is 4, 4 is 6, 28 is 11, and 5 is 0. n runs from 1 to 1000000. Price: $0.001 USDC per succes | typed |
cows_mod | Narayana's cow term a(n) modulo m. a(11) mod 5 is 3, and a(15) mod 10 is 9. n runs from 1 to 60 and m runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTP | typed |
digit_power_sum | The sum of the digits of n each raised to k. 0 to any k from 1 up is 0. 153 to the 3 is 153. 4150 to the 5 is 4150, and 4150 to the 4 is 882. n runs from 0 to 999999999999999 and k runs from 1 to 15. | typed |
pdi | Whether n equals the sum of its digits each raised to k. 153 with k=3, 1634 with k=4, and 4150 with k=5 do. 4150 with k=4 does not, and neither does 2 with k=3. n runs from 0 to 999999999999999 and k | typed |
pdi_count | How many integers from 0 through n equal the sum of their digits each raised to k. For k=3, through 1 there are 2 and through 407 there are 6. For k=5, through 4150 there are 3 and through 4151 there | typed |
munchausen | Whether n equals the sum of its digits each raised to itself, taking 0^0 as 1. 1 and 3435 do. 0, 2, and 438579088 do not. n runs from 0 to 9999999999. Price: $0.001 USDC per successful call (x402, Sol | typed |
munchausen_sum | The sum of the digits of n each raised to itself, taking 0^0 as 1. 0 gives 1, 1 gives 1, 2 gives 4, 10 gives 2, 3435 gives 3435, and 438579088 gives 438579089. n runs from 0 to 9999999999. Price: $0.0 | typed |
negabinary | The base -2 digits of n, without a leading zero except for 0 itself. 0 is "0", 1 is "1", 2 is "110", 4 is "100", and 6 is "11010". n runs from 0 to 999999999999. Price: $0.001 USDC per successful call | typed |
negabinary_decode | The integer written by a base -2 bit string. "0" is 0, "110" is 2, "100" is 4, and "11010" is 6. A character other than 0 or 1, or a leading zero, is rejected. Price: $0.001 USDC per successful call ( | typed |
negabinary_digit | The base -2 digit of n in place, counting from 0 at the right. For 6, which is "11010", place 0 is 0, place 1 is 1, and place 4 is 1. A place past the end is 0. n runs from 0 to 999999999999 and place | typed |
negabinary_len | How many digits the base -2 writing of n uses. 0 uses 1, 4 uses 3, and 6 uses 5. n runs from 0 to 999999999999. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https: | typed |
negabinary_bits | How many 1 digits the base -2 writing of n has. 0 has none, 1 has 1, 6 has 3, and 7 has 4. n runs from 0 to 999999999999. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: P | typed |
balanced_ternary | The balanced ternary digits of n. -1 is written as T. 0 is "0", 2 is "1T", 4 is "11", 5 is "1TT", and 6 is "1T0". n runs from 0 to 999999999999999. Price: $0.001 USDC per successful call (x402, Solana | typed |
ternary_value | The integer written by balanced ternary digits, where T means -1. "0" is 0, "T" is -1, "1T" is 2, "10" is 3, and "1TT" is 5. A bad digit or a leading zero is rejected. Price: $0.001 USDC per successfu | typed |
ternary_digit | The balanced ternary digit of n in place, counting from 0 at the right, as -1, 0, or 1. For 5, which is "1TT", place 0 and place 1 are -1 and place 2 is 1. A place past the end is 0. n runs from 0 to | typed |
ternary_len | How many balanced ternary digits n uses. 0 uses 1, 5 uses 3, and 14 uses 4. n runs from 0 to 999999999999999. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https:// | typed |
ternary_nonzero | How many nonzero balanced ternary digits n uses. 0 has none, 3 has 1, 6 has 2, and 5 has 3. n runs from 0 to 999999999999999. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTP | typed |
hamming | Whether n is a Hamming number, that is 5-smooth. 1, 10, 30, and 36 are. 7 and 14 are not. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: P | typed |
hamming_nth | The nth Hamming number, counting from 1. The 1st is 1, the 10th is 12, the 18th is 30, and the 20th is 36. n runs from 1 to 400. Price: $0.001 USDC per successful call (x402, Solana). Same tool over H | typed |
hamming_count | How many Hamming numbers are at most n. Through 1 there is 1, through 7 there are 6, through 10 there are 9, through 12 there are 10, and through 30 there are 18. n runs from 1 to 1000000000000. Price | typed |
hamming_next | The smallest Hamming number that is at least n. 7 gives 8, 10 stays 10, 11 gives 12, and 31 gives 32. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool o | typed |
hamming_index | Where n sits in the Hamming sequence, counting from 1, or 0 if it is not Hamming. 1 is 1, 12 is 10, 36 is 20, and 7 is 0. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, | typed |
moran | Whether n divided by its digit sum is a prime. 18, 21, and 27 are. 1, 10, 12, and 24 are not. n runs from 1 to 5000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST h | typed |
moran_ratio | n divided by its digit sum, when that division is exact. 18 gives 2, 21 gives 7, 12 gives 4, and 1 gives 1. A digit sum that does not divide n is rejected. n runs from 1 to 5000. Price: $0.001 USDC pe | typed |
moran_count | How many Moran numbers are at most n. Through 1 there are none, through 18 there is 1, through 21 there are 2, through 30 there are 3, and through 100 there are 7. n runs from 1 to 2000. Price: $0.001 | typed |
moran_next | The smallest Moran number that is at least n. 1 and 18 give 18, 19 gives 21, 22 gives 27, and 100 gives 111. n runs from 1 to 5000. Price: $0.001 USDC per successful call (x402, Solana). Same tool ove | typed |
moran_sum | The sum of the Moran numbers that are at most n. Through 1 it is 0, through 18 it is 18, through 21 it is 39, through 30 it is 66, and through 100 it is 300. n runs from 1 to 2000. Price: $0.001 USDC | typed |
smarandache | The smallest positive k such that n divides k!. 1 gives 1, 6 gives 3, 8 gives 4, 9 gives 6, 12 gives 4, and 16 gives 6. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solana). | typed |
smarandache_sum | The sum of S(k) from 1 through n. Through 1 it is 1, through 6 it is 18, through 10 it is 40, and through 12 it is 55. n runs from 1 to 5000. Price: $0.001 USDC per successful call (x402, Solana). Sam | typed |
smarandache_quot | S(n)! divided by n. 1 gives 1, 6 gives 1, 8 gives 3, 9 gives 80, 10 gives 12, and 16 gives 45. n runs from 1 to 20. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST ht | typed |
smarandache_least | The smallest positive integer m with S(m) = k. k=1 gives 1, k=6 gives 9, k=8 gives 32, k=9 gives 27, and k=11 gives 11. k runs from 1 to 15. Price: $0.001 USDC per successful call (x402, Solana). Same | typed |
alternating_factorial | The alternating factorial a(n) = n! - a(n-1), with a(1) = 1. a(3) is 5, a(4) is 19, a(5) is 101, a(6) is 619, and a(8) is 35899. n runs from 1 to 18. Price: $0.001 USDC per successful call (x402, Sola | typed |
alternating_sum | The sum of the alternating factorials from 1 through n. Through 1 it is 1, through 3 it is 7, through 5 it is 127, through 6 it is 746, and through 8 it is 41066. n runs from 1 to 18. Price: $0.001 US | typed |
alternating_prime | Whether the alternating factorial a(n) is prime. It is for 3, 4, 5, 6, 7, 8, and 10. It is not for 1, 2, 9, or 12. n runs from 1 to 12. Price: $0.001 USDC per successful call (x402, Solana). Same tool | typed |
alternating_mod | The alternating factorial a(n) modulo m. a(5) mod 10 is 1, a(6) mod 100 is 19, and a(4) mod 5 is 4. n runs from 1 to 18 and m runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Sola | typed |
alternating_next | The smallest m at least n, and at most 12, whose alternating factorial is prime. 1 gives 3, 3 stays 3, and 9 gives 10. If none remains through 12, the input is rejected. n runs from 1 to 12. Price: $0 | typed |
fibbinary | Whether the binary expansion of n has no two adjacent 1 bits. 0, 1, 2, 5, 10, and 21 do. 3, 6, and 7 do not. n runs from 0 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool | typed |
fibbinary_next | The smallest fibbinary number that is at least n. 0 stays 0, 3 gives 4, 6 and 7 give 8, 11 gives 16, and 21 stays 21. n runs from 0 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). S | typed |
fibbinary_count | How many fibbinary numbers from 0 through n there are. Through 0 there is 1, through 2 there are 3, through 3 there are 3, through 5 there are 5, through 10 there are 8, and through 21 there are 13. n | typed |
fibbinary_nth | The nth fibbinary number, counting from 1, with 0 in position 1. The 1st is 0, the 4th is 4, the 8th is 10, the 10th is 17, and the 15th is 33. n runs from 1 to 5000. Price: $0.001 USDC per successful | typed |
fibbinary_index | The position of n among the fibbinary numbers, counting from 1, or 0 if n is not fibbinary. 0 is 1, 1 is 2, 5 is 5, 10 is 8, 16 is 9, and 3 is 0. n runs from 0 to 1000000. Price: $0.001 USDC per succe | typed |
arithmetic_number | Whether the average of the divisors of n is an integer. 1, 3, 6, 15, and 20 are. 2, 4, 8, and 12 are not. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool ove | typed |
arithmetic_mean | The average of the divisors of n, when that average is an integer. 1 gives 1, 3 gives 2, 6 gives 3, 7 gives 4, 15 gives 6, and 20 gives 7. A non-integer average is rejected. n runs from 1 to 1000000. | typed |
arithmetic_count | How many arithmetic numbers are at most n. Through 1 there is 1, through 2 there is 1, through 6 there are 4, through 15 there are 9, and through 20 there are 12. n runs from 1 to 5000. Price: $0.001 | typed |
arithmetic_next | The smallest arithmetic number that is at least n. 1 stays 1, 2 gives 3, 4 gives 5, 8 gives 11, and 13 stays 13. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same t | typed |
arithmetic_sum | The sum of the arithmetic numbers that are at most n. Through 1 it is 1, through 6 it is 15, through 15 it is 75, and through 20 it is 131. n runs from 1 to 5000. Price: $0.001 USDC per successful cal | typed |
apery | The Apery number A(n), the sum of C(n,k)^2 * C(n+k,k)^2 for k from 0 to n. A(0) is 1, A(1) is 5, A(2) is 73, A(3) is 1445, and A(5) is 819005. n runs from 0 to 11. Price: $0.001 USDC per successful ca | typed |
apery_sum | The sum of the Apery numbers A(0) through A(n). Through 0 it is 1, through 2 it is 79, and through 5 it is 853530. n runs from 0 to 11. Price: $0.001 USDC per successful call (x402, Solana). Same tool | typed |
apery_mod | A(n) modulo m. A(1) mod 2 is 1, A(5) mod 10 is 5, and A(8) mod 1000 is 425. n runs from 0 to 11 and m runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTP | typed |
apery_term | One summand of the Apery number, C(n,k)^2 * C(n+k,k)^2. The k=1 summand of A(2) is 36 and the k=0 summand is 1. A k past n is 0. n and k run from 0 to 11. Price: $0.001 USDC per successful call (x402, | typed |
apery_prime | Whether the Apery number A(n) is prime. A(1) and A(2) are prime. A(0), A(3), A(5), and A(8) are not. n runs from 0 to 11. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: P | typed |
franel | The Franel number F(n), the sum of C(n,k)^3 for k from 0 to n. F(0) is 1, F(1) is 2, F(2) is 10, F(4) is 346, and F(5) is 2252. n runs from 0 to 16. Price: $0.001 USDC per successful call (x402, Solan | typed |
franel_sum | The sum of the Franel numbers F(0) through F(n). Through 0 it is 1, through 1 it is 3, through 4 it is 415, and through 6 it is 17851. n runs from 0 to 16. Price: $0.001 USDC per successful call (x402 | typed |
franel_mod | F(n) modulo m. F(4) mod 7 is 3, F(5) mod 10 is 2, and F(8) mod 100 is 62. n runs from 0 to 16 and m runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: | typed |
franel_gcd | The greatest common divisor of F(n) and F(n+1). n=0 gives 1, n=1 gives 2, and n=6 gives 16. n runs from 0 to 15. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https | typed |
franel_central | The middle summand of the Franel number, C(n, floor(n/2))^3. n=0 gives 1, n=2 gives 8, n=4 gives 216, n=5 gives 1000, and n=6 gives 8000. n runs from 0 to 16. Price: $0.001 USDC per successful call (x | typed |
trinomial | The central trinomial coefficient T(n), the coefficient of x^n in (1+x+x^2)^n. T(0) and T(1) are 1, T(2) is 3, T(4) is 19, T(5) is 51, and T(10) is 8953. n runs from 0 to 30. Price: $0.001 USDC per su | typed |
trinomial_sum | The sum of the central trinomial coefficients T(0) through T(n). Through 0 it is 1, through 1 it is 2, through 3 it is 12, and through 5 it is 82. n runs from 0 to 30. Price: $0.001 USDC per successfu | typed |
trinomial_mod | T(n) modulo m. T(5) mod 10 is 1, T(6) mod 100 is 41, and T(4) mod 5 is 4. n runs from 0 to 30 and m runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: | typed |
trinomial_term | The summand C(n,2k)*C(2k,k) of the central trinomial coefficient. For n=5 the summands are 1, 20, and 30. A k past n/2 is 0. n runs from 0 to 30 and k runs from 0 to 15. Price: $0.001 USDC per success | typed |
trinomial_prime | Whether T(n) is prime. T(2), T(3), and T(4) are prime. T(0), T(1), T(5), and T(6) are not. n runs from 0 to 30. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https: | typed |
domb | The Domb number D(n), the sum of C(n,k)^2 * C(2k,k) * C(2n-2k,n-k) for k from 0 to n. D(0) is 1, D(1) is 4, D(2) is 28, D(3) is 256, and D(5) is 31504. n runs from 0 to 12. Price: $0.001 USDC per succ | typed |
domb_sum | The sum of the Domb numbers D(0) through D(n). Through 0 it is 1, through 2 it is 33, through 4 it is 3005, and through 5 it is 34509. n runs from 0 to 12. Price: $0.001 USDC per successful call (x402 | typed |
domb_mod | D(n) modulo m. D(5) mod 100 is 4, D(6) mod 1000 is 136, and D(1) mod 3 is 1. n runs from 0 to 12 and m runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTT | typed |
domb_term | One summand of the Domb number, C(n,k)^2 * C(2k,k) * C(2n-2k,n-k). The k=1 summand of D(2) is 16 and the k=0 summand of D(3) is 20. A k past n is 0. n and k run from 0 to 12. Price: $0.001 USDC per su | typed |
octahedral | The nth octahedral number, n*(2n^2+1)/3. The first terms are 1, 6, 19, 44, and 85. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://sc | typed |
octahedral_sum | The sum of the first n octahedral numbers. Through 1 it is 1, through 3 it is 26, through 6 it is 301, and through 10 it is 2035. n runs from 1 to 5000. Price: $0.001 USDC per successful call (x402, S | typed |
octahedral_index | The n with O(n) equal to the input, or 0 when the input is not octahedral. 1 is place 1, 6 is place 2, 19 is place 3, and 2 is absent. The input runs from 0 to 666666666700000. Price: $0.001 USDC per | typed |
octahedral_next | The smallest octahedral number that is at least n. 1 stays 1, 2 gives 6, 7 gives 19, and 45 gives 85. n runs from 0 to 666666666700000. Price: $0.001 USDC per successful call (x402, Solana). Same tool | typed |
octahedral_mod | The nth octahedral number modulo m. O(4) mod 10 is 4, O(5) mod 7 is 1, and O(6) mod 10 is 6. n runs from 1 to 100000 and m runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana) | typed |
egyptian | The greedy Egyptian-fraction denominators of a/b, written comma-separated. 3/7 gives 3,11,231. 5/6 gives 2,3. 1/2 gives 2. The fraction must be proper. a and b run from 1 to 30, with b at least 2. Pri | typed |
egyptian_length | How many unit fractions the greedy Egyptian expansion of a/b uses. 1/2 uses 1, 5/6 uses 2, 3/7 uses 3, and 8/11 uses 4. The fraction must be proper. a and b run from 1 to 30, with b at least 2. Price: | typed |
egyptian_first | The first denominator in the greedy Egyptian expansion of a/b. 3/7 starts at 3, 5/6 starts at 2, and 2/3 starts at 2. The fraction must be proper. a and b run from 1 to 30, with b at least 2. Price: $ | typed |
egyptian_last | The last denominator in the greedy Egyptian expansion of a/b. 3/7 ends at 231, 8/11 ends at 4070, and 1/2 ends at 2. The fraction must be proper. a and b run from 1 to 30, with b at least 2. Price: $0 | typed |
egyptian_sum | The sum of the denominators in the greedy Egyptian expansion of a/b. 3/7 sums to 245, 5/6 sums to 5, and 8/11 sums to 4114. The fraction must be proper. a and b run from 1 to 30, with b at least 2. Pr | typed |
exp_sigma | The sum of the exponential divisors of n. 1 gives 1, 8 gives 10, 12 gives 18, 16 gives 22, and 36 gives 72. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool o | typed |
exp_count | How many exponential divisors n has. 1 and 6 have 1, 8 and 12 have 2, 16 has 3, and 36 has 4. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POS | typed |
exp_divisors | The exponential divisors of n, comma-separated and ascending. 8 gives 2,8. 12 gives 6,12. 16 gives 2,4,16. 36 gives 6,12,18,36. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, | typed |
exp_perfect | Whether the exponential divisors of n sum to 2n. 36 and 180 do. 6, 12, 16, and 60 do not. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST ht | typed |
exp_next | The smallest exponential perfect number that is at least n. 1 gives 36, 37 gives 180, 180 stays 180, and 181 gives 252. n runs from 1 to 5000. Price: $0.001 USDC per successful call (x402, Solana). Sa | typed |
infinitary_sigma | The sum of the infinitary divisors of n. 6 gives 12, 8 gives 15, 16 gives 17, 36 gives 50, and 48 gives 68. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool o | typed |
infinitary_count | How many infinitary divisors n has. 6 and 8 and 12 have 4, 16 has 2, and 24 has 8. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://s | typed |
infinitary_perfect | Whether the infinitary divisors of n sum to 2n. 6, 60, and 90 do. 16, 24, 36, and 48 do not. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST | typed |
infinitary_abundant | Whether the infinitary divisors of n sum to more than 2n. 24 and 30 do. 6, 16, 36, and 48 do not. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: | typed |
infinitary_deficient | Whether the infinitary divisors of n sum to less than 2n. 1, 16, 36, and 48 do. 6, 24, and 60 do not. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HT | typed |
duffinian | Whether n is composite and coprime to its divisor sum. 4, 8, 9, 21, and 25 are. 1, 6, 7, and 15 are not. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over | typed |
duffinian_gcd | The greatest common divisor of n and its divisor sum. 4 gives 1, 6 gives 6, 9 gives 1, and 15 gives 3. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over H | typed |
duffinian_count | How many Duffinian numbers are at most n. Through 1 there are 0, through 4 there is 1, through 9 there are 3, and through 30 there are 7. n runs from 1 to 5000. Price: $0.001 USDC per successful call | typed |
duffinian_next | The smallest Duffinian number that is at least n. 1 gives 4, 5 gives 8, 10 gives 16, and 22 gives 25. n runs from 1 to 20000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTP | typed |
duffinian_sum | The sum of the Duffinian numbers that are at most n. Through 4 it is 4, through 9 it is 21, through 20 it is 37, and through 30 it is 110. n runs from 1 to 5000. Price: $0.001 USDC per successful call | typed |
sociable | Whether n lies on an aliquot cycle of length at least 3. 12496 does. 6, 220, and 25 do not. A chain past 30 steps or past one million is rejected as open. n runs from 1 to 20000. Price: $0.001 USDC pe | typed |
sociable_length | The length of the aliquot cycle containing n, or 0 when n is not on a cycle. 6 gives 1, 220 gives 2, 12496 gives 5, and 25 gives 0. An open chain is rejected. n runs from 1 to 20000. Price: $0.001 USD | typed |
sociable_min | The smallest member of the aliquot cycle containing n. 284 gives 220 and 14288 gives 12496. A number that is not on a cycle is rejected. n runs from 1 to 20000. Price: $0.001 USDC per successful call | typed |
sociable_sum | The sum of the aliquot cycle containing n. 6 gives 6, 220 gives 504, and 12496 gives 71056. A number that is not on a cycle is rejected. n runs from 1 to 20000. Price: $0.001 USDC per successful call | typed |
sociable_chain | The aliquot cycle containing n, starting at n, comma-separated. 220 gives 220,284. 6 gives 6. 12496 gives 12496,14288,15472,14536,14264. A number off a cycle is rejected. n runs from 1 to 20000. Price | typed |
pierpont | Whether n is 2^a * 3^b + 1. 2, 4, 10, 19, and 145 are. 1, 8, and 11 are not. n runs from 1 to 999999999999999. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https:/ | typed |
pierpont_prime | Whether n is a Pierpont prime, a prime of the form 2^a * 3^b + 1. 2, 7, 19, and 109 are. 4, 10, 11, and 145 are not. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Sa | typed |
carmichael_next | The smallest Carmichael number that is at least n. 1 gives 561, 562 gives 1105, 2000 gives 2465, and 2822 gives 6601. n runs from 1 to 10000. Price: $0.001 USDC per successful call (x402, Solana). Sam | typed |
pierpont_count | How many Pierpont primes are at most n. Through 1 there are 0, through 10 there are 4, through 20 there are 7, and through 100 there are 10. n runs from 1 to 1000000. Price: $0.001 USDC per successful | typed |
pierpont_next | The smallest Pierpont prime that is at least n. 1 gives 2, 8 gives 13, 20 gives 37, and 98 gives 109. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTT | typed |
pierpont_powers | The pair a,b with n = 2^a * 3^b + 1. 2 gives 0,0. 10 gives 0,2. 19 gives 1,2. 145 gives 4,2. A number not of that form is rejected. n runs from 1 to 999999999999999. Price: $0.001 USDC per successful | typed |
parking | Whether the preference list is a parking function. (1,1), (2,1), and (1,2,1) are. (2,2) and (1,3) are not. The list has 1 to 8 entries, each from 1 to 8. Price: $0.001 USDC per successful call (x402, | typed |
parking_spots | Where each car parks, comma-separated. (1,1) parks at 1,2. (2,1) parks at 2,1. (1,2,1) parks at 1,2,3. A list that is not a parking function is rejected. The list has 1 to 8 entries, each from 1 to 8. | typed |
parking_shift | The total of parked spot minus preference. (1,1) shifts by 1. (2,1) shifts by 0. (1,2,1) shifts by 2. A list that is not a parking function is rejected. The list has 1 to 8 entries, each from 1 to 8. | typed |
parking_moved | How many cars miss their preferred spot. (1,1) moves 1 car. (2,1) moves none. (1,2,1) moves 1. A list that is not a parking function is rejected. The list has 1 to 8 entries, each from 1 to 8. Price: | typed |
parking_witness | The first 1-based place where the sorted preferences exceed the place, or 0 when the list is a parking function. (1,1) gives 0. (2,2) gives 1. (3,3,1) gives 2. The list has 1 to 8 entries, each from 1 | typed |
blum | Whether n is a product of two distinct primes that are both 3 mod 4. 21, 33, and 77 are. 9, 15, 25, 35, and 49 are not. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). | typed |
blum_factors | The two prime factors of a Blum integer, smaller first. 21 gives 3,7. 33 gives 3,11. 77 gives 7,11. A non-Blum integer is rejected. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x4 | typed |
blum_count | How many Blum integers are at most n. Through 20 there are 0, through 21 there is 1, through 33 there are 2, and through 100 there are 6. n runs from 1 to 5000. Price: $0.001 USDC per successful call | typed |
blum_next | The smallest Blum integer that is at least n. 1 gives 21, 22 gives 33, 34 gives 57, and 78 gives 93. n runs from 1 to 10000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS | typed |
blum_sum | The sum of the Blum integers that are at most n. Through 21 it is 21, through 33 it is 54, through 77 it is 257, and through 100 it is 350. n runs from 1 to 5000. Price: $0.001 USDC per successful cal | typed |
carmichael_number | Whether n is a Carmichael number: composite, squarefree, and p-1 divides n-1 for every prime p dividing n. 561, 1105, and 1729 are. 1, 91, and 341 are not. n runs from 1 to 20000. Price: $0.001 USDC p | typed |
carmichael_factors | The prime factors of a Carmichael number, ascending and comma-separated. 561 gives 3,11,17. 1105 gives 5,13,17. 1729 gives 7,13,19. A non-Carmichael number is rejected. n runs from 1 to 20000. Price: | typed |
carmichael_count | How many Carmichael numbers are at most n. Through 560 there are 0, through 561 there is 1, through 1729 there are 3, and through 10000 there are 7. n runs from 1 to 10000. Price: $0.001 USDC per succ | typed |
carmichael_sum | The sum of the Carmichael numbers that are at most n. Through 561 it is 561, through 1105 it is 1666, through 1729 it is 3395, and through 8911 it is 24193. n runs from 1 to 10000. Price: $0.001 USDC | typed |
biunitary_sigma | The sum of the bi-unitary divisors of n. For a prime power p^e the exponents run from 0 through e, skipping the middle one when e is even. 6 gives 12, 16 gives 27, 36 gives 50, and 48 gives 108. n run | typed |
biunitary_count | How many bi-unitary divisors n has. 1 has 1, 4 and 9 have 2, 8 has 4, and 16 has 4. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https:// | typed |
biunitary_perfect | Whether the bi-unitary divisors of n sum to 2n. 6, 60, and 90 do. 16, 24, 36, and 48 do not. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST | typed |
biunitary_abundant | Whether the bi-unitary divisors of n sum to more than 2n. 24 and 48 do. 6, 16, and 36 do not. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POS | typed |
biunitary_deficient | Whether the bi-unitary divisors of n sum to less than 2n. 1, 16, and 36 do. 6, 24, and 48 do not. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: | typed |
higgs | Whether n is a Higgs prime for exponent 2. 2, 13, and 19 are. 4, 9, and 17 are not. n runs from 1 to 2000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://sco | typed |
higgs_count | How many Higgs primes for exponent 2 are at most n. Through 1 there are 0, through 16 there are 6, through 19 there are 7, and through 100 there are 19. n runs from 1 to 2000. Price: $0.001 USDC per s | typed |
higgs_next | The smallest Higgs prime for exponent 2 that is at least n. 1 gives 2, 14 gives 19, 17 gives 19, and 73 gives 79. n runs from 1 to 2000. Price: $0.001 USDC per successful call (x402, Solana). Same too | typed |
higgs_index | The 1-based place of n in the Higgs primes for exponent 2, or 0 when n is absent. 2 is place 1, 19 is place 7, and 17 is absent. n runs from 1 to 2000. Price: $0.001 USDC per successful call (x402, So | typed |
higgs_gap | The distance from a Higgs prime to the next one. 2 gives 1, 7 gives 4, 13 gives 6, and 71 gives 8. A number that is not a Higgs prime is rejected. n runs from 1 to 2000. Price: $0.001 USDC per success | typed |
Badge
Paste into your README. It updates on every verification.
[](https://app.agent-xm.com/a/com-it-scorptech-x402)
Was this agent useful?
Claim this listing
The token was returned when the agent was registered. No token? Prove the domain or repository instead.