> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/Metaculus/metaculus/llms.txt
> Use this file to discover all available pages before exploring further.

# Questions

> Understanding question types, lifecycle, and resolution on Metaculus

## Overview

Questions are the core forecasting objects on Metaculus. Each question asks forecasters to predict the outcome of a future event. Metaculus supports multiple question types to accommodate different kinds of predictions.

## Question Types

Metaculus supports five distinct question types, each optimized for different forecasting scenarios:

<CardGroup cols={2}>
  <Card title="Binary" icon="toggle-on">
    Yes/No questions with probability forecasts between 0% and 100%
  </Card>

  <Card title="Numeric" icon="hashtag">
    Continuous range predictions with customizable scales (linear or logarithmic)
  </Card>

  <Card title="Date" icon="calendar">
    Predictions about when an event will occur
  </Card>

  <Card title="Multiple Choice" icon="list-check">
    Select from predefined options with probability distributions
  </Card>

  <Card title="Discrete" icon="chart-bar">
    Continuous predictions over a discrete set of outcomes
  </Card>
</CardGroup>

### Binary Questions

Binary questions are the simplest type, asking for a yes/no prediction.

**Data Model** (from `questions/models.py:80-85`):

```python theme={null}
class QuestionType(models.TextChoices):
    BINARY = "binary"
```

Forecasters provide a single probability value representing their confidence that the answer will be "yes."

**Example**: "Will SpaceX launch Starship to orbit before 2026?"

### Multiple Choice Questions

Multiple choice questions allow forecasters to distribute probabilities across multiple options.

**Key Features**:

* Options can be modified before forecasting begins
* Options history is tracked (from `questions/models.py:222-231`)
* Support for dynamic ordering (by community prediction or default)
* "Other" category for unlisted outcomes

**Options Ordering** (from `questions/models.py:233-244`):

* `DEFAULT`: Display views sorted by CP, forecast maker preserves creation order
* `CP_DESC`: All views sort options by descending community prediction

**Example**: "Which company will achieve AGI first? \[OpenAI, Anthropic, Google, Meta, Other]"

### Numeric Questions

Numeric questions ask for predictions over a continuous range of numbers.

**Configuration Options** (from `questions/models.py:177-217`):

* `range_min` / `range_max`: Minimum and maximum values
* `zero_point`: For logarithmic scales, the value of the zero point
* `open_upper_bound` / `open_lower_bound`: Whether resolutions outside the range are possible
* `unit`: Display unit (e.g., "meters", "dollars")

**Example**: "What will be the global average temperature anomaly in 2030? (°C)"

### Date Questions

Date questions are specialized numeric questions for temporal predictions.

**Features**:

* Same configuration options as numeric questions
* Internally represented as timestamps
* Displayed with calendar interfaces

**Example**: "When will the next recession begin?"

### Discrete Questions

Discrete questions provide predictions over a fixed number of discrete outcomes.

**Configuration** (from `questions/models.py:210-215`):

* `inbound_outcome_count`: Number of possible outcomes (default: 200)
* Range bounds similar to numeric questions
* Does NOT use `zero_point` (continuous scale only)

**Example**: "How many seats will Democrats win in the 2026 Senate? \[0-100]"

## Question Lifecycle

Questions progress through several states during their lifecycle:

<Steps>
  <Step title="Upcoming">
    Question is created but not yet open for forecasting. The `open_time` is in the future.
  </Step>

  <Step title="Open">
    Question is actively accepting forecasts. Current time is between `open_time` and `scheduled_close_time`.
  </Step>

  <Step title="Closed">
    Forecasting period has ended, but resolution is not yet known.
  </Step>

  <Step title="Resolved">
    The outcome is known and the question has been resolved with a final answer.
  </Step>
</Steps>

### Status Determination

The question status is computed dynamically (from `questions/models.py:355-375`):

```python theme={null}
@property
def status(self) -> QuestionStatus:
    now = timezone.now()
    
    if not self.scheduled_close_time or not self.open_time or self.open_time > now:
        return QuestionStatus.UPCOMING
    
    if self.resolution or (self.actual_resolve_time and self.actual_resolve_time < now):
        return QuestionStatus.RESOLVED
    
    if self.scheduled_close_time <= now or (self.actual_close_time and self.actual_close_time <= now):
        return QuestionStatus.CLOSED
    
    return QuestionStatus.OPEN
```

## Time Fields

Questions have several important timestamps that control their lifecycle:

