(notation: to match the graph on the deepfunding website, all arrows are in the direction of dependency, i.e. \(P\to Q\) means \(P\) depends on \(Q\).)

We have a tree (well DAG) of depth exactly 2. - Depth 0 is a single node, ethereum — call this \(O\). - Depth 1 is 34 nodes, “seed repositories” — \(A_1,\dots A_{34}\). - Depth 2 are the ~5000 code dependencies of the seed repositories \(B_1,\dots B_{4381}\); with a total of ~15000 edges of the form \((A_i,B_j)\)¹

The task of a contestant is to provide: - Level 1: weights \(w_{O\to A}\), denoted like https://github.com/a,ethereum,0.2 such that \(\sum_A w_{O\to A}=1\) [34 outputs] - Level 2: self-weights \(w_{A}\) denoted like https://github.com/a,originality,0.6 [34 outputs] - Level 3: weights \(w_{A\to B}\) denoted like https://github.com/b,https://github.com/a,0.6 such that the sum of \(A\)’s dependencies \(\sum_Bw_{A\to B}=1\) i.e. (note that they add up to 1 and not to \(1-w_{A}\)²) [~15000 outputs]

A juror is given random samples of: - pairs of edges \(((O\to A_1),(O\to A_2))\) for which they give the “relative advantage of \(A_2\) over \(A_1\) to \(O\)” \(j_{(O\to A_1),(O\to A_2)}\) (taken³ as measured in logits). - Depth 1 nodes \(A\) for which they directly estimate the originality score \(j_{A}\). - pairs of edges \(((A\to B_1),(A\to B_2))\) for which they give the “relative advantage of \(B_2\) over \(B_1\) to \(A\)” \(j_{(A\to B_1),(A\to B_2)}\).⁴

To give values for all of these would take, where \(n_A\) is the number of dependencies of \(A\):

\[\frac{34\cdot(34-1)}{2}+34+\sum_{A}\frac{n_A(n_A-1)}{2}\] I ran a quick script to calculate this from the sample submissions (see “helper csv” below), and it comes out to 8,353,774. In particular this means we would need 8,353,774 events if we directly implemented a distillation market. So we need something smarter — ideally something that doesn’t require more than 15000 questions for the 15000 weights.

First let me quickly go over how Deepfunding scores the contestants.

The cost for Level-1 answers is \(\left|\log(w_{O\to A_2}/w_{O\to A_1}) - j_{(O\to A_1),(O\to A_2)}\right|^2\) , summed over all pairs \(((O\to A_1),(O\to A_2))\) for which the juror has provided an estimate.

The cost for Level-2 answers is simply \(\left|w_A-j_A\right|^2\) summed over all \(A\) for which the juror has provided an estimate.

The cost for Level-3 answers is again \(\left|\log(w_{A\to B_2}/w_{A\to B_1}) - j_{(A\to B_1),(A\to B_2)}\right|^2\) , summed over all pairs \(((A\to B_1),(A\to B_2))\) for which the juror has provided an estimate.

BLEG: I’m not sure how these are to be weighted. The concrete instructions just say they are summed over all juror samples, but this depends on how many juror samples are taken of each category — this is probably important if we want to weight questions properly. We should ask them, or maybe we can just create another event to ask the market what it thinks they will do :)

This covers how Deepfunding will score our final model submission. As we will see, this does not necessarily straightforwardly translate to how we score miners in preparing our model.

Level-2 is straightforward — we simply create a question for each \(A\) (depth-1 node) asking “how original is \(A\)?” and score as:

\[s(w_A)=\left|w_A-j_A\right|^2\]

if \(j_A\) is elicited and 0 is otherwise. Then perform the peer score adjustment (otherwise the miners are incentivized to just not bet). ## scoring for level 1 and level 3

The basic problem for scoring Level-1 and Level-3 questions is:

• we can only create events for each edge, not for each of the 8 million pairs of edges
• the scoring needs to be “modular” i.e. the total score needs to be reducible to a sum of scoring functions that each depend on only one question. \(\sum\left|\log(w_{A\to B_2}/w_{A\to B_1}) - j_{(A\to B_1),(A\to B_2)}\right|^2\) does not satisfy this property.

