Monopólio e Discriminação de Preços

// Marginal Revenue: derivação formal
// Revenue: R = P × Q

// Se P = P(Q) (demanda), então:
// R = P(Q) × Q

// Derivando em respeito a Q:
// MR = dR/dQ = P + (dP/dQ) × Q

// Ou, multiplicando e dividindo por P:
// MR = P × [1 + (dP/dQ) × (Q/P)]

// Sabemos que elasticidade: ε = (dQ/dP) × (P/Q)
// Logo: (dP/dQ) × (Q/P) = 1/ε

// Portanto:
// MR = P × [1 + 1/ε]

// Em competição perfeita: ε = -∞
// → MR = P × [1 + 0] = P ✓

// Em monopólio: ε é finito (ex: ε = -2)
// → MR = P × [1 - 1/2] = P/2 < P ✓

console.log('=== MARGINAL REVENUE ANALYSIS ===');
console.log('Perfect Competition (ε = -∞): MR = P');
console.log('Monopoly (ε = -2): MR = 0.5P');
console.log('Monopoly (ε = -3): MR = 0.67P');
console.log('Monopoly (ε = -5): MR = 0.8P');

console.log('\nCONCLUSÃO: Quanto mais elástica a demanda,');
console.log('mais próximo MR está de P. Quanto mais inelástica,');
console.log('maior o efeito poisoning.');

// Exemplo: Monopolista com demanda linear e custo quadrático
class Monopolist {
  constructor() {
    // Demanda: Q = 24 - P → P = 24 - Q
    this.demandIntercept = 24;
    this.demandSlope = -1;

    // Custo: C = 12 + Q²
    this.fixedCost = 12;
    this.costCoefficient = 1;  // Q²
  }

  // Preço dado quantidade (curva de demanda)
  price(Q) {
    return this.demandIntercept + this.demandSlope * Q;
  }

  // Revenue
  revenue(Q) {
    return this.price(Q) * Q;
  }

  // Marginal Revenue
  marginalRevenue(Q) {
    // R = 24Q - Q² → MR = 24 - 2Q
    return 24 - 2 * Q;
  }

  // Custo
  cost(Q) {
    return this.fixedCost + this.costCoefficient * Math.pow(Q, 2);
  }

  // Marginal Cost
  marginalCost(Q) {
    // C = 12 + Q² → MC = 2Q
    return 2 * this.costCoefficient * Q;
  }

  // Average Cost
  averageCost(Q) {
    if (Q === 0) return Infinity;
    return this.cost(Q) / Q;
  }

  // Profit
  profit(Q) {
    return this.revenue(Q) - this.cost(Q);
  }

  // Encontrar Q* onde MR = MC
  profitMaximizingQuantity() {
    // MR = 24 - 2Q
    // MC = 2Q
    // 24 - 2Q = 2Q
    // 24 = 4Q
    // Q* = 6
    return 6;
  }

  // Análise completa
  analyze() {
    const Q_star = this.profitMaximizingQuantity();
    const P_star = this.price(Q_star);
    const MR_star = this.marginalRevenue(Q_star);
    const MC_star = this.marginalCost(Q_star);
    const profit_star = this.profit(Q_star);
    const AC_star = this.averageCost(Q_star);

    return {
      quantity: Q_star,
      price: P_star,
      marginalRevenue: MR_star,
      marginalCost: MC_star,
      averageCost: AC_star,
      profit: profit_star,
      profitPerUnit: P_star - AC_star,
    };
  }
}

const monopolist = new Monopolist();
const result = monopolist.analyze();

console.log('=== MONOPOLY PROFIT MAXIMIZATION ===\n');
console.log(`Optimal Quantity (Q*): ${result.quantity} units`);
console.log(`Optimal Price (P*): $${result.price}`);
console.log(`Marginal Revenue at Q*: $${result.marginalRevenue}`);
console.log(`Marginal Cost at Q*: $${result.marginalCost}`);
console.log(`Average Cost at Q*: $${result.averageCost.toFixed(2)}`);
console.log(`\nProfit per unit: $${result.profitPerUnit.toFixed(2)}`);
console.log(`Total Profit: $${result.profit}`);

