Dropping the loser kept its overhead

# Self-authored for the EML case corpus (no external origin). A company
# allocates its fixed overhead across three products in proportion to revenue,
# finds that product C shows a loss after its share, and drops it. The
# allocation is the standard method and every figure is real. What leaves with
# product C, and what stays, is computed below.
#
# The analysis is careful. Revenues and variable costs are real; the overhead is
# real and is allocated by the standard revenue-share method; C's allocated
# share is computed exactly; and the intent is exactly 'stop making the product
# that loses money'.
#
# Overhead allocated to a product does not leave with the product - only its
# revenue and variable cost do - so dropping C removes C's contribution and
# leaves C's share of the overhead for A and B to carry.

6000 => revenue_a
3000 => revenue_b
1000 => revenue_c
3000 => variable_cost_a
1800 => variable_cost_b
600 => variable_cost_c
4500 => fixed_overhead

revenue_a - variable_cost_a => contribution_a
revenue_b - variable_cost_b => contribution_b
revenue_c - variable_cost_c => contribution_c
contribution_a + contribution_b + contribution_c => contribution_total
revenue_a + revenue_b + revenue_c => revenue_total
int(fixed_overhead * revenue_c / revenue_total) => overhead_allocated_to_c
contribution_c - overhead_allocated_to_c => reported_profit_c
contribution_total - fixed_overhead => company_profit_with_c
contribution_total - contribution_c => contribution_without_c
contribution_without_c - fixed_overhead => company_profit_without_c
company_profit_with_c - company_profit_without_c => profit_lost_by_dropping_c

"revenue A / B / C               : " + str(revenue_a) + " / " + str(revenue_b) + " / " + str(revenue_c) ^0
"contribution A / B / C          : " + str(contribution_a) + " / " + str(contribution_b) + " / " + str(contribution_c) ^0
"fixed overhead                  : " + str(fixed_overhead) ^0
"overhead allocated to C         : " + str(overhead_allocated_to_c) + " (by revenue share)" ^0
"reported profit of C            : " + str(reported_profit_c) + ", a loss" ^0
"" ^0
"company profit with C           : " + str(company_profit_with_c) ^0
"company profit after dropping C : " + str(company_profit_without_c) ^0
"profit lost by dropping C       : " + str(profit_lost_by_dropping_c) ^0
"" ^0

# ---- what the analysis verified ----

"the product profitability report" ^0
"  revenues and variable costs : real" ^0
"  overhead : real, allocated by the standard revenue-share" ^0
"    method" ^0
"  C's share : computed exactly, " + str(overhead_allocated_to_c) ^0
"  intent : stop making the product that loses money" ^0
"  figures misstated : 0" ^0
"  verdict : C LOSES 50 AFTER OVERHEAD, DROP IT" ^0
"" ^0
"  allocating the real overhead by the standard method is" ^0
"  the part done right here, and it is why C's reported" ^0
"  figure is exactly what the method says" ^0
"" ^0

# ---- what leaves with C and what stays ----

"the drop" ^0
"  what C brought : " + str(revenue_c) + " of revenue against " + str(variable_cost_c) + " of variable cost," ^0
"    a contribution of " + str(contribution_c) ^0
"  what was charged to C : " + str(overhead_allocated_to_c) + " of overhead that exists" ^0
"    regardless of C" ^0
"  when C is dropped : the " + str(contribution_c) + " leaves; the " + str(overhead_allocated_to_c) + " stays" ^0
"  so the company : loses C's " + str(contribution_c) + " and saves nothing" ^0
"  and next quarter : B, now carrying more overhead, shows a" ^0
"    loss too" ^0
"" ^0

# ---- what the company got ----

"the result" ^0
"  profit before dropping C : " + str(company_profit_with_c) ^0
"  profit after : " + str(company_profit_without_c) ^0
"  is C's reported loss miscomputed : no; the allocation is" ^0
"    exact" ^0
"  was C losing the company money : no; C was covering " + str(contribution_c) ^0
"    of overhead that is now uncovered" ^0
"" ^0

# ---- null control ----

# The same decision made on contribution margin: drop a product only if its
# revenue fails to cover its own variable cost.
contribution_c - overhead_allocated_to_c => nc_c_judged_after_allocated_overhead
400 => nc_c_judged_by_contribution
0 => nc_products_dropped_by_contribution