Three possible solutions:

#+begin_src python import csv import json import pandas as pd import numpy as np

import requests import time from datetime import datetime from urllib.parse import urlparse import os from dotenv import load_dotenv from functools import lru_cache

load_dotenv()

INCLUDE_{REPOHEURISTICS} = True

if “GITHUB_TOKEN” not in os.environ and INCLUDE_{REPOHEURISTICS}: print(“Warning: GitHub API token not found. You will get rate-limited. You should set INCLUDE_{REPOHEURISTICS} to False.”)

L1_{TRAINSETEXAMPLES} = “” L2_{TRAINSETEXAMPLES} = “” L3_{TRAINSETEXAMPLES} = “”

PROMPT_INTRO = “This question is for the `Deepfunding competition`, a distillation prediction market for determining the relative importances of different dependencies in the Ethereum ecosystem.”

USE_{LONGJURORLIST} = False SHORT_JURORLIST = “\nThe jurors are expected to be experts in the Ethereum ecosystem. Some known names include: Jason, Toni Wahrstatter, Ladislaus, Vitalik Buterin, DC Builder, Vectorized and Marius Van Der.” LONG_JURORLIST = “”" This is the list of publicly known jurors, if it helps you. The jurors are expected to be experts in the Ethereum ecosystem.

“”"

TRAIN_{SETEXAMPLESPROMPT} = ( “Here are some existing juror answers from the public ‘training set’.” )

L1_PROMPTBASE = “”"

For this question, you will need to estimate the relative importances of two direct dependencies of Ethereum:

<QUESTION> {repo1} and {repo2} are dependencies of Ethereum. Estimate the ratio of importance of {repo2} to {repo1}. E.g. if {repo2} is 10 times more important then {repo1} then answer “10”; if {repo1} is 10 times more important than {repo2} then answer “0.1”. </QUESTION>

This exact question will be asked to the Deepfunding jury. Your job is to predict how the Deepfunding jury will answer this question, and answer as close as possible to what the jury will. To be exact: we will score you based on the mean-squared-error between the log of your answer and the log of the jury’s answer.

Your answer must be a positive float.

“”"

L2_PROMPTBASE = “”"

For this question, you will be given a repository and you need to estimate how much of its value belongs to that repository itself, versus its dependencies.

<QUESTION> How much of {repo}’s value comes from itself, versus its dependencies? E.g.

Examples: Brave (a fork of Chromium), Ollama (a wrapper of llama.cpp).

Example: An Ethereum wallet.

</QUESTION>

This exact question will be asked to the Deepfunding jury. Your job is to predict how the Deepfunding jury will answer this question, and answer as close as possible to what the jury will. To be exact: we will score you based on the mean-squared-error between your answer and the jury’s answer.

Your answer must be a float between 0 and 1.

“”"

L3_PROMPTBASE = “”"

For this question, we are looking at the {parent} repository. You will need to estimate the relative importances of two dependencies of this repository – i.e. which of their dependencies matters more for {parent}.

<QUESTION> {repo1} and {repo2} are dependencies of {parent}. Estimate the ratio of importance of {repo2} compared to {repo1} for {parent}. E.g. if {repo2} is 10 times more important then {repo1} for {parent} then answer “10”; if {repo1} is 10 times more important than {repo2} then answer “0.1”. </QUESTION>

This exact question will be asked to the Deepfunding jury. Your job is to predict how the Deepfunding jury will answer this question, and answer as close as possible to what the jury will. To be exact: we will score you based on the mean-squared-error between the log of your answer and the log of the jury’s answer.

Your answer must be a positive float.

“”"

class RepoHeuristics: “”“Fetch and cache heuristics about GitHub repositories.”“”

def __init__{(self, githubtoken=None, cachettl=3600)}: “”" Initialize the heuristics fetcher.

Args: github_token: GitHub API token (optional but recommended to avoid rate limits) cache_ttl: Time in seconds to cache repository data “”" self.github_token = github_token or os.environ.get(’GITHUB_TOKEN’) self.headers = {’Authorization’: f’token {self.github_token}’} if self.github_token else {} self.cache_ttl = cache_ttl self._repocache = {}