// Por que não produzir 7 unidades?
const Q_7 = 7;
const profit_7 = monopolist.profit(Q_7);
console.log(`\n=== WHY NOT Q=7? ===`);
console.log(`Price at Q=7: $${monopolist.price(Q_7)}`);
console.log(`MC at Q=7: $${monopolist.marginalCost(Q_7)}`);
console.log(`Profit at Q=7: $${profit_7.toFixed(2)}`);
console.log(`Profit loss: $${(result.profit - profit_7).toFixed(2)}`);

console.log(`\nINSIGHT: Mesmo que P exceda MC na unidade 7, produzir 7`);
console.log(`reduz lucros porque o efeito poisoning (baixar preço em`);
console.log(`todas as 6 unidades anteriores) supera o ganho da 7ª unidade.`);

/*
OUTPUT:
=== MONOPOLY PROFIT MAXIMIZATION ===

Optimal Quantity (Q*): 6 units
Optimal Price (P*): $18
Marginal Revenue at Q*: $12
Marginal Cost at Q*: $12
Average Cost at Q*: $8.00

Profit per unit: $10.00
Total Profit: $60

=== WHY NOT Q=7? ===
Price at Q=7: $17
MC at Q=7: $14
Profit at Q=7: $58.00
Profit loss: $2.00

INSIGHT: Mesmo que P exceda MC na unidade 7, produzir 7
reduz lucros porque o efeito poisoning (baixar preço em
todas as 6 unidades anteriores) supera o ganho da 7ª unidade.
*/

// Market Power: relação entre elasticidade e markup
class MarketPower {
  constructor(epsilon, marginalCost) {
    this.epsilon = epsilon;  // Elasticidade (sempre negativo)
    this.MC = marginalCost;
  }

  // Markup: (P - MC) / P
  markup() {
    return -1 / this.epsilon;
  }

  // Preço de monopólio
  monopolyPrice() {
    // (P - MC)/P = -1/ε
    // P - MC = -P/ε
    // P(1 + 1/ε) = MC
    // P = MC / (1 + 1/ε)
    return this.MC / (1 + 1/this.epsilon);
  }

  // Profit margin
  profitMargin() {
    const P = this.monopolyPrice();
    return ((P - this.MC) / P) * 100;
  }
}

// Exemplo 1: Insulina (demanda muito inelástica)
const insulin = new MarketPower(-0.2, 10);  // ε = -0.2, MC = $10
console.log('=== INSULIN (Highly Inelastic) ===');
console.log(`Elasticity: ${insulin.epsilon}`);
console.log(`Markup: ${insulin.markup().toFixed(2)}`);
console.log(`Monopoly Price: $${insulin.monopolyPrice().toFixed(2)}`);
console.log(`Profit Margin: ${insulin.profitMargin().toFixed(1)}%\n`);

// Exemplo 2: Goma de mascar (demanda elástica)
const gum = new MarketPower(-5.0, 0.10);  // ε = -5.0, MC = $0.10
console.log('=== GUM (Elastic) ===');
console.log(`Elasticity: ${gum.epsilon}`);
console.log(`Markup: ${gum.markup().toFixed(2)}`);
console.log(`Monopoly Price: $${gum.monopolyPrice().toFixed(2)}`);
console.log(`Profit Margin: ${gum.profitMargin().toFixed(1)}%\n`);

// Exemplo 3: SaaS (demanda moderadamente elástica)
const saas = new MarketPower(-2.5, 20);  // ε = -2.5, MC = $20
console.log('=== SAAS PRODUCT (Moderate) ===');
console.log(`Elasticity: ${saas.epsilon}`);
console.log(`Markup: ${saas.markup().toFixed(2)}`);
console.log(`Monopoly Price: $${saas.monopolyPrice().toFixed(2)}`);
console.log(`Profit Margin: ${saas.profitMargin().toFixed(1)}%\n`);