<AccordionGroup>
  <Accordion title="open_time" icon="door-open">
    Time when forecasting begins. Defines the start of the scoring period. **Should not be changed after forecasts are made.**
  </Accordion>

  <Accordion title="scheduled_close_time" icon="door-closed">
    Planned time when forecasting ends. Defines the end of the scoring period. **Should not be changed after forecasts are made.**
  </Accordion>

  <Accordion title="scheduled_resolve_time" icon="clock">
    Predicted time when the resolution will become known.
  </Accordion>

  <Accordion title="actual_resolve_time" icon="check">
    Actual time when the resolution became known.
  </Accordion>

  <Accordion title="actual_close_time" icon="lock">
    Actual time when the question closed (minimum of `scheduled_close_time` and `actual_resolve_time`).
  </Accordion>

  <Accordion title="cp_reveal_time" icon="eye">
    Time when the community prediction becomes visible to forecasters.
  </Accordion>

  <Accordion title="spot_scoring_time" icon="bullseye">
    Time when spot scores are evaluated. Defaults to `cp_reveal_time` if not set.
  </Accordion>
</AccordionGroup>

## Resolution

Resolution is the process of determining the final outcome of a question.

### Resolution Values

The `resolution` field stores the outcome as a string (from `questions/models.py:88`):

* **Binary**: `"yes"` or `"no"` (or probability for ambiguous resolutions)
* **Multiple Choice**: The selected option text or index
* **Numeric/Date/Discrete**: The numeric value as a string
* **Unsuccessful resolutions**: `"ambiguous"` or `"annulled"` (from `questions/constants.py:4-6`)

### Resolution Criteria

Each question includes three key description fields (from `questions/models.py:116-119`):

1. **Description**: Background and context for the question
2. **Resolution Criteria**: Precise conditions that determine the outcome
3. **Fine Print**: Additional clarifications and edge cases

<Tip>
  Clear, unambiguous resolution criteria are essential for high-quality forecasting questions.
</Tip>

## Question Weights

Questions can have different weights for scoring purposes (from `questions/models.py:90`):

```python theme={null}
question_weight = models.FloatField(default=1.0)
```

A weight of `0` excludes the question from scoring entirely, while higher weights increase its contribution to leaderboards.

## Community Prediction (CP)

The community prediction aggregates all forecaster predictions into a single consensus forecast.

### Hidden Community Predictions

Questions can hide the CP until a specified time (from `questions/models.py:377-383`):

```python theme={null}
@property
def is_cp_hidden(self):
    return (
        not self.resolution  # always show cp when resolved
        and self.cp_reveal_time
        and self.cp_reveal_time > timezone.now()
    )
```

This prevents anchoring bias where forecasters might simply follow the crowd.

### Aggregation Methods

Metaculus supports multiple aggregation methods (from `questions/types.py:18-22`):

* **`recency_weighted`**: Recent forecasts weighted more heavily (default)
* **`unweighted`**: All forecasts weighted equally (better for short-term questions)
* **`single_aggregation`**: Single point-in-time aggregation
* **`metaculus_prediction`**: Proprietary Metaculus algorithm

## Advanced Features

### Group of Questions

Multiple related questions can be grouped together (from `questions/models.py:508-536`):

* Shared description and resolution criteria
* Fan graphs or multiple choice visualizations
* Subquestions can be manually ordered or sorted by CP

### Conditional Questions

Conditional questions split into two variants based on a condition (from `questions/models.py:486-505`):

* `condition`: The binary question that determines the path
* `question_yes`: Question resolved if condition is YES
* `question_no`: Question resolved if condition is NO

**Example**: "If Trump wins 2024, will GDP growth exceed 3%?" vs. "If Trump loses 2024, will GDP growth exceed 3%?"

## API Reference

<Card title="Questions API" icon="code" href="/api/questions">
  Explore the full Questions API documentation
</Card>

## Related Topics

<CardGroup cols={2}>
  <Card title="Forecasting" icon="chart-line" href="/features/forecasting">
    Learn how to make and update predictions
  </Card>

  <Card title="Scoring" icon="trophy" href="/features/scoring">
    Understand how forecasts are evaluated
  </Card>

  <Card title="Projects" icon="folder" href="/features/projects">
    Organize questions into collections
  </Card>

  <Card title="Tournaments" icon="medal" href="/features/tournaments">
    Compete in forecasting competitions
  </Card>
</CardGroup>