equilibria-mcp-server 1.0.0

package/dist/templates/oligopoly.js

@@ -0,0 +1,1113 @@
+/**
+ * Oligopoly Templates
+ *
+ * Templates for oligopoly models including Cournot, Bertrand, Stackelberg,
+ * kinked demand, and monopolistic competition.
+ *
+ * Phase 3.5: Market Structures - Oligopoly
+ */
+// ============================================================================
+// PHASE 3.5: OLIGOPOLY
+// ============================================================================
+/**
+ * Cournot Duopoly
+ *
+ * Simultaneous quantity competition between two firms.
+ * Shows reaction functions and Nash equilibrium.
+ */
+const cournotDuopoly = {
+    id: 'cournot_duopoly',
+    name: 'Cournot Duopoly',
+    description: 'Simultaneous quantity competition. Each firm chooses output taking rival\'s output as given. Nash equilibrium at intersection of reaction functions.',
+    category: 'market_structures',
+    level: 'undergraduate',
+    tags: ['Cournot', 'oligopoly', 'quantity competition', 'reaction function', 'Nash equilibrium'],
+    parameters: {
+        demandIntercept: {
+            type: 'number',
+            default: 100,
+            min: 50,
+            max: 200,
+            description: 'Market demand intercept (a)',
+        },
+        demandSlope: {
+            type: 'number',
+            default: 1,
+            min: 0.5,
+            max: 3,
+            description: 'Market demand slope (b)',
+        },
+        mc1: {
+            type: 'number',
+            default: 10,
+            min: 0,
+            max: 40,
+            description: 'Firm 1 marginal cost',
+        },
+        mc2: {
+            type: 'number',
+            default: 10,
+            min: 0,
+            max: 40,
+            description: 'Firm 2 marginal cost',
+        },
+    },
+    generate: (params) => {
+        const a = params.demandIntercept ?? 100;
+        const b = params.demandSlope ?? 1;
+        const c1 = params.mc1 ?? 10;
+        const c2 = params.mc2 ?? 10;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Cournot Duopoly',
+                description: 'Simultaneous quantity competition',
+            },
+            parameters: {
+                a: { value: a, label: 'Demand Intercept', min: 50, max: 200 },
+                b: { value: b, label: 'Demand Slope', min: 0.5, max: 3, step: 0.1 },
+                c1: { value: c1, label: 'MC₁', min: 0, max: 40 },
+                c2: { value: c2, label: 'MC₂', min: 0, max: 40 },
+                // Reaction functions:
+                // q1 = (a - c1 - b*q2) / (2b) = (a - c1)/(2b) - q2/2
+                // q2 = (a - c2 - b*q1) / (2b) = (a - c2)/(2b) - q1/2
+                // Nash equilibrium (solving simultaneously):
+                // q1* = (a - 2c1 + c2) / (3b)
+                // q2* = (a - 2c2 + c1) / (3b)
+                q1_star: {
+                    expression: '(a - 2 * c1 + c2) / (3 * b)',
+                    label: 'q₁*',
+                    readonly: true,
+                },
+                q2_star: {
+                    expression: '(a - 2 * c2 + c1) / (3 * b)',
+                    label: 'q₂*',
+                    readonly: true,
+                },
+                // Total output and price
+                Q_star: { expression: 'q1_star + q2_star', label: 'Q*', readonly: true },
+                P_star: { expression: 'a - b * Q_star', label: 'P*', readonly: true },
+                // Profits
+                profit1: {
+                    expression: '(P_star - c1) * q1_star',
+                    label: 'π₁',
+                    readonly: true,
+                },
+                profit2: {
+                    expression: '(P_star - c2) * q2_star',
+                    label: 'π₂',
+                    readonly: true,
+                },
+                // Reaction function intercepts
+                rf1_intercept: { expression: '(a - c1) / (2 * b)', hidden: true },
+                rf2_intercept: { expression: '(a - c2) / (2 * b)', hidden: true },
+                // Monopoly output for comparison
+                q_monopoly: { expression: '(a - c1) / (2 * b)', hidden: true },
+                // Competitive output
+                q_comp: { expression: '(a - c1) / b', hidden: true },
+                // Chart bounds
+                chartMax: { expression: 'max(rf1_intercept, rf2_intercept) * 1.2', hidden: true },
+            },
+            charts: [
+                {
+                    id: 'reaction',
+                    title: 'Reaction Functions',
+                    xAxis: { label: 'Firm 1 Output (q₁)', min: 0, max: 'chartMax' },
+                    yAxis: { label: 'Firm 2 Output (q₂)', min: 0, max: 'chartMax' },
+                    elements: [
+                        // Firm 1 reaction function: q1 = (a-c1)/(2b) - q2/2
+                        // Rearranged as q2 in terms of q1: q2 = (a-c1)/b - 2*q1
+                        {
+                            id: 'rf1',
+                            type: 'line',
+                            equation: '(a - c1) / b - 2 * x',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            label: 'RF₁ (Firm 1 BR)',
+                            domain: { min: 0, max: 'rf1_intercept' },
+                        },
+                        // Firm 2 reaction function: q2 = (a-c2)/(2b) - q1/2
+                        {
+                            id: 'rf2',
+                            type: 'line',
+                            equation: '(a - c2) / (2 * b) - x / 2',
+                            color: '#DC2626',
+                            strokeWidth: 3,
+                            label: 'RF₂ (Firm 2 BR)',
+                            domain: { min: 0, max: '(a - c2) / b' },
+                        },
+                        // Nash equilibrium
+                        {
+                            id: 'nash',
+                            type: 'point',
+                            x: 'q1_star',
+                            y: 'q2_star',
+                            color: '#16A34A',
+                            size: 12,
+                            label: 'Nash Equilibrium',
+                            droplines: { x: true, y: true },
+                        },
+                        // 45-degree line (equal outputs)
+                        {
+                            id: 'equal-line',
+                            type: 'line',
+                            equation: 'x',
+                            color: '#9CA3AF',
+                            strokeWidth: 1,
+                            lineStyle: 'dotted',
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'nash-label',
+                            text: '(${q1_star:.1f}, ${q2_star:.1f})',
+                            x: 'q1_star + chartMax * 0.05',
+                            y: 'q2_star + chartMax * 0.05',
+                            color: '#16A34A',
+                        },
+                        {
+                            id: 'rf1-label',
+                            text: 'q₁ = (a-c₁)/2b - q₂/2',
+                            x: 'chartMax * 0.6',
+                            y: 'chartMax * 0.9',
+                            color: '#2563EB',
+                        },
+                        {
+                            id: 'rf2-label',
+                            text: 'q₂ = (a-c₂)/2b - q₁/2',
+                            x: 'chartMax * 0.6',
+                            y: 'chartMax * 0.8',
+                            color: '#DC2626',
+                        },
+                    ],
+                },
+                {
+                    id: 'market',
+                    title: 'Market Outcome',
+                    xAxis: { label: 'Total Quantity (Q)', min: 0, max: 'q_comp * 1.2' },
+                    yAxis: { label: 'Price', min: 0, max: 'a * 1.1' },
+                    elements: [
+                        // Demand curve
+                        {
+                            id: 'demand',
+                            type: 'line',
+                            equation: 'a - b * x',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            label: 'Market Demand',
+                            domain: { min: 0, max: 'a / b' },
+                        },
+                        // MC (average of both)
+                        {
+                            id: 'mc',
+                            type: 'horizontalLine',
+                            y: '(c1 + c2) / 2',
+                            color: '#DC2626',
+                            strokeWidth: 2,
+                            lineStyle: 'dashed',
+                            label: 'Avg MC',
+                        },
+                        // Cournot equilibrium
+                        {
+                            id: 'cournot-point',
+                            type: 'point',
+                            x: 'Q_star',
+                            y: 'P_star',
+                            color: '#16A34A',
+                            size: 10,
+                            label: 'Cournot',
+                            droplines: { x: true, y: true },
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'outcome',
+                            text: 'P* = $${P_star:.1f}, Q* = ${Q_star:.1f}',
+                            x: 'q_comp * 0.5',
+                            y: 'a * 0.9',
+                            color: '#16A34A',
+                        },
+                        {
+                            id: 'profits',
+                            text: 'π₁ = $${profit1:.0f}, π₂ = $${profit2:.0f}',
+                            x: 'q_comp * 0.5',
+                            y: 'a * 0.8',
+                            color: '#6B7280',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+/**
+ * Bertrand Duopoly
+ *
+ * Simultaneous price competition with homogeneous products.
+ * Results in competitive (marginal cost) pricing.
+ */
+const bertrandDuopoly = {
+    id: 'bertrand_duopoly',
+    name: 'Bertrand Duopoly',
+    description: 'Simultaneous price competition with identical products. In equilibrium, both firms price at marginal cost (competitive outcome). The "Bertrand paradox."',
+    category: 'market_structures',
+    level: 'undergraduate',
+    tags: ['Bertrand', 'oligopoly', 'price competition', 'Bertrand paradox'],
+    parameters: {
+        demandIntercept: {
+            type: 'number',
+            default: 100,
+            description: 'Market demand intercept',
+        },
+        demandSlope: {
+            type: 'number',
+            default: 1,
+            description: 'Market demand slope',
+        },
+        marginalCost: {
+            type: 'number',
+            default: 20,
+            description: 'Common marginal cost',
+        },
+        firm1Price: {
+            type: 'number',
+            default: 30,
+            description: 'Firm 1 price choice (for illustration)',
+        },
+    },
+    generate: (params) => {
+        const a = params.demandIntercept ?? 100;
+        const b = params.demandSlope ?? 1;
+        const MC = params.marginalCost ?? 20;
+        const p1 = params.firm1Price ?? 30;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Bertrand Duopoly',
+                description: 'Price competition with homogeneous products',
+            },
+            parameters: {
+                a: { value: a, label: 'Demand Intercept', min: 50, max: 200 },
+                b: { value: b, label: 'Demand Slope', min: 0.5, max: 3, step: 0.1 },
+                MC: { value: MC, label: 'Marginal Cost', min: 5, max: 50 },
+                p1: { value: p1, label: 'Firm 1 Price', min: 'MC', max: 'a' },
+                // Bertrand equilibrium: P1 = P2 = MC
+                P_star: { expression: 'MC', label: 'P* (equilibrium)', readonly: true },
+                // Total quantity at equilibrium
+                Q_star: { expression: '(a - MC) / b', label: 'Q*', readonly: true },
+                // Each firm gets half (symmetric)
+                q_each: { expression: 'Q_star / 2', label: 'q each', readonly: true },
+                // Zero profit in equilibrium
+                profit_eq: { value: 0, label: 'π* (each)', readonly: true },
+                // Compare to monopoly
+                P_monopoly: { expression: '(a + MC) / 2', label: 'P (monopoly)', readonly: true },
+                Q_monopoly: { expression: '(a - MC) / (2 * b)', hidden: true },
+                // What happens at p1 (illustration)
+                Q_at_p1: { expression: '(a - p1) / b', hidden: true },
+                profit_at_p1: {
+                    expression: '(p1 - MC) * Q_at_p1',
+                    label: 'π if monopolist',
+                    readonly: true,
+                },
+                // Chart bounds
+                chartMaxQ: { expression: 'Q_star * 1.3', hidden: true },
+                chartMaxP: { expression: 'a * 1.1', hidden: true },
+            },
+            charts: [
+                {
+                    id: 'undercutting',
+                    title: 'Bertrand Price Competition',
+                    xAxis: { label: 'Firm 1 Price (P₁)', min: 0, max: 'chartMaxP' },
+                    yAxis: { label: 'Firm 2 Best Response (P₂)', min: 0, max: 'chartMaxP' },
+                    elements: [
+                        // Firm 2 best response: undercut P1 if P1 > MC
+                        // At P1 = MC, indifferent between MC and not entering
+                        // For P1 > MC: BR is P2 = P1 - ε (just below P1)
+                        // This creates the "undercut" dynamic
+                        // 45-degree line (match price)
+                        {
+                            id: 'match-line',
+                            type: 'line',
+                            equation: 'x',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            label: 'Match Price (P₂ = P₁)',
+                            domain: { min: 'MC', max: 'chartMaxP' },
+                        },
+                        // MC horizontal
+                        {
+                            id: 'mc-line',
+                            type: 'horizontalLine',
+                            y: 'MC',
+                            color: '#DC2626',
+                            strokeWidth: 3,
+                            label: 'MC',
+                        },
+                        // MC vertical
+                        {
+                            id: 'mc-vertical',
+                            type: 'verticalLine',
+                            x: 'MC',
+                            color: '#DC2626',
+                            strokeWidth: 3,
+                        },
+                        // Nash equilibrium
+                        {
+                            id: 'nash',
+                            type: 'point',
+                            x: 'MC',
+                            y: 'MC',
+                            color: '#16A34A',
+                            size: 12,
+                            label: 'Nash: P₁ = P₂ = MC',
+                        },
+                        // Current p1 illustration
+                        {
+                            id: 'p1-point',
+                            type: 'point',
+                            x: 'p1',
+                            y: 'p1',
+                            color: '#7C3AED',
+                            label: 'If P₁ = ${p1}',
+                            droplines: { x: true, y: true },
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'undercutting-note',
+                            text: 'Any P > MC invites undercutting',
+                            x: 'chartMaxP * 0.5',
+                            y: 'chartMaxP * 0.8',
+                            color: '#6B7280',
+                        },
+                        {
+                            id: 'paradox',
+                            text: 'Bertrand Paradox: Only 2 firms → competitive price!',
+                            x: 'chartMaxP * 0.4',
+                            y: 'chartMaxP * 0.15',
+                            color: '#DC2626',
+                        },
+                    ],
+                },
+                {
+                    id: 'market',
+                    title: 'Market Outcome',
+                    xAxis: { label: 'Quantity (Q)', min: 0, max: 'chartMaxQ' },
+                    yAxis: { label: 'Price', min: 0, max: 'chartMaxP' },
+                    elements: [
+                        // Demand
+                        {
+                            id: 'demand',
+                            type: 'line',
+                            equation: 'a - b * x',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            label: 'Demand',
+                            domain: { min: 0, max: 'a / b' },
+                        },
+                        // MC
+                        {
+                            id: 'mc',
+                            type: 'horizontalLine',
+                            y: 'MC',
+                            color: '#DC2626',
+                            strokeWidth: 3,
+                            label: 'MC = P*',
+                        },
+                        // Bertrand equilibrium
+                        {
+                            id: 'bertrand-eq',
+                            type: 'point',
+                            x: 'Q_star',
+                            y: 'MC',
+                            color: '#16A34A',
+                            size: 10,
+                            label: 'Bertrand Eq.',
+                            droplines: { x: true, y: true },
+                        },
+                        // Monopoly point for comparison
+                        {
+                            id: 'monopoly-point',
+                            type: 'point',
+                            x: 'Q_monopoly',
+                            y: 'P_monopoly',
+                            color: '#9CA3AF',
+                            size: 6,
+                            label: 'Monopoly',
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'bertrand-result',
+                            text: 'P* = MC = $${MC}, Q* = ${Q_star:.0f}',
+                            x: 'chartMaxQ * 0.5',
+                            y: 'chartMaxP * 0.9',
+                            color: '#16A34A',
+                        },
+                        {
+                            id: 'zero-profit',
+                            text: 'π₁ = π₂ = 0 (competitive outcome)',
+                            x: 'chartMaxQ * 0.5',
+                            y: 'chartMaxP * 0.8',
+                            color: '#6B7280',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+/**
+ * Stackelberg Duopoly
+ *
+ * Sequential quantity competition with a first-mover (leader)
+ * and a follower. Leader has first-mover advantage.
+ */
+const stackelbergDuopoly = {
+    id: 'stackelberg_duopoly',
+    name: 'Stackelberg Duopoly',
+    description: 'Sequential quantity competition. Leader moves first, follower observes and responds. Leader has first-mover advantage and produces more than follower.',
+    category: 'market_structures',
+    level: 'undergraduate',
+    tags: ['Stackelberg', 'oligopoly', 'sequential game', 'first-mover advantage', 'leader-follower'],
+    parameters: {
+        demandIntercept: {
+            type: 'number',
+            default: 100,
+            description: 'Demand intercept',
+        },
+        demandSlope: {
+            type: 'number',
+            default: 1,
+            description: 'Demand slope',
+        },
+        marginalCost: {
+            type: 'number',
+            default: 10,
+            description: 'Common marginal cost',
+        },
+    },
+    generate: (params) => {
+        const a = params.demandIntercept ?? 100;
+        const b = params.demandSlope ?? 1;
+        const c = params.marginalCost ?? 10;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Stackelberg Duopoly',
+                description: 'Sequential quantity competition',
+            },
+            parameters: {
+                a: { value: a, label: 'Demand Intercept', min: 50, max: 200 },
+                b: { value: b, label: 'Demand Slope', min: 0.5, max: 3, step: 0.1 },
+                c: { value: c, label: 'Marginal Cost', min: 0, max: 40 },
+                // Follower's reaction function: q2 = (a - c)/(2b) - q1/2
+                // Leader maximizes: π1 = (a - b*(q1 + q2) - c) * q1
+                // Substituting follower's RF: q1* = (a - c) / (2b)
+                q_leader: {
+                    expression: '(a - c) / (2 * b)',
+                    label: 'q_L (leader)',
+                    readonly: true,
+                },
+                // Follower's response: q2 = (a-c)/(2b) - q1/2 = (a-c)/(4b)
+                q_follower: {
+                    expression: '(a - c) / (4 * b)',
+                    label: 'q_F (follower)',
+                    readonly: true,
+                },
+                // Total output
+                Q_stack: { expression: 'q_leader + q_follower', label: 'Q (total)', readonly: true },
+                // Price
+                P_stack: { expression: 'a - b * Q_stack', label: 'P*', readonly: true },
+                // Profits
+                profit_leader: {
+                    expression: '(P_stack - c) * q_leader',
+                    label: 'π_L',
+                    readonly: true,
+                },
+                profit_follower: {
+                    expression: '(P_stack - c) * q_follower',
+                    label: 'π_F',
+                    readonly: true,
+                },
+                // Cournot for comparison
+                q_cournot: { expression: '(a - c) / (3 * b)', hidden: true },
+                // Chart bounds
+                chartMax: { expression: '(a - c) / b * 0.7', hidden: true },
+            },
+            charts: [
+                {
+                    id: 'reaction',
+                    title: 'Stackelberg Equilibrium',
+                    xAxis: { label: 'Leader Output (q_L)', min: 0, max: 'chartMax' },
+                    yAxis: { label: 'Follower Output (q_F)', min: 0, max: 'chartMax' },
+                    elements: [
+                        // Follower's reaction function
+                        {
+                            id: 'rf-follower',
+                            type: 'line',
+                            equation: '(a - c) / (2 * b) - x / 2',
+                            color: '#DC2626',
+                            strokeWidth: 3,
+                            label: 'Follower RF',
+                            domain: { min: 0, max: '(a - c) / b' },
+                        },
+                        // Leader's isoprofit curves (higher profit toward origin)
+                        // π_L = (a - b*(q1 + q2) - c) * q1
+                        // For a given profit level π: q2 = (a-c)/b - q1 - π/(b*q1)
+                        {
+                            id: 'isoprofit-leader',
+                            type: 'line',
+                            equation: '(a - c) / b - x - profit_leader / (b * x)',
+                            color: '#2563EB',
+                            strokeWidth: 2,
+                            lineStyle: 'dashed',
+                            label: 'Leader Isoprofit',
+                            domain: { min: 'q_leader * 0.3', max: 'q_leader * 1.5' },
+                        },
+                        // Stackelberg equilibrium
+                        {
+                            id: 'stackelberg-eq',
+                            type: 'point',
+                            x: 'q_leader',
+                            y: 'q_follower',
+                            color: '#16A34A',
+                            size: 12,
+                            label: 'Stackelberg',
+                            droplines: { x: true, y: true },
+                        },
+                        // Cournot for comparison
+                        {
+                            id: 'cournot-eq',
+                            type: 'point',
+                            x: 'q_cournot',
+                            y: 'q_cournot',
+                            color: '#9CA3AF',
+                            size: 8,
+                            label: 'Cournot',
+                        },
+                        // 45-degree line
+                        {
+                            id: 'equal-line',
+                            type: 'line',
+                            equation: 'x',
+                            color: '#E5E7EB',
+                            strokeWidth: 1,
+                            lineStyle: 'dotted',
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'leader-advantage',
+                            text: 'Leader: ${q_leader:.1f} > Follower: ${q_follower:.1f}',
+                            x: 'chartMax * 0.5',
+                            y: 'chartMax * 0.9',
+                            color: '#16A34A',
+                        },
+                        {
+                            id: 'tangency',
+                            text: 'Tangency = optimal commitment',
+                            x: 'q_leader * 1.1',
+                            y: 'q_follower * 1.3',
+                            color: '#2563EB',
+                        },
+                    ],
+                },
+                {
+                    id: 'profit-compare',
+                    title: 'Profit Comparison',
+                    xAxis: { label: 'Firm', min: 0, max: 3 },
+                    yAxis: { label: 'Profit', min: 0, max: 'profit_leader * 1.5' },
+                    elements: [
+                        // Leader profit bar
+                        {
+                            id: 'leader-bar',
+                            type: 'rectangle',
+                            x1: 0.5,
+                            y1: 0,
+                            x2: 1.5,
+                            y2: 'profit_leader',
+                            fill: '#2563EB',
+                            opacity: 0.7,
+                        },
+                        // Follower profit bar
+                        {
+                            id: 'follower-bar',
+                            type: 'rectangle',
+                            x1: 1.5,
+                            y1: 0,
+                            x2: 2.5,
+                            y2: 'profit_follower',
+                            fill: '#DC2626',
+                            opacity: 0.7,
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'leader-label',
+                            text: 'Leader: $${profit_leader:.0f}',
+                            x: 1,
+                            y: 'profit_leader * 1.1',
+                            color: '#2563EB',
+                        },
+                        {
+                            id: 'follower-label',
+                            text: 'Follower: $${profit_follower:.0f}',
+                            x: 2,
+                            y: 'profit_follower * 1.1',
+                            color: '#DC2626',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+/**
+ * Kinked Demand Curve
+ *
+ * Oligopoly model explaining price rigidity through
+ * asymmetric responses to price changes.
+ */
+const kinkedDemand = {
+    id: 'kinked_demand_oligopoly',
+    name: 'Kinked Demand Curve',
+    description: 'Model explaining price rigidity in oligopoly. Rivals match price cuts but not increases, creating a kink in demand and discontinuity in MR.',
+    category: 'market_structures',
+    level: 'undergraduate',
+    tags: ['kinked demand', 'oligopoly', 'price rigidity', 'price stickiness'],
+    parameters: {
+        currentPrice: {
+            type: 'number',
+            default: 50,
+            description: 'Current (kinked) price',
+        },
+        currentQuantity: {
+            type: 'number',
+            default: 50,
+            description: 'Current quantity at kink',
+        },
+        elasticSlope: {
+            type: 'number',
+            default: 0.5,
+            description: 'Slope for price increases (more elastic)',
+        },
+        inelasticSlope: {
+            type: 'number',
+            default: 2,
+            description: 'Slope for price decreases (less elastic)',
+        },
+    },
+    generate: (params) => {
+        const P_kink = params.currentPrice ?? 50;
+        const Q_kink = params.currentQuantity ?? 50;
+        const b_up = params.elasticSlope ?? 0.5;
+        const b_down = params.inelasticSlope ?? 2;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Kinked Demand Curve',
+                description: 'Price rigidity in oligopoly',
+            },
+            parameters: {
+                P_kink: { value: P_kink, label: 'Current Price', min: 20, max: 100 },
+                Q_kink: { value: Q_kink, label: 'Current Quantity', min: 20, max: 100 },
+                b_up: { value: b_up, label: 'Elastic Slope', min: 0.2, max: 1, step: 0.1 },
+                b_down: { value: b_down, label: 'Inelastic Slope', min: 1, max: 4, step: 0.1 },
+                // Demand intercepts (solving P = a - bQ at kink point)
+                a_up: { expression: 'P_kink + b_up * Q_kink', hidden: true },
+                a_down: { expression: 'P_kink + b_down * Q_kink', hidden: true },
+                // MR discontinuity at kink
+                MR_upper: { expression: 'a_up - 2 * b_up * Q_kink', hidden: true },
+                MR_lower: { expression: 'a_down - 2 * b_down * Q_kink', hidden: true },
+                MR_gap: {
+                    expression: 'MR_upper - MR_lower',
+                    label: 'MR Gap',
+                    readonly: true,
+                },
+                // Chart bounds
+                chartMaxQ: { expression: 'Q_kink * 2', hidden: true },
+                chartMaxP: { expression: 'P_kink * 2', hidden: true },
+            },
+            charts: [
+                {
+                    id: 'main',
+                    title: 'Kinked Demand Curve',
+                    xAxis: { label: 'Quantity (Q)', min: 0, max: 'chartMaxQ' },
+                    yAxis: { label: 'Price', min: 0, max: 'chartMaxP' },
+                    elements: [
+                        // Upper demand segment (elastic - for price increases)
+                        {
+                            id: 'demand-upper',
+                            type: 'line',
+                            equation: 'a_up - b_up * x',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            label: 'Elastic (↑P → rivals don\'t follow)',
+                            domain: { min: 0, max: 'Q_kink' },
+                        },
+                        // Lower demand segment (inelastic - for price cuts)
+                        {
+                            id: 'demand-lower',
+                            type: 'line',
+                            equation: 'a_down - b_down * x',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            label: 'Inelastic (↓P → rivals match)',
+                            domain: { min: 'Q_kink', max: 'a_down / b_down' },
+                        },
+                        // Upper MR segment
+                        {
+                            id: 'mr-upper',
+                            type: 'line',
+                            equation: 'a_up - 2 * b_up * x',
+                            color: '#7C3AED',
+                            strokeWidth: 2,
+                            label: 'MR (upper)',
+                            domain: { min: 0, max: 'Q_kink' },
+                        },
+                        // Lower MR segment
+                        {
+                            id: 'mr-lower',
+                            type: 'line',
+                            equation: 'a_down - 2 * b_down * x',
+                            color: '#7C3AED',
+                            strokeWidth: 2,
+                            label: 'MR (lower)',
+                            domain: { min: 'Q_kink', max: 'a_down / (2 * b_down)' },
+                        },
+                        // MR gap (vertical discontinuity)
+                        {
+                            id: 'mr-gap',
+                            type: 'verticalLine',
+                            x: 'Q_kink',
+                            color: '#7C3AED',
+                            strokeWidth: 3,
+                            domain: { min: 'MR_lower', max: 'MR_upper' },
+                        },
+                        // Kink point
+                        {
+                            id: 'kink',
+                            type: 'point',
+                            x: 'Q_kink',
+                            y: 'P_kink',
+                            color: '#DC2626',
+                            size: 12,
+                            label: 'Kink',
+                            droplines: { x: true, y: true },
+                        },
+                        // Example MC in the gap (explaining price rigidity)
+                        {
+                            id: 'mc-example',
+                            type: 'horizontalLine',
+                            y: '(MR_upper + MR_lower) / 2',
+                            color: '#DC2626',
+                            strokeWidth: 2,
+                            lineStyle: 'dashed',
+                            label: 'MC (in gap)',
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'rigidity-label',
+                            text: 'MC can shift within gap',
+                            x: 'Q_kink * 1.3',
+                            y: '(MR_upper + MR_lower) / 2',
+                            color: '#DC2626',
+                        },
+                        {
+                            id: 'no-price-change',
+                            text: '→ Price stays at $${P_kink}',
+                            x: 'Q_kink * 1.3',
+                            y: '(MR_upper + MR_lower) / 2 - chartMaxP * 0.1',
+                            color: '#DC2626',
+                        },
+                        {
+                            id: 'gap-size',
+                            text: 'MR gap = $${MR_gap:.1f}',
+                            x: 'Q_kink + chartMaxQ * 0.05',
+                            y: 'MR_upper',
+                            color: '#7C3AED',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+/**
+ * Monopolistic Competition
+ *
+ * Market with many firms selling differentiated products.
+ * Shows short-run profit and long-run zero-profit tangency.
+ */
+const monopolisticCompetition = {
+    id: 'monopolistic_competition',
+    name: 'Monopolistic Competition',
+    description: 'Many firms with differentiated products. Short-run profits attract entry until long-run equilibrium where demand is tangent to ATC (zero profit).',
+    category: 'market_structures',
+    level: 'undergraduate',
+    tags: ['monopolistic competition', 'product differentiation', 'free entry', 'tangency'],
+    parameters: {
+        demandInterceptSR: {
+            type: 'number',
+            default: 100,
+            description: 'Short-run demand intercept',
+        },
+        demandSlope: {
+            type: 'number',
+            default: 2,
+            description: 'Demand slope',
+        },
+        minATC: {
+            type: 'number',
+            default: 30,
+            description: 'Minimum average total cost',
+        },
+        efficientScale: {
+            type: 'number',
+            default: 20,
+            description: 'Output at minimum ATC',
+        },
+        atcCurvature: {
+            type: 'number',
+            default: 0.05,
+            description: 'ATC curvature parameter',
+        },
+    },
+    generate: (params) => {
+        const a_sr = params.demandInterceptSR ?? 100;
+        const b = params.demandSlope ?? 2;
+        const minATC = params.minATC ?? 30;
+        const Q_eff = params.efficientScale ?? 20;
+        const c = params.atcCurvature ?? 0.05;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Monopolistic Competition',
+                description: 'Short-run and long-run equilibrium',
+            },
+            parameters: {
+                a_sr: { value: a_sr, label: 'SR Demand Intercept', min: 60, max: 150 },
+                b: { value: b, label: 'Demand Slope', min: 1, max: 5, step: 0.1 },
+                minATC: { value: minATC, label: 'Min ATC', min: 10, max: 60 },
+                Q_eff: { value: Q_eff, label: 'Efficient Scale', min: 10, max: 40 },
+                c: { value: c, label: 'ATC Curvature', min: 0.01, max: 0.1, step: 0.01 },
+                // ATC: minATC + c*(Q - Q_eff)²
+                // MC: derivative of TC = minATC + 2c*(Q - Q_eff) + 2*c*Q_eff (approximately)
+                // Short-run: MR = MC at Q_sr, then P_sr from demand
+                // For simplicity, calculate SR equilibrium numerically
+                Q_sr: { expression: '(a_sr - minATC) / (2 * b + 2 * c)', label: 'Q_SR', readonly: true },
+                P_sr: { expression: 'a_sr - b * Q_sr', label: 'P_SR', readonly: true },
+                ATC_sr: {
+                    expression: 'minATC + c * ((Q_sr - Q_eff) ^ 2)',
+                    label: 'ATC at Q_SR',
+                    readonly: true,
+                },
+                profit_sr: {
+                    expression: '(P_sr - ATC_sr) * Q_sr',
+                    label: 'SR Profit',
+                    readonly: true,
+                },
+                // Long-run: demand tangent to ATC at zero profit
+                // At tangency: slope of demand = slope of ATC
+                // -b = 2c(Q - Q_eff), and P = ATC
+                // Solving: Q_lr and then a_lr (new demand after entry)
+                Q_lr: { expression: 'Q_eff - b / (2 * c)', label: 'Q_LR', readonly: true },
+                P_lr: {
+                    expression: 'minATC + c * ((Q_lr - Q_eff) ^ 2)',
+                    label: 'P_LR',
+                    readonly: true,
+                },
+                a_lr: { expression: 'P_lr + b * Q_lr', hidden: true },
+                // Chart bounds
+                chartMaxQ: { expression: 'max(Q_sr, Q_eff) * 2', hidden: true },
+                chartMaxP: { expression: 'max(P_sr, a_sr) * 1.2', hidden: true },
+            },
+            charts: [
+                {
+                    id: 'short-run',
+                    title: 'Short-Run: Positive Profit',
+                    xAxis: { label: 'Quantity (q)', min: 0, max: 'chartMaxQ' },
+                    yAxis: { label: 'Price, Cost', min: 0, max: 'chartMaxP' },
+                    elements: [
+                        // Profit rectangle
+                        {
+                            id: 'profit-area',
+                            type: 'rectangle',
+                            x1: 0,
+                            y1: 'ATC_sr',
+                            x2: 'Q_sr',
+                            y2: 'P_sr',
+                            fill: '#22C55E',
+                            opacity: 0.3,
+                            label: 'Profit',
+                        },
+                        // Demand
+                        {
+                            id: 'demand-sr',
+                            type: 'line',
+                            equation: 'a_sr - b * x',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            label: 'Demand',
+                            domain: { min: 0, max: 'a_sr / b' },
+                        },
+                        // MR
+                        {
+                            id: 'mr-sr',
+                            type: 'line',
+                            equation: 'a_sr - 2 * b * x',
+                            color: '#7C3AED',
+                            strokeWidth: 2,
+                            label: 'MR',
+                            domain: { min: 0, max: 'a_sr / (2 * b)' },
+                        },
+                        // ATC
+                        {
+                            id: 'atc',
+                            type: 'line',
+                            equation: 'minATC + c * ((x - Q_eff) ^ 2)',
+                            color: '#16A34A',
+                            strokeWidth: 3,
+                            label: 'ATC',
+                            domain: { min: 1, max: 'chartMaxQ' },
+                        },
+                        // MC (approximate)
+                        {
+                            id: 'mc',
+                            type: 'line',
+                            equation: 'minATC + 2 * c * (x - Q_eff)',
+                            color: '#DC2626',
+                            strokeWidth: 2,
+                            label: 'MC',
+                            domain: { min: 'Q_eff * 0.3', max: 'chartMaxQ' },
+                        },
+                        // Optimal point
+                        {
+                            id: 'optimum-sr',
+                            type: 'point',
+                            x: 'Q_sr',
+                            y: 'P_sr',
+                            color: '#2563EB',
+                            size: 8,
+                            droplines: { x: true, y: true },
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'profit-label',
+                            text: 'π = $${profit_sr:.0f} → Entry',
+                            x: 'chartMaxQ * 0.6',
+                            y: 'chartMaxP * 0.9',
+                            color: '#16A34A',
+                        },
+                    ],
+                },
+                {
+                    id: 'long-run',
+                    title: 'Long-Run: Zero Profit (Tangency)',
+                    xAxis: { label: 'Quantity (q)', min: 0, max: 'chartMaxQ' },
+                    yAxis: { label: 'Price, Cost', min: 0, max: 'chartMaxP' },
+                    elements: [
+                        // LR Demand (shifted in from entry)
+                        {
+                            id: 'demand-lr',
+                            type: 'line',
+                            equation: 'a_lr - b * x',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            label: 'Demand (after entry)',
+                            domain: { min: 0, max: 'a_lr / b' },
+                        },
+                        // LR MR
+                        {
+                            id: 'mr-lr',
+                            type: 'line',
+                            equation: 'a_lr - 2 * b * x',
+                            color: '#7C3AED',
+                            strokeWidth: 2,
+                            label: 'MR',
+                            domain: { min: 0, max: 'a_lr / (2 * b)' },
+                        },
+                        // ATC
+                        {
+                            id: 'atc-lr',
+                            type: 'line',
+                            equation: 'minATC + c * ((x - Q_eff) ^ 2)',
+                            color: '#16A34A',
+                            strokeWidth: 3,
+                            label: 'ATC',
+                            domain: { min: 1, max: 'chartMaxQ' },
+                        },
+                        // MC
+                        {
+                            id: 'mc-lr',
+                            type: 'line',
+                            equation: 'minATC + 2 * c * (x - Q_eff)',
+                            color: '#DC2626',
+                            strokeWidth: 2,
+                            label: 'MC',
+                            domain: { min: 'Q_eff * 0.3', max: 'chartMaxQ' },
+                        },
+                        // Tangency point
+                        {
+                            id: 'tangency',
+                            type: 'point',
+                            x: 'Q_lr',
+                            y: 'P_lr',
+                            color: '#16A34A',
+                            size: 12,
+                            label: 'Tangency (π = 0)',
+                            droplines: { x: true, y: true },
+                        },
+                        // Efficient scale marker
+                        {
+                            id: 'efficient-point',
+                            type: 'point',
+                            x: 'Q_eff',
+                            y: 'minATC',
+                            color: '#9CA3AF',
+                            size: 6,
+                            label: 'Min ATC',
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'zero-profit',
+                            text: 'P = ATC → π = 0',
+                            x: 'chartMaxQ * 0.6',
+                            y: 'chartMaxP * 0.9',
+                            color: '#16A34A',
+                        },
+                        {
+                            id: 'excess-capacity',
+                            text: 'Excess Capacity: Q_LR < Q_eff',
+                            x: 'chartMaxQ * 0.6',
+                            y: 'chartMaxP * 0.8',
+                            color: '#6B7280',
+                        },
+                        {
+                            id: 'markup',
+                            text: 'P > MC (markup over marginal cost)',
+                            x: 'chartMaxQ * 0.6',
+                            y: 'chartMaxP * 0.7',
+                            color: '#6B7280',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+// ============================================================================
+// EXPORTS
+// ============================================================================
+export const oligopolyTemplates = [
+    cournotDuopoly,
+    bertrandDuopoly,
+    stackelbergDuopoly,
+    kinkedDemand,
+    monopolisticCompetition,
+];
+//# sourceMappingURL=oligopoly.js.map