Pricing Psychology Guide

import numpy as np
from typing import List, Dict

def bdm_mechanism(stated_wtp: float, price_range: tuple = (0, 50)) -> dict:
    """
    Becker-DeGroot-Marschak (BDM) incentive-compatible mechanism.
    Participants state WTP; random price drawn; buy if WTP >= price.
    Truthful reporting is the dominant strategy.
    """
    random_price = np.random.uniform(*price_range)
    purchase = stated_wtp >= random_price
    return {
        "stated_wtp": stated_wtp,
        "random_price": round(random_price, 2),
        "purchased": purchase,
        "payment": round(random_price, 2) if purchase else 0,
    }

def multiple_price_list(prices: List[float]) -> Dict:
    """
    Multiple Price List (MPL) method for WTP elicitation.
    Present a series of binary choices: buy at price X or keep money.
    WTP = switching point from "buy" to "keep money."
    """
    return {
        "instructions": (
            "For each price below, indicate whether you would buy "
            "the product at that price (one row will be randomly selected "
            "for real payment)."
        ),
        "choices": [
            {"price": p, "buy": None, "keep_money": None}
            for p in sorted(prices)
        ],
        "wtp_estimate": "Midpoint between last 'buy' and first 'keep money'",
    }

def van_westendorp_psm(
    too_cheap: List[float],
    cheap: List[float],
    expensive: List[float],
    too_expensive: List[float],
) -> dict:
    """
    Van Westendorp Price Sensitivity Meter.
    Four questions about price perception; intersections define optimal range.
    """
    # In practice, compute cumulative distributions and find intersection points
    return {
        "point_of_marginal_cheapness": "Intersection: too_cheap & expensive",
        "point_of_marginal_expensiveness": "Intersection: cheap & too_expensive",
        "optimal_price_point": "Intersection: too_cheap & too_expensive",
        "indifference_price_point": "Intersection: cheap & expensive",
    }

# Discrete Choice Experiment (DCE) for price research
# Standard method for decomposing preferences across attributes including price

design_example = {
    "attributes": {
        "brand": ["Brand A", "Brand B", "Brand C"],
        "features": ["Basic", "Standard", "Premium"],
        "price": ["$9.99", "$14.99", "$19.99", "$24.99"],
        "warranty": ["1 year", "3 years"],
    },
    "design": "D-optimal fractional factorial",
    "choice_sets": 12,       # Number of choice tasks per respondent
    "alternatives": 3,       # Options per choice set (+ no-purchase)
    "sample_size": 300,      # Respondents

    "analysis": "Mixed logit (random coefficients) for heterogeneity",
    "output": {
        "part_worths": "Utility contribution of each attribute level",
        "price_sensitivity": "Distribution of price coefficients",
        "wtp_for_features": "WTP = -beta_feature / beta_price",
        "optimal_price": "Price that maximizes share or revenue",
    },
}

import numpy as np
from scipy import stats

def estimate_price_elasticity(
    prices: np.ndarray,
    quantities: np.ndarray,
    method: str = "log-log",
) -> dict:
    """
    Estimate price elasticity of demand.

    Methods:
    - "log-log": ln(Q) = a + e*ln(P) + error (constant elasticity)
    - "arc": Midpoint elasticity between two points
    """
    if method == "log-log":
        log_p = np.log(prices)
        log_q = np.log(quantities)
        slope, intercept, r_value, p_value, std_err = stats.linregress(log_p, log_q)
        return {
            "elasticity": slope,
            "std_error": std_err,
            "r_squared": r_value ** 2,
            "p_value": p_value,
            "interpretation": (
                "elastic" if abs(slope) > 1
                else "unit elastic" if abs(slope) == 1
                else "inelastic"
            ),
        }
    elif method == "arc":
        # Midpoint method for discrete price changes
        elasticities = []
        for i in range(len(prices) - 1):
            pct_q = (quantities[i+1] - quantities[i]) / ((quantities[i+1] + quantities[i]) / 2)
            pct_p = (prices[i+1] - prices[i]) / ((prices[i+1] + prices[i]) / 2)
            if pct_p != 0:
                elasticities.append(pct_q / pct_p)
        return {
            "arc_elasticities": elasticities,
            "mean_elasticity": np.mean(elasticities),
        }

Pricing experiment design checklist:

1. INCENTIVE COMPATIBILITY
   [ ] Use BDM, Vickrey auction, or real purchase
   [ ] Never use hypothetical WTP without validation
   [ ] Endow participants with money to make purchases real

2. REFERENCE PRICE CONTROL
   [ ] Measure or manipulate reference prices
   [ ] Control for prior brand/product experience
   [ ] Randomize presentation order

3. DEMAND CHARACTERISTICS
   [ ] Blind participants to the pricing manipulation
   [ ] Include filler products to mask the focal comparison
   [ ] Use between-subjects design for price comparisons

4. ECOLOGICAL VALIDITY
   [ ] Use realistic product descriptions and images
   [ ] Set price ranges within the market range
   [ ] Include a "no purchase" option

5. ANALYSIS
   [ ] Pre-register hypotheses and analysis plan
   [ ] Report effect sizes and confidence intervals
   [ ] Test for heterogeneity across consumer segments
   [ ] Check for order effects and carryover