--- license: mit task_categories: - other language: - en tags: - blockchain - proof-of-work - np-complete - optimization - energy-measurement - consensus size_categories: - 1K str: s = max(0, int(time.time()) - int(ts)) if s < 60: return f"{s}s ago" if s < 3600: return f"{s // 60}m ago" return f"{s // 3600}h ago" def _addr_short(hex64: str | None) -> str | None: if not hex64 or len(hex64) < 16: return hex64 return f"{hex64[:8]}...{hex64[-6:]}" def _fmt_int_string(s: str | None) -> str: if not s: return "—" try: return f"{int(s):,}" except ValueError: return s def problem_line(pt: str, pd: Mapping[str, Any]) -> str: if pt == "SAT": n_c = len(pd.get("clauses") or []) n_v = int(pd.get("variables") or 0) return f"Satisfy {n_c} clauses with {n_v} variables" if pt == "SubsetSum": nums = pd.get("numbers") or [] tgt = pd.get("target") return f"Find subset summing to {tgt}\nValues: {nums}" return str(pd) def solution_line(pt: str, pd: Mapping[str, Any], sd: Mapping[str, Any] | None) -> str: if sd is None: return "—" if pt == "SAT": return "Satisfying assignment found" if pt == "SubsetSum": idx = sd.get("indices") or [] tgt = pd.get("target") return f"Indices {', '.join(str(i) for i in idx)} → Sum: {tgt}" return str(sd) def format_block_card(r: Mapping[str, Any]) -> str: pt = r.get("problem_type") or "?" pd = r.get("problem_data") or {} sd = r.get("solution_data") ws = r.get("work_score") ta = r.get("time_asymmetry") q = r.get("solution_quality") su = r.get("solve_time_us") or 0 vu = r.get("verify_time_us") or 0 ej = r.get("total_energy_joules") lines = [ f"Block #{r.get('block_height', '?')}", str(pt), _rel_ago(int(r.get("timestamp") or 0)), "", "Problem:", problem_line(pt, pd), "", "Solution:", solution_line(pt, pd, sd), "", f"Solver: {_addr_short(r.get('solver') or r.get('submitter'))}", "", "Reward (BEANS)", _fmt_int_string(r.get("bounty")), "", "Work (bits)", f"{ws:.3f}" if isinstance(ws, (int, float)) else "—", "", "Asymmetry", f"{ta:.2f}×" if isinstance(ta, (int, float)) else "—", "", "Quality", f"{q:.3f}" if isinstance(q, (int, float)) else "—", "", f"Δt: {su / 1000:.1f} ms solve / {vu / 1000:.2f} ms verify", ] if isinstance(ej, (int, float)): lines.append(f"Est. energy: {ej:.1f} J") return "\n".join(lines) ``` ## Dataset Structure ### Data Instances Each record in the dataset represents either: 1. A problem submission (when a problem is submitted to the network) 2. A solution submission (when a solution is verified) 3. A consensus block (complete block data with all transactions) ### Data Fields | Field | Type | Description | |-------|------|-------------| | **PRIMARY CONTENT** ||| | `problem_id` | string | Unique identifier for the problem | | `problem_type` | string | Type of problem: "SubsetSum", "SAT", "TSP", "Custom", or "Private" | | `problem_data` | object | Complete problem data. **Always a JSON object** in rows emitted by current nodes; very old JSONL may have used a string (double-encoded JSON), which breaks automatic schema inference across files. | | `solution_data` | object (optional) | Solution data with normalized structure. Same object-vs-string caveat as `problem_data` for legacy shards. | | `explorer_card` | string | Preformatted explorer-style card (multi-line text). Uses **absolute UTC** from `timestamp` in the card (not “Ns ago”). Omitted or empty on legacy JSONL without this field. | | **IDENTIFIERS** ||| | `block_height` | int64 | Block height when the record was created | | `timestamp` | int64 | Unix timestamp (consensus rows: block header time; marketplace rows may use ingest time — see `metrics_source`) | | `submitter` | string (optional) | Address of the problem submitter (hex encoded) | | `solver` | string (optional) | Address of the solution solver (hex encoded) | | **PERFORMANCE METRICS** ||| | `problem_complexity` | float64 | Complexity score of the problem | | `bounty` | string | Bounty amount in native tokens (serialized as string to avoid JSON precision loss) | | `work_score` | float64 (optional) | Work score calculated for the solution | | `solution_quality` | float64 (optional) | Quality score of the solution | | **ASYMMETRY METRICS** ||| | `time_asymmetry` | float64 (optional) | Ratio of solve_time / verify_time | | `space_asymmetry` | float64 (optional) | Memory asymmetry metric | | `energy_asymmetry` | float64 (optional) | Energy asymmetry ratio | | **ENERGY MEASUREMENTS** ||| | `solve_energy_joules` | float64 (optional) | Energy consumed during solving (joules) | | `verify_energy_joules` | float64 (optional) | Energy consumed during verification (joules) | | `total_energy_joules` | float64 (optional) | Total energy consumption (joules) | | `energy_per_operation` | float64 (optional) | Energy per operation estimate | | `energy_efficiency` | float64 (optional) | Energy efficiency metric | | **TIMING (consensus / detailed rows)** ||| | `solve_time_us` | uint64 (optional) | Solve duration in microseconds (→ ms in explorer) | | `verify_time_us` | uint64 (optional) | Verify duration in microseconds | | `mining_attempts` | uint64 or null | **Present on every JSONL row** (`null` when not applicable). For consensus blocks the node sets this to the header `nonce` (on-chain proxy for search effort). Omitting the key across some shards caused Hugging Face Data Studio column mismatches. | | **MINING / CONSENSUS** ||| | `difficulty_target` | uint32 (optional) | Minimum leading zero bits in block hash (node PoW setting) | | `nonce` | uint64 (optional) | Winning header nonce | | **METADATA** ||| | `status` | string | Status: "Pending", "Solved", "Mined", "Validated", etc. | | `submission_mode` | string | Submission mode: "public", "private", or "mining" | | `energy_measurement_method` | string | Method used: "rapl", "powermetrics", or "estimate" | | **DATA PROVENANCE** ||| | `metrics_source` | string | Source of metrics: "block_header_actual", "measured_marketplace", "estimated", or "not_applicable" | | `measurement_confidence` | string | Confidence level: "high" (from header), "medium" (proxy/measured), "low" (estimate), or "not_applicable" | | `data_version` | string | Dataset schema version (e.g. `v3.1` — see `huggingface/src/metrics.rs`) | Consensus and marketplace paths may populate **additional optional fields** (timing, memory, energy, network, mining, hardware, economics). The full schema is `DatasetRecord` in `huggingface/src/client.rs`. ### Solution Data Structure Solutions are normalized to a consistent structure to avoid schema conflicts: ```json { "type": "SubsetSum" | "SAT" | "TSP" | "Custom", "data": } ``` - **SubsetSum**: `data` is an array of indices (numbers) - **SAT**: `data` is an array of 0/1 values (normalized from booleans) - **TSP**: `data` is an array representing the tour (numbers) - **Custom**: `data` is a base64-encoded string ### Problem Data Structure For consensus blocks, `problem_data` contains comprehensive block information: ```json { "height": , "miner": , "transactions": [...], "solution_reveal": { "problem": {...}, "solution": { "type": "...", "data": [...] }, "commitment_hash": "...", "problem_hash": "..." }, "solve_time_us": , "verify_time_us": , "energy_estimate_joules": , ... } ``` ## Dataset Creation ### Source Data Data is collected in real-time from running COINjecture Network nodes. Each node pushes records to this dataset when: - A problem is submitted via transaction - A solution is submitted and verified - A consensus block is mined or validated ### Data Collection Process 1. **Problem Submission**: When a problem transaction is processed, a record is created with problem data 2. **Solution Submission**: When a solution is verified, metrics are calculated and a record is created 3. **Consensus Blocks**: Complete block data is recorded for transparency and analysis ### Data Preprocessing - Solutions are normalized to consistent schema (see Solution Data Structure) - Energy measurements use multiple methods (RAPL, powermetrics, or estimation) - Addresses are hex-encoded for consistency - Timestamps are Unix epoch seconds - Large integers (u128) are serialized as strings to avoid JSON precision loss - All problem types are unified in a single continuous dataset for cross-problem analysis ### Normalizing legacy JSONL (Hub viewer / `CastError`) Older JSONL omitted optional keys on some rows. That yields different Arrow **column sets** across shards and breaks Data Studio with `CastError` ("column names don't match"). Current nodes emit the full key set on every line (`null` when unknown). To **batch-fix** existing `data/*.jsonl` files locally (same key names as `DatasetRecord` in `huggingface/src/client.rs`; unknown top-level keys are dropped): ```bash python3 scripts/hf_np_solutions_normalize_jsonl.py --in data/data_1775801281.jsonl --out data/data_1775801281.norm.jsonl ``` Then replace the originals on the Hub (e.g. `hf upload` or Hub API commits). For thousands of files, run in a loop or job runner and commit in batches. If you change `DatasetRecord`, update `RECORD_KEYS` in `scripts/hf_np_solutions_jsonl_common.py` to match. **Automated Hub pass** (download → normalize → upload one commit per file; needs `pip install huggingface_hub` and a write token): ```bash export HF_TOKEN=hf_... python3 scripts/hf_np_solutions_batch_normalize_hub.py --dry-run python3 scripts/hf_np_solutions_batch_normalize_hub.py --limit 5 python3 scripts/hf_np_solutions_batch_normalize_hub.py --sleep 1.0 ``` Use `--start-after data/data_.jsonl` to resume. Full runs create thousands of commits; prefer a VM, tune `--sleep`, or fork the script to batch multiple files per `create_commit` if you hit rate limits. ## Dataset Statistics - **Total Records**: Growing in real-time (unified dataset with all problem types) - **Update Frequency**: Real-time (buffered, flushed when 10 total records accumulated across all problem types) - **Data Format**: JSONL (newline-delimited JSON) - **Storage Location**: `/data/` directory in the repository - **Problem Types**: SubsetSum, SAT, TSP, Custom, Private (all in one dataset) - **Data Quality**: v3.1 institutional-grade records when emitted by current nodes (block header and extended metrics where available) ## Considerations for Using the Data ### Ethical Considerations - All data is from public blockchain transactions - Addresses are included only if explicitly enabled (privacy option) - No personally identifiable information is collected ### Licensing This dataset is released under the MIT License. ### Citation Information If you use this dataset in your research, please cite: ```bibtex @dataset{coinjecture_np_solutions, title={COINjecture NP-Solutions Dataset}, author={COINjecture Network}, year={2024}, url={https://huggingface.co/datasets/COINjecture/NP-Solutions} } ``` ## Dataset Access ### Using Hugging Face Datasets ```python from datasets import load_dataset # Load the dataset dataset = load_dataset("COINjecture/NP-Solutions", split="train") # Access records for record in dataset: print(record["problem_id"]) print(record["problem_data"]) ``` ### Direct File Access The raw JSONL files are available in the `/data/` directory: - Files are named `data_.jsonl` - Each line is a complete JSON record - Files can be processed with standard JSONL tools ### API Access The dataset is accessible via the Hugging Face API: - Dataset viewer: https://huggingface.co/datasets/COINjecture/NP-Solutions - API endpoint: `https://huggingface.co/api/datasets/COINjecture/NP-Solutions` ### Uploading with the Hugging Face CLI For manual pushes (exports, Parquet/JSONL, README updates), use the [`hf` CLI](https://huggingface.co/docs/huggingface_hub/guides/cli). Install **one** of these (pick what works on your machine): ```bash # Option A — standalone installer (macOS / Linux; adds hf to your PATH) curl -LsSf https://hf.co/cli/install.sh | bash # Option B — Homebrew (if the formula is available on your Mac) brew install hf # Option C — Python (hf ships with huggingface_hub; ensure the install’s bin is on PATH) python3 -m pip install -U "huggingface_hub" ``` Then authenticate and upload (example: dataset card only from this repo): ```bash hf auth login # or: export HF_TOKEN=... (never commit tokens) cd /path/to/COINjecture2.0-main hf upload COINjecture/NP-Solutions huggingface/README.md --repo-type=dataset \ --commit-message "Dataset card: viewer YAML + schema notes" # Or upload everything in the current directory tree: hf upload COINjecture/NP-Solutions . --repo-type=dataset ``` Set `HF_DATASET_NAME` / `--hf-dataset-name` to this repo’s Hub id (`COINjecture/NP-Solutions`). Hyphen vs underscore are different Hub repositories if both exist. ## Additional Information ### Energy Measurement Methods - **RAPL** (Linux): Intel/AMD Running Average Power Limit counters - **powermetrics** (macOS): macOS powermetrics tool - **estimate**: CPU TDP-based estimation (fallback, works everywhere) ### Problem Types 1. **SubsetSum**: Find a subset of numbers that sum to a target 2. **SAT**: Boolean satisfiability problem 3. **TSP**: Traveling Salesman Problem 4. **Custom**: Arbitrary problem data (base64 encoded) ### Performance Metrics - **Time Asymmetry**: Measures how much harder solving is than verifying - **Space Asymmetry**: Memory usage differences - **Energy Asymmetry**: Energy consumption differences - **Energy Efficiency**: Work performed per unit of energy ## Contact For questions or issues: - Dataset repository: https://huggingface.co/datasets/COINjecture/NP-Solutions - Open a discussion on the dataset page ## Changelog ### 2026-04-16 - **Hub `CastError` / “column names don’t match”**: Older JSONL omitted optional fields entirely (`serde` `skip_serializing_if`). Different shards then inferred different Arrow column sets. Nodes now serialize **every** `DatasetRecord` field on every line (`null` when `None`), so new shards align with the full schema. Existing Hub files stay sparse until replaced or batch-normalized. ### 2026-04-15 - **JSONL shape (nodes)**: `mining_attempts` is always serialized (use `null` when unknown); consensus rows set it from header `nonce`. `problem_data` / `solution_data` are coerced to JSON objects before upload so stringified JSON blobs are not emitted. - **Dataset card YAML**: Do **not** add a `configs` / `on_mixed_types` block for this repo: it made the Hub builder infer `problem_data`/`solution_data` as strings while legacy shards still use nested JSON objects, which triggers `DatasetGenerationError` / `CastError` when generating the preview table. ### 2026-04-10 - **`explorer_card` field**: Each JSONL row includes a precomputed multi-line card (UTC time); implemented in `huggingface/src/explorer_card.rs`. - **Explorer layout**: Documented the block-card presentation (block #, type, time, problem/solution prose, solver, BEANS reward, work, asymmetry, quality, Δt, energy) with line-by-line JSON mapping and a Python `format_block_card` helper. ### 2025-11-23 - **Unified Dataset**: Consolidated all problem types (SubsetSum, SAT, TSP, Custom) into a single continuous dataset - **Schema Fix**: Fixed u128 bounty serialization (now serialized as string to avoid JSON precision loss) - **Data Provenance**: Added institutional-grade data provenance fields (metrics_source, measurement_confidence, data_version) - **Unified Buffer**: Changed from per-problem-type buffers to unified buffer that flushes all types together - **Enhanced Metrics**: All consensus blocks now include actual block header metrics (high confidence)