@staticmethod def parse_githuburl(repo_url): “”“Extract owner and repo name from a GitHub URL.”“” if not repo_url or ’github.com’ not in repo_url: return None, None

parsed = urlparse(repo_url) path_parts = parsed.path.strip(’’).split(’’)

if len(path_parts) < 2: return None, None

return path_parts[0], path_parts[1]

@lru_cache(maxsize=128) def get_repoinfo(self, repo_url): “”" Fetch detailed information about a repository.

Args: repo_url: Full URL to the GitHub repository

Returns: Dictionary with repository information or None on failure “”" owner, repo = self.parse_githuburl(repo_url) if not owner or not repo: return None

cache_key = f“{owner}/{repo}” if cache_key in self._repocache: cached_data, timestamp = self._repocache[cache_key] if time.time() - timestamp < self.cache_ttl: return cached_data

try: repo_apiurl = f“https://api.github.com/repos/%7Bowner%7D/%7Brepo}” response = requests.get(repo_apiurl, headers=self.headers) response.raise_forstatus() repo_data = response.json()

contributors_url = f“{repo_apiurl}/contributors?per_page=5” contributors_resp = requests.get(contributors_url, headers=self.headers) contributors_{resp.raiseforstatus}() contributors = contributors_resp.json()

languages_url = f“{repo_apiurl}/languages” languages_resp = requests.get(languages_url, headers=self.headers) languages_{resp.raiseforstatus}() languages = languages_resp.json()

repo_info = { ’name’: repo_data.get(’name’), ’full_name’: repo_data.get(’full_name’), ’description’: repo_data.get(’description’), ’stars’: repo_data.get(’stargazers_count’, 0), ’forks’: repo_data.get(’forks_count’, 0), ’watchers’: repo_data.get(’watchers_count’, 0), ’open_issues’: repo_data.get(’open_issuescount’, 0), ’created_at’: repo_data.get(’created_at’), ’updated_at’: repo_data.get(’updated_at’), ’contributors’: [c.get(’login’) for c in contributors[:5]], ’languages’: languages, ’homepage’: repo_data.get(’homepage’), ’license’: repo_data.get(’license’, {}).get(’name’) if repo_data.get(’license’) else None, ’topics’: repo_data.get(’topics’, []), ’size’: repo_data.get(’size’, 0) }

self._repocache[cache_key] = (repo_info, time.time())

return repo_info

except Exception as e: print(f“Error fetching data for {repo_url}: {e}”) return None

def format_{repoheuristics}(self, repo_url): “”“Format repository information as a readable string.”“” repo_info = self.get_repoinfo(repo_url) if not repo_info: return f“Repository {repo_url} information not available.”

total_bytes = sum(repo_info[’languages’].values()) if repo_info[’languages’] else 1 language_percentages = {lang: f“{count/total_bytes*100:.1f}%” for lang, count in repo_info[’languages’].items()}

created_date = datetime.strptime(repo_info[’created_at’], “%Y-%m-%dT%H:%M:%SZ”) if repo_info[’created_at’] else None age = (datetime.now() - created_date).days // 30 if created_date else “unknown”

info_string = f“”"[{repo_info[’full_name’]}]:

• Description: {repo_info[’description’] or ’No description’}
• Stars: {repo_info[’stars’]}, Forks: {repo_info[’forks’]}
• Age: {age} months, Last updated: {repo_info[’updated_at’].split(’T’)[0] if repo_info[’updated_at’] else ’Unknown’}
• Main languages: {’, ’.join(f“{lang} ({pct})” for lang, pct in list(language_{percentages.items}())[:3])}
• Top contributors: {’, ’.join(repo_info[’contributors’]) if repo_info[’contributors’] else ’Unknown’}
• Topics: {’, ’.join(repo_info[’topics’]) if repo_info[’topics’] else ’None’}

“”" return info_string

def compare_repos(self, repo1_url, repo2_url): “”“Compare two repositories and return a formatted comparison string.”“” repo1_info = self.get_repoinfo(repo1_url) repo2_info = self.get_repoinfo(repo2_url)

if not repo1_info or not repo2_info: return “Comparison information not available for one or both repositories.”

