Bertrand Competition is a basic micro-economic model in which all firms set their own price, with each firm assuming the other competitors in the market will not change price.

Bertrand Competition can be contrasted with Cournot Competition in which firms first determine their own output capacity, then set price. See also the Market Simulation: MS-182 Cournot Competition.

Joseph Bertrand developed the Bertrand Competition Model in 1883. He argued that, because firms always have an incentive to cut price, the market will inevitably reach a point where all prices are reduced down to marginal cost, and all profitability is eliminated. Hence, Bertrand Competition is often associated with vicious “race to the bottom” Price Wars.

This version of the Bertrand Competition Model depends upon some specific assumptions:

1. There are at least two Competitors in the Market;
2. The Competitors cannot cooperate in any way;
3. Each Competitor sells the exact same Commodity Product;
4. Each Competitor can supply enough of the Product to satisfy the entire Market by itself;
5. All Customers have perfect knowledge of all Products and Prices in the Market;
6. Customers all have the same access to the Market (shipping costs are constant); and
7. Customers want to buy everything from the Competitor with the lowest Price.

Variations to this Bertrand Competition Model are explored in follow-on Market Simulations (find links at the bottom of this page). These variations relax the assumptions listed above, with the result that Competitors can set profitable prices.

This Case Study provides a high-level overview of the workflow without detailed explanation. It assumes you are already somewhat familiar with KNIME and Market Simulation. If not, start by reviewing the Building Blocks and Community Nodes.

Bertrand Competition requires at least two Competitors in the Market (otherwise a Monopoly Market would be the suitable model). Our two Competitors are:

1. Spacely Sprockets
2. Cogswell Cogs

Both Competitors sell an undifferentiated “Sprockets” Product.

A Product Generator node is used to define the Market comprising of these two Competitors. The Product that both Competitors offer has the single Feature ‘Sprockets’.

The Willingness To Pay (WTP) that Customers have for Sprockets is determined by the Customer Distributions node. In this case, Customers have a Mean WTP of $100 with a Standard Deviation (SD) of $50.

The Customer Distributions node also sets the Number of Customers in the Market to be 10,000. Each Customer in the Market is given an identification number, ranging from C00001 to C10000. A row-by-row comparison of the ‘Output WTP Matrix’ from the Product Generator node shows that each Customer considers both Products to be identical in value.

WTP Matrix

The Prices for both Competitors are set using ‘Flow Variables’. These Flow Variables can be used and modified by all the nodes in the Pricing Loop, so it is possible to run Price Experiments on several Prices and then select those Prices that yields the best result.

The most important Flow Variables are:

• Spacely_Price
• Cogswell_Price

The Bertrand Model will start with the initial Price of $150 for both Products. Each Loop Iteration will then adjust the Prices depending upon the expectations of both Spacely and Cogswell. Remember, both Competitors will change Price assuming that the other Competitor retains their old Price.

Additional Flow Variables are provided for Cost:

• Spacely_Cost
• Cogswell_Cost

These Cost Flow Variables are not used by the Pricing Loop but are provided for the benefit of the user (in case you want to experiment with how a Cost change could alter the results).

The ‘Price_Change_Percentage’ Flow Variable sets the size of the Price increase or decrease.

Five Price Experiments are run simultaneously:

1. Raise Spacely’s Price
2. Lower Spacely’s Price
3. No Price Change for either Product
4. Raise Cogswell’s Price
5. Lower Cogswell’s Price

As both Competitors expect the other to retain their old Price, there is no need to experiment with adjusting both Prices simultaneously.

The ‘Java Snippet’ nodes are used to change the Prices. When raising Price, the Java Snippet node will increase the old Price by the ‘Price_Change_Percentage’. When lowering Price, the Java Snippet node will decrease Price towards the Cost. This ensures that Price will never dip below Marginal Cost.

The ‘Simulate Market‘ node runs a single Market Simulation for each Price Experiment. The expected results for each Competitor are then collected together for comparison.

Note that the Bertrand Paradox was also explored in another Market Simulation:

• BB-113 Commodity Competitive Loop

In that Building Blocks Market Simulation, two ‘Profit Engine‘ nodes were used instead of five ‘Simulate Market‘ nodes. The two ‘Profit Engine’ nodes generated ‘Demand Curves’ to calculate the ‘Profit Maximizing Price’ for each Competitor.

The three Price Experiments relevant to Spacely Sprockets are:

1. Raise Spacely’s Price
2. No Price Change
3. Lower Spacely’s Price

Similarly, the three Price Experiments relevant to Cogswell Cogs are:

1. Raise Cogswell’s Price
2. No Price Change
3. Lower Cogswell’s Price

The expected results for Spacely (and Cogswell) are collected together for comparison. The ‘Sorter’ node will sort the results by the Pricing Strategy that yields the greatest Profit, and the ‘Row Filter’ node will select that Pricing Strategy as the Expected Result (again assuming that the Competitor will not change Price).

The selected Price adjustments from both Competitors are then collected together and passed back to the next iteration of the Pricing Loop.

Next Loop Iteration

After the 30 iterations of the Pricing Loop, the Price Strategy trends for both Competitors can be compared and plotted.

As predicted by Joseph Bertrand, both Competitors will wish to lower Price each iteration as both expect to capture the entire Market from the other. As a result, Price trends towards Marginal Cost, and Profit trends towards zero.

Chart #3
Profit