"null control - judge products by contribution, not allocated overhead" ^0
"  C after allocated overhead : " + str(nc_c_judged_after_allocated_overhead) ^0
"  C by contribution : " + str(nc_c_judged_by_contribution) ^0
"  products dropped by contribution : " + str(nc_products_dropped_by_contribution) ^0
"  no revenue and no cost changed; the overhead stopped" ^0
"  being counted as something a product could take with it" ^0
"" ^0

# ---- the rule ----

"what an allocated-overhead product report guarantees" ^0
"  each product's share of overhead is the standard share :" ^0
"    exactly, real overhead, revenue-share method" ^0
"  a product showing a loss is losing the company money :" ^0
"    not addressed; the overhead stays when the product goes," ^0
"    so dropping C removes " + str(contribution_c) + " of contribution and no cost," ^0
"    taking company profit from " + str(company_profit_with_c) + " to " + str(company_profit_without_c) ^0
"" ^0

"a cost allocated to a thing is not a cost caused by it; when the thing is" ^0
"removed the allocation moves to its neighbours and the cost stays, so the" ^0
"product that looked like a loss was the one paying part of everybody's bill" ^0
"" ^0

"It allocates real overhead by the standard method and C reports " + str(reported_profit_c) + ". But" ^0
"the " + str(overhead_allocated_to_c) + " charged to C stays when C goes and C's " + str(contribution_c) + " of contribution leaves;" ^0
"company profit falls from " + str(company_profit_with_c) + " to " + str(company_profit_without_c) + ", " + str(profit_lost_by_dropping_c) + " lost by dropping the product that" ^0
"was paying part of the bill, until products are judged by contribution." ^0

revenue_a = 6000
revenue_b = 3000
revenue_c = 1000
variable_cost_a = 3000
variable_cost_b = 1800
variable_cost_c = 600
fixed_overhead = 4500
contribution_a = revenue_a - variable_cost_a
contribution_b = revenue_b - variable_cost_b
contribution_c = revenue_c - variable_cost_c
contribution_total = contribution_a + contribution_b + contribution_c
revenue_total = revenue_a + revenue_b + revenue_c
overhead_allocated_to_c = int(fixed_overhead * revenue_c / revenue_total)
reported_profit_c = contribution_c - overhead_allocated_to_c
company_profit_with_c = contribution_total - fixed_overhead
contribution_without_c = contribution_total - contribution_c
company_profit_without_c = contribution_without_c - fixed_overhead
profit_lost_by_dropping_c = company_profit_with_c - company_profit_without_c
print("revenue A / B / C               : " + str(revenue_a) + " / " + str(revenue_b) + " / " + str(revenue_c))
print("contribution A / B / C          : " + str(contribution_a) + " / " + str(contribution_b) + " / " + str(contribution_c))
print("fixed overhead                  : " + str(fixed_overhead))
print("overhead allocated to C         : " + str(overhead_allocated_to_c) + " (by revenue share)")
print("reported profit of C            : " + str(reported_profit_c) + ", a loss")
print("")
print("company profit with C           : " + str(company_profit_with_c))
print("company profit after dropping C : " + str(company_profit_without_c))
print("profit lost by dropping C       : " + str(profit_lost_by_dropping_c))
print("")
print("the product profitability report")
print("  revenues and variable costs : real")
print("  overhead : real, allocated by the standard revenue-share")
print("    method")
print("  C's share : computed exactly, " + str(overhead_allocated_to_c))
print("  intent : stop making the product that loses money")
print("  figures misstated : 0")
print("  verdict : C LOSES 50 AFTER OVERHEAD, DROP IT")
print("")
print("  allocating the real overhead by the standard method is")
print("  the part done right here, and it is why C's reported")
print("  figure is exactly what the method says")
print("")
print("the drop")
print("  what C brought : " + str(revenue_c) + " of revenue against " + str(variable_cost_c) + " of variable cost,")
print("    a contribution of " + str(contribution_c))
print("  what was charged to C : " + str(overhead_allocated_to_c) + " of overhead that exists")
print("    regardless of C")
print("  when C is dropped : the " + str(contribution_c) + " leaves; the " + str(overhead_allocated_to_c) + " stays")
print("  so the company : loses C's " + str(contribution_c) + " and saves nothing")
print("  and next quarter : B, now carrying more overhead, shows a")
print("    loss too")
print("")
print("the result")
print("  profit before dropping C : " + str(company_profit_with_c))
print("  profit after : " + str(company_profit_without_c))
print("  is C's reported loss miscomputed : no; the allocation is")
print("    exact")
print("  was C losing the company money : no; C was covering " + str(contribution_c))
print("    of overhead that is now uncovered")
print("")
nc_c_judged_after_allocated_overhead = contribution_c - overhead_allocated_to_c
nc_c_judged_by_contribution = 400
nc_products_dropped_by_contribution = 0
print("null control - judge products by contribution, not allocated overhead")
print("  C after allocated overhead : " + str(nc_c_judged_after_allocated_overhead))
print("  C by contribution : " + str(nc_c_judged_by_contribution))
print("  products dropped by contribution : " + str(nc_products_dropped_by_contribution))
print("  no revenue and no cost changed; the overhead stopped")
print("  being counted as something a product could take with it")
print("")
print("what an allocated-overhead product report guarantees")
print("  each product's share of overhead is the standard share :")
print("    exactly, real overhead, revenue-share method")
print("  a product showing a loss is losing the company money :")
print("    not addressed; the overhead stays when the product goes,")
print("    so dropping C removes " + str(contribution_c) + " of contribution and no cost,")
print("    taking company profit from " + str(company_profit_with_c) + " to " + str(company_profit_without_c))
print("")
print("a cost allocated to a thing is not a cost caused by it; when the thing is")
print("removed the allocation moves to its neighbours and the cost stays, so the")
print("product that looked like a loss was the one paying part of everybody's bill")
print("")
print("It allocates real overhead by the standard method and C reports " + str(reported_profit_c) + ". But")
print("the " + str(overhead_allocated_to_c) + " charged to C stays when C goes and C's " + str(contribution_c) + " of contribution leaves;")
print("company profit falls from " + str(company_profit_with_c) + " to " + str(company_profit_without_c) + ", " + str(profit_lost_by_dropping_c) + " lost by dropping the product that")
print("was paying part of the bill, until products are judged by contribution.")