/*
OUTPUT:
=== INSULIN (Highly Inelastic) ===
Elasticity: -0.2
Markup: 5.00
Monopoly Price: $12.50
Profit Margin: 20.0%

=== GUM (Elastic) ===
Elasticity: -5.0
Markup: 0.20
Monopoly Price: $0.12
Profit Margin: 20.0%

=== SAAS PRODUCT (Moderate) ===
Elasticity: -2.5
Markup: 0.40
Monopoly Price: $33.33
Profit Margin: 40.0%

LESSON: Monopolistas são disciplinados pela elasticidade de demanda.
Eles só podem cobrar alto quando demanda é inelástica (poucos substitutos).
*/

// Deadweight Loss: Welfare Analysis
class WelfareAnalysis {
  constructor() {
    // Mesma demanda e custo dos exemplos anteriores
    this.demandIntercept = 24;
    this.demandSlope = -1;
    this.fixedCost = 12;
    this.costCoefficient = 1;
  }

  price(Q) {
    return this.demandIntercept + this.demandSlope * Q;
  }

  marginalCost(Q) {
    return 2 * Q;
  }

  // Consumer Surplus: área abaixo da demanda, acima do preço
  consumerSurplus(Q, P) {
    // Triângulo: base × altura / 2
    // Base = Q, Altura = (demandIntercept - P)
    return (Q * (this.demandIntercept - P)) / 2;
  }

  // Producer Surplus: área acima do MC, abaixo do preço
  producerSurplus(Q, P) {
    // Área entre P e MC curve
    // Para MC = 2Q, PS = P*Q - integral(MC)
    // Integral de 2Q de 0 a Q = Q²
    return P * Q - Math.pow(Q, 2);
  }

  totalSurplus(Q, P) {
    return this.consumerSurplus(Q, P) + this.producerSurplus(Q, P);
  }

  // Equilíbrio competitivo: P = MC
  competitiveEquilibrium() {
    // P = 24 - Q, MC = 2Q
    // 24 - Q = 2Q → Q = 8
    const Q_c = 8;
    const P_c = this.price(Q_c);
    const CS_c = this.consumerSurplus(Q_c, P_c);
    const PS_c = this.producerSurplus(Q_c, P_c);
    const TS_c = this.totalSurplus(Q_c, P_c);

    return { Q: Q_c, P: P_c, CS: CS_c, PS: PS_c, TS: TS_c };
  }

  // Equilíbrio monopolístico: MR = MC
  monopolyEquilibrium() {
    // MR = 24 - 2Q, MC = 2Q
    // 24 - 2Q = 2Q → Q = 6
    const Q_m = 6;
    const P_m = this.price(Q_m);
    const CS_m = this.consumerSurplus(Q_m, P_m);
    const PS_m = this.producerSurplus(Q_m, P_m);
    const TS_m = this.totalSurplus(Q_m, P_m);

    return { Q: Q_m, P: P_m, CS: CS_m, PS: PS_m, TS: TS_m };
  }

  // Deadweight Loss
  deadweightLoss() {
    const comp = this.competitiveEquilibrium();
    const mono = this.monopolyEquilibrium();

    const DWL = comp.TS - mono.TS;
    const CS_loss = comp.CS - mono.CS;
    const PS_change = mono.PS - comp.PS;

    return {
      DWL,
      CS_loss,
      PS_change,
      transferFromConsumers: CS_loss - DWL, // Parte que virou PS
      efficiencyLoss: DWL, // C + E
    };
  }