star_ratio = repo2_info[’stars’] / max(1, repo1_info[’stars’]) if star_ratio > 1.5: star_comparison = f“{repo2_info[‘full_name’]} has {star_ratio:.1f}x more stars than {repo1_info[‘full_name’]}” elif star_ratio < 0.67: star_comparison = f“{repo1_info[‘full_name’]} has {(1/star_ratio):.1f}x more stars than {repo2_info[‘full_name’]}” else: star_comparison = f“Both repositories have similar star counts ({repo1_info[‘stars’]} vs {repo2_info[‘stars’]})”

try: repo1_date = datetime.strptime(repo1_info[’updated_at’], “%Y-%m-%dT%H:%M:%SZ”) if repo1_info[’updated_at’] else None repo2_date = datetime.strptime(repo2_info[’updated_at’], “%Y-%m-%dT%H:%M:%SZ”) if repo2_info[’updated_at’] else None

if repo1_date and repo2_date: date_diff = abs((repo1_date - repo2_date).days) if date_diff > 30: more_recent = f“{repo1_info[‘full_name’] if repo1_date > repo2_date else repo2_info[‘full_name’]} has been updated more recently” else: more_recent = “Both repositories have been updated recently” else: more_recent = “Update information not available for comparison” except: more_recent = “Error comparing dates”

comparison = f“”"

1. {repo1_info[’full_name’]} vs 2. {repo2_info[’full_name’]}
2. Star comparison: {star_comparison}
3. Activity: {more_recent}
4. Age: {repo1_info[’created_at’].split(’T’)[0] if repo1_info[’created_at’] else ’Unknown’} vs {repo2_info[’created_at’].split(’T’)[0] if repo2_info[’created_at’] else ’Unknown’}
5. Languages: • {repo1_info[’full_name’]}: {’, ’.join(list(repo1_info[’languages’].keys())[:3]) if repo1_info[’languages’] else ’Unknown’} • {repo2_info[’full_name’]}: {’, ’.join(list(repo2_info[’languages’].keys())[:3]) if repo2_info[’languages’] else ’Unknown’}

“”" return comparison

repo_heuristics = RepoHeuristics()