revenue A / B / C               : 6000 / 3000 / 1000
contribution A / B / C          : 3000 / 1200 / 400
fixed overhead                  : 4500
overhead allocated to C         : 450 (by revenue share)
reported profit of C            : -50, a loss

company profit with C           : 100
company profit after dropping C : -300
profit lost by dropping C       : 400

the product profitability report
  revenues and variable costs : real
  overhead : real, allocated by the standard revenue-share
    method
  C's share : computed exactly, 450
  intent : stop making the product that loses money
  figures misstated : 0
  verdict : C LOSES 50 AFTER OVERHEAD, DROP IT

  allocating the real overhead by the standard method is
  the part done right here, and it is why C's reported
  figure is exactly what the method says

the drop
  what C brought : 1000 of revenue against 600 of variable cost,
    a contribution of 400
  what was charged to C : 450 of overhead that exists
    regardless of C
  when C is dropped : the 400 leaves; the 450 stays
  so the company : loses C's 400 and saves nothing
  and next quarter : B, now carrying more overhead, shows a
    loss too

the result
  profit before dropping C : 100
  profit after : -300
  is C's reported loss miscomputed : no; the allocation is
    exact
  was C losing the company money : no; C was covering 400
    of overhead that is now uncovered

null control - judge products by contribution, not allocated overhead
  C after allocated overhead : -50
  C by contribution : 400
  products dropped by contribution : 0
  no revenue and no cost changed; the overhead stopped
  being counted as something a product could take with it

what an allocated-overhead product report guarantees
  each product's share of overhead is the standard share :
    exactly, real overhead, revenue-share method
  a product showing a loss is losing the company money :
    not addressed; the overhead stays when the product goes,
    so dropping C removes 400 of contribution and no cost,
    taking company profit from 100 to -300

a cost allocated to a thing is not a cost caused by it; when the thing is
removed the allocation moves to its neighbours and the cost stays, so the
product that looked like a loss was the one paying part of everybody's bill

It allocates real overhead by the standard method and C reports -50. But
the 450 charged to C stays when C goes and C's 400 of contribution leaves;
company profit falls from 100 to -300, 400 lost by dropping the product that
was paying part of the bill, until products are judged by contribution.

Trace event types