  analyze() {
    const comp = this.competitiveEquilibrium();
    const mono = this.monopolyEquilibrium();
    const dwl = this.deadweightLoss();

    console.log('=== COMPETITIVE EQUILIBRIUM ===');
    console.log(`Quantity: ${comp.Q} units`);
    console.log(`Price: $${comp.P}`);
    console.log(`Consumer Surplus: $${comp.CS.toFixed(2)}`);
    console.log(`Producer Surplus: $${comp.PS.toFixed(2)}`);
    console.log(`Total Surplus: $${comp.TS.toFixed(2)}\n`);

    console.log('=== MONOPOLY EQUILIBRIUM ===');
    console.log(`Quantity: ${mono.Q} units`);
    console.log(`Price: $${mono.P}`);
    console.log(`Consumer Surplus: $${mono.CS.toFixed(2)}`);
    console.log(`Producer Surplus: $${mono.PS.toFixed(2)}`);
    console.log(`Total Surplus: $${mono.TS.toFixed(2)}\n`);

    console.log('=== WELFARE IMPACT ===');
    console.log(`CS Loss: $${dwl.CS_loss.toFixed(2)}`);
    console.log(`  → Transferred to PS: $${dwl.transferFromConsumers.toFixed(2)}`);
    console.log(`  → Lost to DWL: $${(dwl.CS_loss - dwl.transferFromConsumers).toFixed(2)}`);
    console.log(`PS Change: $${dwl.PS_change.toFixed(2)}`);
    console.log(`\n🔺 DEADWEIGHT LOSS: $${dwl.DWL.toFixed(2)}`);
    console.log(`   (${((dwl.DWL / comp.TS) * 100).toFixed(1)}% of competitive surplus)\n`);

    return { comp, mono, dwl };
  }
}

const welfare = new WelfareAnalysis();
welfare.analyze();

/*
OUTPUT:
=== COMPETITIVE EQUILIBRIUM ===
Quantity: 8 units
Price: $16
Consumer Surplus: $32.00
Producer Surplus: $64.00
Total Surplus: $96.00

=== MONOPOLY EQUILIBRIUM ===
Quantity: 6 units
Price: $18
Consumer Surplus: $18.00
Producer Surplus: $72.00
Total Surplus: $90.00

=== WELFARE IMPACT ===
CS Loss: $14.00
  → Transferred to PS: $8.00 (área B)
  → Lost to DWL: $6.00 (área C)
PS Change: $8.00

🔺 DEADWEIGHT LOSS: $6.00
   (6.3% of competitive surplus)

KEY INSIGHTS:
1. Consumidores perdem $14 no total
2. Produtores ganham $8 (área B transferida)
3. $6 é simplesmente PERDIDO (áreas C + E)
4. Há transações que fariam a sociedade melhor mas não acontecem
5. Monopoly cria market failure mesmo sem governo

PARADOXO: Unidades 7 e 8 têm WTP excedendo MC, mas não são vendidas!
*/

// Perfect Price Discrimination
class PerfectPriceDiscrimination {
  constructor() {
    this.demandIntercept = 24;
    this.demandSlope = -1;
  }

  // WTP do consumidor n (onde n = 1, 2, 3, ...)
  willingnessToPay(n) {
    return this.demandIntercept - n + 1;
  }

  marginalCost(Q) {
    return 2 * Q;
  }

  // Monopolista vende até WTP = MC
  optimalQuantity() {
    // WTP do consumidor Q: 24 - Q + 1 = 25 - Q
    // MC: 2Q
    // 25 - Q = 2Q → 3Q = 25 → Q ≈ 8.33
    // Como só vendemos unidades inteiras, Q = 8
    return 8;
  }

  // Revenue total vendendo Q unidades
  totalRevenue(Q) {
    let revenue = 0;
    for (let n = 1; n <= Q; n++) {
      revenue += this.willingnessToPay(n);
    }
    return revenue;
  }

  // Total cost
  totalCost(Q) {
    return 12 + Math.pow(Q, 2);
  }

  // Profit
  profit(Q) {
    return this.totalRevenue(Q) - this.totalCost(Q);
  }