def _format_reponame(repo: str): “”“Format a repository name for display.”“” return ( repo.replace(“https://”, “”) .replace(“http://”, “”) .replace(“www.”, “”) .replace(“github.com”, “”) .strip(“/”) )

def format_l1prompt(repo1, repo2): prompt = PROMPT_INTRO + L1_{PROMPTBASE.format}( repo1=_{formatreponame}(repo1), repo2=_{formatreponame}(repo2) )

if INCLUDE_{REPOHEURISTICS}:

try: comparison = repo_{heuristics.comparerepos}(repo1, repo2) prompt += “Repository Comparison:\n” + comparison except Exception as e: print(f“Warning: Could not fetch repository comparison for {repo1} and {repo2}: {e}”)

prompt += LONG_JURORLIST if USE_{LONGJURORLIST} else SHORT_JURORLIST prompt += ( TRAIN_{SETEXAMPLESPROMPT} + “\n\n” + L1_{TRAINSETEXAMPLES} if L1_{TRAINSETEXAMPLES} else “” ) return prompt

def format_l2prompt(repo): prompt = PROMPT_INTRO + L2_{PROMPTBASE.format}(repo=_{formatreponame}(repo))

if INCLUDE_{REPOHEURISTICS}:

try: repo_info = repo_{heuristics.formatrepoheuristics}(repo) prompt += “Repository Information:\n” + repo_info except Exception as e: print(f“Warning: Could not fetch repository information for {repo}: {e}”)

prompt += LONG_JURORLIST if USE_{LONGJURORLIST} else SHORT_JURORLIST prompt += ( TRAIN_{SETEXAMPLESPROMPT} + “\n\n” + L2_{TRAINSETEXAMPLES} if L2_{TRAINSETEXAMPLES} else “” ) return prompt

def format_l3prompt(repo1, repo2, parent): prompt = PROMPT_INTRO + L3_{PROMPTBASE.format}( repo1=_{formatreponame}(repo1), repo2=_{formatreponame}(repo2), parent=_{formatreponame}(parent), )

if INCLUDE_{REPOHEURISTICS}:

try: parent_info = repo_{heuristics.formatrepoheuristics}(parent) prompt += “Parent Repository Information:\n” + parent_info

comparison = repo_{heuristics.comparerepos}(repo1, repo2) prompt += “\nDependency Comparison:\n” + comparison except Exception as e: print(f“Warning: Could not fetch repository information: {e}”)

prompt += LONG_JURORLIST if USE_{LONGJURORLIST} else SHORT_JURORLIST prompt += ( TRAIN_{SETEXAMPLESPROMPT} + “\n\n” + L3_{TRAINSETEXAMPLES} if L3_{TRAINSETEXAMPLES} else “” ) return prompt

def load_csv(file_path): “”“Load CSV file into a pandas DataFrame.”“” try: df = pd.read_csv(file_path, skipinitialspace=True) return df except Exception as e: raise Exception(f“Error loading CSV file: {e}”)

def extract_{importantrepos}(df): “”“Extract the list of important repositories from rows with ethereum as parent.”“”

important_repos = list(df[df[“parent”] == “ethereum”][“repo”]) return important_repos

def validate_{importantrepos}(df, important_repos): “”“Perform validations on the list of important repositories.”“”

if len(important_repos) != 35: raise ValueError( f“Expected 35 important repos, but found {len(important_repos)}” )

ethereum_children = set(df[df[“parent”] = "ethereum"]["repo"].unique()) originality_children = set(df[df["parent"] = “originality”][“repo”].unique())

if ethereum_children != originality_children: diff = ethereum_{children.symmetricdifference}(originality_children) raise ValueError(f“Mismatch between ethereum and originality lists: {diff}”)

middle_sections = df[~df[“parent”].isin([“ethereum”, “originality”])] middle_parents = set(middle_sections[“parent”].unique())

if not middle_{parents.issubset}(set(important_repos)): invalid_parents = middle_parents - set(important_repos) raise ValueError( f“Found items in middle column that are not in important_repos: {invalid_parents}” )

return True

def calculate_{dependencyweights}(df, important_repos): “”“ Calculate total weights of dependencies for each important repo and validate they sum to 1. ”“” dependency_weights = {} dependency_counts = {}

for repo in important_repos:

deps = df[ (df[“parent”] == repo) & ~df[“repo”].isin([“ethereum”, “originality”]) ]

total_weight = deps[“weight”].sum() dependency_weights[repo] = total_weight

dependency_counts[repo] = len(deps)

if len(deps) > 0 and not np.isclose(total_weight, 1.0, atol=1e-6): raise ValueError(f“Weights for {repo} sum to {total_weight}, not 1.0”)

return dependency_weights, dependency_counts

def calculate_combinations(n): “”“Calculate n choose 2, which is n*(n-1)/2”“” return n * (n - 1) / 2

def get_{repoclassificationweights}(df, important_repos): “”“Get the ethereum and originality weights for each important repo.”“” ethereum_weights = dict( zip( df[df[“parent”] = "ethereum"]["repo"], df[df["parent"] = “ethereum”][“weight”], ) )

originality_weights = dict( zip( df[df[“parent”] = "originality"]["repo"], df[df["parent"] = “originality”][“weight”], ) )

return ethereum_weights, originality_weights

def compile_outputcsv( important_repos, dependency_weights, dependency_counts, ethereum_weights, originality_weights, output_file, ): “”“Create the output CSV file with the required columns.”“” combinations = {} total_combinations = 0

for repo in important_repos: count = dependency_counts.get(repo, 0) comb = calculate_combinations(count) combinations[repo] = comb total_combinations += comb

with open(output_file, “w”, newline=“”) as csvfile: fieldnames = [ “important_repo”, “sum_depweights”, “num_deps”, “num_{depscombinations}”, “originality”, “ethereum”, ] writer = csv.DictWriter(csvfile, fieldnames=fieldnames)

writer.writeheader() for repo in important_repos: writer.writerow( { “important_repo”: repo, “sum_depweights”: dependency_weights.get(repo, 0), “num_deps”: dependency_counts.get(repo, 0), “num_{depscombinations}”: combinations.get(repo, 0), “originality”: originality_weights.get(repo, 0), “ethereum”: ethereum_weights.get(repo, 0), } )

return total_combinations

def generate_questions(df, important_repos, questions_file): “”" Generate three lists of questions based on the data and write them to a JSONL file:

1. Level 1: Questions about consecutive pairs of important repos
2. Level 2: Questions about each important repo’s originality
3. Level 3: Questions about consecutive pairs of dependencies for each important repo

Args: df: DataFrame containing the CSV data important_repos: List of important repositories questions_file: Path to the output JSONL file

Returns: Tuple of (level1_count, level2_count, level3_count) indicating the number of questions generated “”"

with open(questions_file, “w”) as jsonl_file:

level1_count = _generate_{andwritelevel1questions}(important_repos, jsonl_file)

level2_count = _generate_{andwritelevel2questions}(important_repos, jsonl_file)

level3_count = _generate_{andwritelevel3questions}( df, important_repos, jsonl_file )

return level1_count, level2_count, level3_count

def _generate_{andwritelevel1questions}(important_repos, jsonl_file): “”" Generate and write questions for consecutive pairs of important repos.

Args: important_repos: List of important repositories jsonl_file: File handle for the output JSONL file

Returns: Number of questions generated “”" count = 0

for i in range(len(important_repos)): repo1 = important_repos[i] repo2 = important_repos[(i + 1) % len(important_repos)] # Wrap around to start

content = format_l1prompt(repo1, repo2)

question = { “level”: 1, “repo1”: repo1, “repo2”: repo2, “parent”: “ethereum”, “content”: content, }

json.dump(question, jsonl_file) jsonl_file.write(“\n”) count += 1

return count

def _generate_{andwritelevel2questions}(important_repos, jsonl_file): “”" Generate and write questions about each important repo’s originality.

Args: important_repos: List of important repositories jsonl_file: File handle for the output JSONL file

Returns: Number of questions generated “”" count = 0

for repo in important_repos: content = format_l2prompt(repo)

question = { “level”: 2, “repo”: repo, “parent”: “originality”, “content”: content, }

json.dump(question, jsonl_file) jsonl_file.write(“\n”) count += 1

return count

def _generate_{andwritelevel3questions}(df, important_repos, jsonl_file): “”" Generate and write questions about consecutive pairs of dependencies for each important repo.

Args: df: DataFrame containing the CSV data important_repos: List of important repositories jsonl_file: File handle for the output JSONL file

Returns: Number of questions generated “”" count = 0

middle_rows = df[~df[“parent”].isin([“ethereum”, “originality”])]

for parent_repo in important_repos:

dependencies = middle_rows[middle_rows[“parent”] == parent_repo][ “repo” ].tolist()

if len(dependencies) > 1: # Only if there are at least 2 dependencies for i in range(len(dependencies)): repo1 = dependencies[i] repo2 = dependencies[ (i + 1) % len(dependencies) ] # Wrap around to start

content = format_l3prompt(repo1=repo1, repo2=repo2, parent=parent_repo)

question = { “level”: 3, “repo1”: repo1, “repo2”: repo2, “parent”: parent_repo, “content”: content, }

json.dump(question, jsonl_file) jsonl_file.write(“\n”) count += 1

return count

def main(input_file, output_file, questions_file=None): “”“Main function to process the CSV file and optionally generate questions.”“” try:

df = load_csv(input_file)

important_repos = extract_{importantrepos}(df)

validate_{importantrepos}(df, important_repos)

dependency_weights, dependency_counts = calculate_{dependencyweights}( df, important_repos )

ethereum_weights, originality_weights = get_{repoclassificationweights}( df, important_repos )

total_combinations = compile_outputcsv( important_repos, dependency_weights, dependency_counts, ethereum_weights, originality_weights, output_file, )

print(f“Successfully processed {input_file} and created {output_file}”) print( f“Found {len(important_repos)} important repositories with valid weight distributions.” ) print( f“Total number of dependency pairs (num_{depscombinations}): {total_combinations}” )

if questions_file: level1_count, level2_count, level3_count = generate_questions( df, important_repos, questions_file )

print(f“\nGenerated and wrote to {questions_file}:”) print(f“- {level1_count} level 1 questions (important repo comparisons)”) print(f“- {level2_count} level 2 questions (repo originality)”) print(f“- {level3_count} level 3 questions (dependency comparisons)”) print(f“Total: {level1_count + level2_count + level3_count} questions”)

except Exception as e: print(f“Error: {e}”) raise

if name == “main”: import argparse

parser = argparse.ArgumentParser(description=“Process repo dependency CSV file.”) parser.add_argument(“input_file”, help=“Path to the input CSV file”) parser.add_argument( “–output_file”, default=“repo_analysis.csv”, help=“Path to the output CSV file (default: repo_analysis.csv)”, ) parser.add_argument( “–questions_file”, help=“Path to output JSONL file for generated questions” )

args = parser.parse_args() main(args.input_file, args.output_file, args.questions_file) #+end_src

</QUESTION>

This exact question will be asked to the Deepfunding jury. Your job is to predict how the Deepfunding jury will answer this question, and answer as close as possible to what the jury will. To be exact: we will score you based on the mean-squared-error between your answer and the jury’s answer.

Your answer must be a float between 0 and 1.

Repository Information: [vyperlang/vyper]:

• Description: Pythonic Smart Contract Language for the EVM
• Stars: 4995, Forks: 837
• Age: 101 months, Last updated: 2025-03-17
• Main languages: Python (99.8%), Makefile (0.1%), Batchfile (0.1%)
• Top contributors: jacqueswww, charles-cooper, iamdefinitelyahuman, fubuloubu, DavidKnott
• Topics: ethereum, ethereum-dapp, language, python, vyper

The jurors are expected to be experts in the Ethereum ecosystem. Some known names include: Jason, Toni Wahrstatter, Ladislaus, Vitalik Buterin, DC Builder, Vectorized and Marius Van Der. #+end_src

Level 3

This question is for the `Deepfunding competition`, a distillation prediction market for determining the relative importances of different dependencies in the Ethereum ecosystem.

For this question, we are looking at the prysmaticlabs/prysm repository. You will need to estimate the relative importances of two dependencies of this repository -- i.e. which of their dependencies matters more for prysmaticlabs/prysm.

<QUESTION>
coreos/go-systemd and herumi/bls-eth-go-binary are dependencies of prysmaticlabs/prysm. Estimate the ratio of importance of herumi/bls-eth-go-binary compared to coreos/go-systemd for prysmaticlabs/prysm.
E.g. if herumi/bls-eth-go-binary is 10 times more important then coreos/go-systemd for prysmaticlabs/prysm then answer "10"; if coreos/go-systemd is 10 times more important than herumi/bls-eth-go-binary then answer "0.1".
</QUESTION>

This exact question will be asked to the Deepfunding jury.
**Your job is to predict how the Deepfunding jury will answer this question, and answer as close as possible to what the jury will.**
To be exact: we will score you based on the mean-squared-error between the log of your answer and the log of the jury's answer.

Your answer must be a positive float.

Parent Repository Information:
[prysmaticlabs/prysm]:
- Description: Go implementation of Ethereum proof of stake
- Stars: 3546, Forks: 1090 
- Age: 87 months, Last updated: 2025-03-17
- Main languages: Go (93.6%), Starlark (5.5%), Shell (0.5%)
- Top contributors: terencechain, prestonvanloon, rauljordan, nisdas, rkapka
- Topics: ethereum

Dependency Comparison:

1. coreos/go-systemd vs 2. herumi/bls-eth-go-binary
- Star comparison: coreos/go-systemd has 36.6x more stars than herumi/bls-eth-go-binary
- Activity: Both repositories have been updated recently
- Age: 2013-09-13 vs 2019-10-19
- Languages: 
  • coreos/go-systemd: Go, Shell
  • herumi/bls-eth-go-binary: Go, C, C++
 
The jurors are expected to be experts in the Ethereum ecosystem. Some known names include: Jason, Toni Wahrstatter, Ladislaus, Vitalik Buterin, DC Builder, Vectorized and Marius Van Der.