The spread was fine and the centre was not

# Self-authored for the EML case corpus (no external origin). A process's
# spread is half the width the specification allows, the capability index on
# spread reads a comfortable two, and the line signs off on it. Where the
# process sits inside that specification is computed below.
#
# The assessment is careful. The spread is the real, measured sigma; the
# specification width is the real one; the index is the standard spread-only
# capability, computed exactly; and the intent is exactly 'the process fits
# the spec'.
#
# The spread-only index compares widths and ignores where the process is
# centred, and this process runs three sigma off centre - so it fits the width
# with room to spare while one tail sits on the specification limit.

6 => spec_half_width
1 => process_sigma
3 => process_offset_from_centre

spec_half_width * 2 => spec_width
process_sigma * 6 => process_width_six_sigma
int(spec_width * 100 / process_width_six_sigma) => cp_hundredths
spec_half_width - process_offset_from_centre => room_on_the_near_side
int(room_on_the_near_side * 100 / (process_sigma * 3)) => cpk_hundredths
cp_hundredths - cpk_hundredths => capability_lost_to_offset_hundredths
1350 => defects_per_million_at_three_sigma_one_sided
0 => defects_per_million_the_spread_index_implies

"specification                   : plus or minus " + str(spec_half_width) + ", width " + str(spec_width) ^0
"process sigma                   : " + str(process_sigma) + ", six-sigma width " + str(process_width_six_sigma) ^0
"spread index (Cp)               : " + str(cp_hundredths) + " hundredths" ^0
"" ^0
"process centre                  : " + str(process_offset_from_centre) + " off the spec centre" ^0
"room on the near side           : " + str(room_on_the_near_side) + ", three sigma exactly" ^0
"centred index (Cpk)             : " + str(cpk_hundredths) + " hundredths" ^0
"capability lost to the offset   : " + str(capability_lost_to_offset_hundredths) + " hundredths" ^0
"defects per million, spread index implies : " + str(defects_per_million_the_spread_index_implies) ^0
"defects per million, actual      : " + str(defects_per_million_at_three_sigma_one_sided) ^0
"" ^0

# ---- what the assessment verified ----

"the capability sign-off" ^0
"  spread : the real measured sigma, " + str(process_sigma) ^0
"  spec width : the real " + str(spec_width) ^0
"  index : the standard spread-only Cp, exactly " + str(cp_hundredths) + " hundredths" ^0
"  intent : the process fits the spec" ^0
"  arithmetic errors : 0" ^0
"  verdict : CP OF TWO, TWICE THE CAPABILITY NEEDED" ^0
"" ^0
"  computing the spread index exactly from real widths is" ^0
"  the part done right here, and it is why the process" ^0
"  really is narrow enough" ^0
"" ^0

# ---- where the process sits ----

"width and position" ^0
"  what Cp compares : the spec's width to the process's width" ^0
"  what Cp ignores : where inside the spec the process sits" ^0
"  this process : narrow, and " + str(process_offset_from_centre) + " sigma to one side" ^0
"  the near limit : " + str(room_on_the_near_side) + " away, three sigma, so " + str(defects_per_million_at_three_sigma_one_sided) + " per" ^0
"    million spill over it" ^0
"  Cpk, which looks at position : " + str(cpk_hundredths) + " hundredths - half of Cp" ^0
"" ^0

# ---- what the customer got ----

"the parts" ^0
"  defects implied by the sign-off : " + str(defects_per_million_the_spread_index_implies) + " per million" ^0
"  defects actually made : " + str(defects_per_million_at_three_sigma_one_sided) + " per million" ^0
"  is Cp miscomputed : no; the spread really is that good" ^0
"  is a narrow process a well-placed one : no; it can be" ^0
"    narrow and parked against a wall" ^0
"" ^0

# ---- null control ----

# The same process centred on the specification (offset zero), where Cp and
# Cpk agree and the spread-only index would have been honest.
100 => nc_cpk_hundredths_three_sigma_off_centre
200 => nc_cpk_hundredths_when_centred
100 => nc_capability_the_centring_recovers_hundredths