  // Consumer Surplus (sempre zero!)
  consumerSurplus(Q) {
    return 0; // Cada um paga exatamente sua WTP
  }

  // Producer Surplus = todo o surplus
  producerSurplus(Q) {
    // PS = Revenue - Total Cost
    return this.profit(Q);
  }

  analyze() {
    const Q_ppd = this.optimalQuantity();
    const TR = this.totalRevenue(Q_ppd);
    const TC = this.totalCost(Q_ppd);
    const profit = this.profit(Q_ppd);
    const CS = this.consumerSurplus(Q_ppd);
    const PS = this.producerSurplus(Q_ppd);
    const TS = CS + PS;

    console.log('=== PERFECT PRICE DISCRIMINATION ===\n');
    console.log(`Quantity Sold: ${Q_ppd} units`);
    console.log(`(Mesma quantidade do equilíbrio competitivo!)\n`);

    console.log('Breakdown por consumidor:');
    for (let n = 1; n <= Q_ppd; n++) {
      const wtp = this.willingnessToPay(n);
      const mc = this.marginalCost(n);
      console.log(`  Consumidor ${n}: WTP = $${wtp}, paga $${wtp}, MC = $${mc.toFixed(2)}`);
    }

    console.log(`\nTotal Revenue: $${TR}`);
    console.log(`Total Cost: $${TC}`);
    console.log(`Profit: $${profit}\n`);

    console.log('=== SURPLUS DISTRIBUTION ===');
    console.log(`Consumer Surplus: $${CS} ❌`);
    console.log(`Producer Surplus: $${PS} ✅`);
    console.log(`Total Surplus: $${TS}\n`);

    console.log('=== COMPARAÇÃO ===');
    console.log('Perfect Competition: CS = $32, PS = $64, TS = $96');
    console.log('Monopoly (single price): CS = $18, PS = $72, TS = $90, DWL = $6');
    console.log(`Perfect Discrimination: CS = $0, PS = $${PS}, TS = $${TS}, DWL = $0\n`);

    return { Q: Q_ppd, TR, TC, profit, CS, PS, TS };
  }
}

const ppd = new PerfectPriceDiscrimination();
ppd.analyze();

/*
OUTPUT:
=== PERFECT PRICE DISCRIMINATION ===

Quantity Sold: 8 units
(Mesma quantidade do equilíbrio competitivo!)

Breakdown por consumidor:
  Consumidor 1: WTP = $24, paga $24, MC = $2.00
  Consumidor 2: WTP = $23, paga $23, MC = $4.00
  Consumidor 3: WTP = $22, paga $22, MC = $6.00
  Consumidor 4: WTP = $21, paga $21, MC = $8.00
  Consumidor 5: WTP = $20, paga $20, MC = $10.00
  Consumidor 6: WTP = $19, paga $19, MC = $12.00
  Consumidor 7: WTP = $18, paga $18, MC = $14.00
  Consumidor 8: WTP = $17, paga $17, MC = $16.00

Total Revenue: $164
Total Cost: $76
Profit: $88

=== SURPLUS DISTRIBUTION ===
Consumer Surplus: $0 ❌
Producer Surplus: $88 ✅
Total Surplus: $88

=== COMPARAÇÃO ===
Perfect Competition: CS = $32, PS = $64, TS = $96
Monopoly (single price): CS = $18, PS = $72, TS = $90, DWL = $6
Perfect Discrimination: CS = $0, PS = $88, TS = $88, DWL = $0

KEY INSIGHTS:
1. Não há DEADWEIGHT LOSS! (quantidade = competição perfeita)
2. Mas Consumer Surplus = $0 (monopolista captura tudo)
3. Efficiency sim, mas fairness zero
4. Monopolista ganha MAIS que com single price ($88 vs $72)
5. Por que? Sem efeito poisoning! Pode vender mais sem baixar preço
*/