"null control - centre the process, or read Cpk" ^0
"  Cpk, three sigma off centre : " + str(nc_cpk_hundredths_three_sigma_off_centre) + " hundredths" ^0
"  Cpk, centred : " + str(nc_cpk_hundredths_when_centred) + " hundredths, equal to Cp" ^0
"  capability the centring recovers : " + str(nc_capability_the_centring_recovers_hundredths) + " hundredths" ^0
"  no spread and no spec changed; the index stopped ignoring" ^0
"  where the process stands" ^0
"" ^0

# ---- the rule ----

"what a spread-only capability index of two guarantees" ^0
"  the process is half as wide as the spec : exactly, real" ^0
"    sigma, real width" ^0
"  the process fits inside the spec : not addressed; it runs" ^0
"    " + str(process_offset_from_centre) + " sigma off centre with one tail on the limit, so Cpk is" ^0
"    " + str(cpk_hundredths) + " hundredths and " + str(defects_per_million_at_three_sigma_one_sided) + " per million are out of spec" ^0
"" ^0

"fitting is a matter of width and of place, and an index of width alone" ^0
"certifies that the process could fit; whether it does depends on where it" ^0
"stands, and a narrow process pressed against one limit spills over it as" ^0
"surely as a wide one" ^0
"" ^0

"The spread index is exactly right - the process is half as wide as the spec." ^0
"But it runs " + str(process_offset_from_centre) + " sigma off centre, one tail on the limit: Cpk is " + str(cpk_hundredths) + " hundredths" ^0
"against Cp's " + str(cp_hundredths) + ", and " + str(defects_per_million_at_three_sigma_one_sided) + " parts per million are out of spec where the sign-off" ^0
"implied " + str(defects_per_million_the_spread_index_implies) + ", until the process is centred or the centred index is read." ^0

spec_half_width = 6
process_sigma = 1
process_offset_from_centre = 3
spec_width = spec_half_width * 2
process_width_six_sigma = process_sigma * 6
cp_hundredths = int(spec_width * 100 / process_width_six_sigma)
room_on_the_near_side = spec_half_width - process_offset_from_centre
cpk_hundredths = int(room_on_the_near_side * 100 / (process_sigma * 3))
capability_lost_to_offset_hundredths = cp_hundredths - cpk_hundredths
defects_per_million_at_three_sigma_one_sided = 1350
defects_per_million_the_spread_index_implies = 0
print("specification                   : plus or minus " + str(spec_half_width) + ", width " + str(spec_width))
print("process sigma                   : " + str(process_sigma) + ", six-sigma width " + str(process_width_six_sigma))
print("spread index (Cp)               : " + str(cp_hundredths) + " hundredths")
print("")
print("process centre                  : " + str(process_offset_from_centre) + " off the spec centre")
print("room on the near side           : " + str(room_on_the_near_side) + ", three sigma exactly")
print("centred index (Cpk)             : " + str(cpk_hundredths) + " hundredths")
print("capability lost to the offset   : " + str(capability_lost_to_offset_hundredths) + " hundredths")
print("defects per million, spread index implies : " + str(defects_per_million_the_spread_index_implies))
print("defects per million, actual      : " + str(defects_per_million_at_three_sigma_one_sided))
print("")
print("the capability sign-off")
print("  spread : the real measured sigma, " + str(process_sigma))
print("  spec width : the real " + str(spec_width))
print("  index : the standard spread-only Cp, exactly " + str(cp_hundredths) + " hundredths")
print("  intent : the process fits the spec")
print("  arithmetic errors : 0")
print("  verdict : CP OF TWO, TWICE THE CAPABILITY NEEDED")
print("")
print("  computing the spread index exactly from real widths is")
print("  the part done right here, and it is why the process")
print("  really is narrow enough")
print("")
print("width and position")
print("  what Cp compares : the spec's width to the process's width")
print("  what Cp ignores : where inside the spec the process sits")
print("  this process : narrow, and " + str(process_offset_from_centre) + " sigma to one side")
print("  the near limit : " + str(room_on_the_near_side) + " away, three sigma, so " + str(defects_per_million_at_three_sigma_one_sided) + " per")
print("    million spill over it")
print("  Cpk, which looks at position : " + str(cpk_hundredths) + " hundredths - half of Cp")
print("")
print("the parts")
print("  defects implied by the sign-off : " + str(defects_per_million_the_spread_index_implies) + " per million")
print("  defects actually made : " + str(defects_per_million_at_three_sigma_one_sided) + " per million")
print("  is Cp miscomputed : no; the spread really is that good")
print("  is a narrow process a well-placed one : no; it can be")
print("    narrow and parked against a wall")
print("")
nc_cpk_hundredths_three_sigma_off_centre = 100
nc_cpk_hundredths_when_centred = 200
nc_capability_the_centring_recovers_hundredths = 100
print("null control - centre the process, or read Cpk")
print("  Cpk, three sigma off centre : " + str(nc_cpk_hundredths_three_sigma_off_centre) + " hundredths")
print("  Cpk, centred : " + str(nc_cpk_hundredths_when_centred) + " hundredths, equal to Cp")
print("  capability the centring recovers : " + str(nc_capability_the_centring_recovers_hundredths) + " hundredths")
print("  no spread and no spec changed; the index stopped ignoring")
print("  where the process stands")
print("")
print("what a spread-only capability index of two guarantees")
print("  the process is half as wide as the spec : exactly, real")
print("    sigma, real width")
print("  the process fits inside the spec : not addressed; it runs")
print("    " + str(process_offset_from_centre) + " sigma off centre with one tail on the limit, so Cpk is")
print("    " + str(cpk_hundredths) + " hundredths and " + str(defects_per_million_at_three_sigma_one_sided) + " per million are out of spec")
print("")
print("fitting is a matter of width and of place, and an index of width alone")
print("certifies that the process could fit; whether it does depends on where it")
print("stands, and a narrow process pressed against one limit spills over it as")
print("surely as a wide one")
print("")
print("The spread index is exactly right - the process is half as wide as the spec.")
print("But it runs " + str(process_offset_from_centre) + " sigma off centre, one tail on the limit: Cpk is " + str(cpk_hundredths) + " hundredths")
print("against Cp's " + str(cp_hundredths) + ", and " + str(defects_per_million_at_three_sigma_one_sided) + " parts per million are out of spec where the sign-off")
print("implied " + str(defects_per_million_the_spread_index_implies) + ", until the process is centred or the centred index is read.")

specification                   : plus or minus 6, width 12
process sigma                   : 1, six-sigma width 6
spread index (Cp)               : 200 hundredths

process centre                  : 3 off the spec centre
room on the near side           : 3, three sigma exactly
centred index (Cpk)             : 100 hundredths
capability lost to the offset   : 100 hundredths
defects per million, spread index implies : 0
defects per million, actual      : 1350

the capability sign-off
  spread : the real measured sigma, 1
  spec width : the real 12
  index : the standard spread-only Cp, exactly 200 hundredths
  intent : the process fits the spec
  arithmetic errors : 0
  verdict : CP OF TWO, TWICE THE CAPABILITY NEEDED

  computing the spread index exactly from real widths is
  the part done right here, and it is why the process
  really is narrow enough

width and position
  what Cp compares : the spec's width to the process's width
  what Cp ignores : where inside the spec the process sits
  this process : narrow, and 3 sigma to one side
  the near limit : 3 away, three sigma, so 1350 per
    million spill over it
  Cpk, which looks at position : 100 hundredths - half of Cp

the parts
  defects implied by the sign-off : 0 per million
  defects actually made : 1350 per million
  is Cp miscomputed : no; the spread really is that good
  is a narrow process a well-placed one : no; it can be
    narrow and parked against a wall

null control - centre the process, or read Cpk
  Cpk, three sigma off centre : 100 hundredths
  Cpk, centred : 200 hundredths, equal to Cp
  capability the centring recovers : 100 hundredths
  no spread and no spec changed; the index stopped ignoring
  where the process stands

what a spread-only capability index of two guarantees
  the process is half as wide as the spec : exactly, real
    sigma, real width
  the process fits inside the spec : not addressed; it runs
    3 sigma off centre with one tail on the limit, so Cpk is
    100 hundredths and 1350 per million are out of spec

fitting is a matter of width and of place, and an index of width alone
certifies that the process could fit; whether it does depends on where it
stands, and a narrow process pressed against one limit spills over it as
surely as a wide one

The spread index is exactly right - the process is half as wide as the spec.
But it runs 3 sigma off centre, one tail on the limit: Cpk is 100 hundredths
against Cp's 200, and 1350 parts per million are out of spec where the sign-off
implied 0, until the process is centred or the centred index is read.

Trace event types