diff --git a/docs/free-threading_test/sudoku_thread_perf_comparison.py b/docs/free-threading_test/sudoku_thread_perf_comparison.py
new file mode 100644
index 0000000..fbb3478
--- /dev/null
+++ b/docs/free-threading_test/sudoku_thread_perf_comparison.py
@@ -0,0 +1,217 @@
+## Solve Every Sudoku Puzzle
+
+## See http://norvig.com/sudoku.html
+
+## Throughout this program we have:
+##   r is a row,    e.g. 'A'
+##   c is a column, e.g. '3'
+##   s is a square, e.g. 'A3'
+##   d is a digit,  e.g. '9'
+##   u is a unit,   e.g. ['A1','B1','C1','D1','E1','F1','G1','H1','I1']
+##   grid is a grid,e.g. 81 non-blank chars, e.g. starting with '.18...7...
+##   values is a dict of possible values, e.g. {'A1':'12349', 'A2':'8', ...}
+
+import os
+
+def cross(A, B):
+    "Cross product of elements in A and elements in B."
+    return [a+b for a in A for b in B]
+
+digits   = '123456789'
+rows     = 'ABCDEFGHI'
+cols     = digits
+squares  = cross(rows, cols)
+unitlist = ([cross(rows, c) for c in cols] +
+            [cross(r, cols) for r in rows] +
+            [cross(rs, cs) for rs in ('ABC','DEF','GHI') for cs in ('123','456','789')])
+units = dict((s, [u for u in unitlist if s in u])
+             for s in squares)
+peers = dict((s, set(sum(units[s],[]))-set([s]))
+             for s in squares)
+
+################ Unit Tests ################
+
+def test():
+    "A set of tests that must pass."
+    assert len(squares) == 81
+    assert len(unitlist) == 27
+    assert all(len(units[s]) == 3 for s in squares)
+    assert all(len(peers[s]) == 20 for s in squares)
+    assert units['C2'] == [['A2', 'B2', 'C2', 'D2', 'E2', 'F2', 'G2', 'H2', 'I2'],
+                           ['C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'C8', 'C9'],
+                           ['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']]
+    assert peers['C2'] == set(['A2', 'B2', 'D2', 'E2', 'F2', 'G2', 'H2', 'I2',
+                               'C1', 'C3', 'C4', 'C5', 'C6', 'C7', 'C8', 'C9',
+                               'A1', 'A3', 'B1', 'B3'])
+    print('All tests pass.')
+
+################ Parse a Grid ################
+
+def parse_grid(grid):
+    """Convert grid to a dict of possible values, {square: digits}, or
+    return False if a contradiction is detected."""
+    ## To start, every square can be any digit; then assign values from the grid.
+    values = dict((s, digits) for s in squares)
+    for s,d in list(grid_values(grid).items()):
+        if d in digits and not assign(values, s, d):
+            return False ## (Fail if we can't assign d to square s.)
+    return values
+
+def grid_values(grid):
+    "Convert grid into a dict of {square: char} with '0' or '.' for empties."
+    chars = [c for c in grid if c in digits or c in '0.']
+    assert len(chars) == 81
+    return dict(list(zip(squares, chars)))
+
+################ Constraint Propagation ################
+
+def assign(values, s, d):
+    """Eliminate all the other values (except d) from values[s] and propagate.
+    Return values, except return False if a contradiction is detected."""
+    other_values = values[s].replace(d, '')
+    if all(eliminate(values, s, d2) for d2 in other_values):
+        return values
+    else:
+        return False
+
+def eliminate(values, s, d):
+    """Eliminate d from values[s]; propagate when values or places <= 2.
+    Return values, except return False if a contradiction is detected."""
+    if d not in values[s]:
+        return values ## Already eliminated
+    values[s] = values[s].replace(d,'')
+    ## (1) If a square s is reduced to one value d2, then eliminate d2 from the peers.
+    if len(values[s]) == 0:
+        return False ## Contradiction: removed last value
+    elif len(values[s]) == 1:
+        d2 = values[s]
+        if not all(eliminate(values, s2, d2) for s2 in peers[s]):
+            return False
+    ## (2) If a unit u is reduced to only one place for a value d, then put it there.
+    for u in units[s]:
+        dplaces = [s for s in u if d in values[s]]
+        if len(dplaces) == 0:
+            return False ## Contradiction: no place for this value
+        elif len(dplaces) == 1:
+            # d can only be in one place in unit; assign it there
+            if not assign(values, dplaces[0], d):
+                return False
+    return values
+
+################ Display as 2-D grid ################
+
+def display(values):
+    "Display these values as a 2-D grid."
+    width = 1+max(len(values[s]) for s in squares)
+    line = '+'.join(['-'*(width*3)]*3)
+    for r in rows:
+        print(''.join(values[r+c].center(width)+('|' if c in '36' else '')
+                      for c in cols))
+        if r in 'CF': print(line)
+    print()
+
+################ Search ################
+
+def solve(grid): return search(parse_grid(grid))
+
+def search(values):
+    "Using depth-first search and propagation, try all possible values."
+    if values is False:
+        return False ## Failed earlier
+    if all(len(values[s]) == 1 for s in squares):
+        return values ## Solved!
+    ## Chose the unfilled square s with the fewest possibilities
+    n,s = min((len(values[s]), s) for s in squares if len(values[s]) > 1)
+    return some(search(assign(values.copy(), s, d))
+                for d in values[s])
+
+################ Utilities ################
+
+def some(seq):
+    "Return some element of seq that is true."
+    for e in seq:
+        if e: return e
+    return False
+
+def from_file(filename, sep='\n'):
+    "Parse a file into a list of strings, separated by sep."
+    with open(filename) as f:
+        return f.read().strip().split(sep)
+
+def shuffled(seq):
+    "Return a randomly shuffled copy of the input sequence."
+    seq = list(seq)
+    random.shuffle(seq)
+    return seq
+
+################ System test ################
+
+import time, random
+from concurrent.futures import ThreadPoolExecutor
+
+
+def solve_all(grids, name='', showif=0.0, nbthreads=1):
+    """Attempt to solve a sequence of grids. Report results.
+    When showif is a number of seconds, display puzzles that take longer.
+    When showif is None, don't display any puzzles."""
+    def time_solve(grid):
+        start = time.time()
+        values = solve(grid)
+        t = time.time()-start
+        ## Display puzzles that take long enough
+        if showif is not None and t > showif:
+            display(grid_values(grid))
+            if values: display(values)
+            print('(%.2f seconds)\n' % t)
+        return (t, solved(values))
+    with ThreadPoolExecutor(max_workers=nbthreads) as e:
+        times, results = zip(*e.map(time_solve, grids))
+    N = len(grids)
+    if N > 1:
+        print("Solved %d of %d %s puzzles (avg %.2f secs (%d Hz), max %.2f secs)." % (
+            sum(results), N, name, sum(times)/N, N/sum(times), max(times)))
+
+def solved(values):
+    "A puzzle is solved if each unit is a permutation of the digits 1 to 9."
+    def unitsolved(unit): return set(values[s] for s in unit) == set(digits)
+    return values is not False and all(unitsolved(unit) for unit in unitlist)
+
+def random_puzzle(N=17):
+    """Make a random puzzle with N or more assignments. Restart on contradictions.
+    Note the resulting puzzle is not guaranteed to be solvable, but empirically
+    about 99.8% of them are solvable. Some have multiple solutions."""
+    values = dict((s, digits) for s in squares)
+    for s in shuffled(squares):
+        if not assign(values, s, random.choice(values[s])):
+            break
+        ds = [values[s] for s in squares if len(values[s]) == 1]
+        if len(ds) >= N and len(set(ds)) >= 8:
+            return ''.join(values[s] if len(values[s])==1 else '.' for s in squares)
+    return random_puzzle(N) ## Give up and make a new puzzle
+
+grid1  = '003020600900305001001806400008102900700000008006708200002609500800203009005010300'
+grid2  = '4.....8.5.3..........7......2.....6.....8.4......1.......6.3.7.5..2.....1.4......'
+hard1  = '.....6....59.....82....8....45........3........6..3.54...325..6..................'
+hard2  = '8..........36......7..9.2...5...7.......457.....1...3...1....68..85...1..9....4..'    
+    
+if __name__ == '__main__':
+    test()
+    nbsudoku = 40
+    thread_list = ( 1, 2, 4, 8, 16)
+    print(f'there is {os.cpu_count()} logical processors, {os.cpu_count()/2} physical processors')
+    reference_delta = 0
+    for nbthreads in thread_list:
+        startall = time.time()
+        solve_all([hard2]*nbsudoku, "hard2", None, nbthreads=nbthreads)
+        new_delta = time.time()-startall
+        if reference_delta ==0 :
+           reference_delta = new_delta
+        ratio = reference_delta/(new_delta) 
+        print(f'solved {nbsudoku} tests with {nbthreads} threads in {new_delta:.2f} seconds, {ratio:.2f} speed-up' + '\n')
+
+
+## References used:
+## http://www.scanraid.com/BasicStrategies.htm
+## http://www.sudokudragon.com/sudokustrategy.htm
+## http://www.krazydad.com/blog/2005/09/29/an-index-of-sudoku-strategies/
+## http://www2.warwick.ac.uk/fac/sci/moac/currentstudents/peter_cock/python/sudoku/
diff --git a/docs/free-threading_test/sudoku_thread_perf_comparison_typed.py b/docs/free-threading_test/sudoku_thread_perf_comparison_typed.py
new file mode 100644
index 0000000..2b5b28d
--- /dev/null
+++ b/docs/free-threading_test/sudoku_thread_perf_comparison_typed.py
@@ -0,0 +1,239 @@
+## Solve Every Sudoku Puzzle
+
+## See http://norvig.com/sudoku.html 
+### tuned with modernised code from or https://github.com/norvig/pytudes/blob/main/ipynb/Sudoku.ipynb
+### executable at https://colab.research.google.com/github/norvig/pytudes/blob/main/ipynb/Sudoku.ipynb#scrollTo=h06tPIVW60Ll
+
+## Throughout this program we have:
+##   r is a row,    e.g. 'A'
+##   c is a column, e.g. '3'
+##   s is a square, e.g. 'A3'
+##   d is a digit,  e.g. '9'
+##   u is a unit,   e.g. ['A1','B1','C1','D1','E1','F1','G1','H1','I1']
+##   grid is a grid,e.g. 81 non-blank chars, e.g. starting with '.18...7...
+##   values is a dict of possible values, e.g. {'A1':'12349', 'A2':'8', ...}
+
+import os
+
+import re
+import time, random
+from concurrent.futures import ThreadPoolExecutor
+
+DigitSet = str  # e.g. '123'
+Square   = str  # e.g. 'A9'
+
+Picture  = str  # e.g. "53..7....6..195....98....6.8...6...34..8.3..17...2...6.6....28....419..5....8..79"
+Grid     = dict # E.g. {'A9': '123', ...}, a dict  of {Square: DigitSet}
+
+Fail     = Grid() # The empty Grid is used to indicate failure to find a solution
+
+def cross(A, B) -> tuple:
+    "Cross product of strings in A and strings in B."
+    return tuple(a + b for a in A for b in B)
+
+digits    = '123456789' # possible values in a square
+rows      = 'ABCDEFGHI' # row names
+cols      = digits      # column names (inversion from Excel where cols aer characters)
+squares   = cross(rows, cols) # all square coordinates : 'A1', 'B1', ... 'A2'...
+
+
+# a box = a group of 3x3 square (9 boxes of 9 squares in a sudoku)
+all_boxes = [cross(rs, cs)  for rs in ('ABC','DEF','GHI') for cs in ('123','456','789')]
+
+# all 27 group of contraints (9 columns of squares, 9 rows of squares , 9 boxes of squares)
+all_units = [cross(rows, c) for c in cols] + [cross(r, cols) for r in rows] + all_boxes
+
+# units[s] = group of constraints wher is a givean square 's'
+units     = {s: tuple(u for u in all_units if s in u) for s in squares}
+
+# peers[s] = the 20 squares that are in some unit of the square 's' (same columns, row or box)
+peers     = {s: set().union(*units[s]) - {s} for s in squares}
+
+def is_solution(solution: Grid, puzzle: Grid) -> bool:
+    "Is this proposed solution to the puzzle actually valid?"
+    return (solution is not Fail and
+            all(solution[s] == puzzle[s] for s in squares if len(puzzle[s]) == 1) and
+            all({solution[s] for s in unit} == set(digits) for unit in all_units))
+
+def parse(picture) -> Grid:
+    """Convert a Picture to a Grid."""
+    vals = re.findall(r"[.1-9]|[{][1-9]+[}]", picture)
+    assert len(vals) == 81
+    return {s: digits if v == '.' else re.sub(r"[{}]", '', v) 
+            for s, v in zip(squares, vals)}
+
+def picture(grid) -> Picture:
+    """Convert a Grid to a Picture."""
+    if grid is Fail: 
+        return "Fail"
+    def val(d: DigitSet) -> str: return '.' if d == digits else d if len(d) == 1 else '{' + d + '}'
+    width = max(len(val(grid[s])) for s in grid)
+    dash = '\n' + '+'.join(['-' * (width * 3 + 2)] * 3) + ' '
+    def cell(r, c): return val(grid[r + c]).center(width) + ('|'  if c in '36' else ' ')
+    def line(r): return ''.join(cell(r, c) for c in cols) + (dash if r in 'CF' else '')
+    return '\n'.join(map(line, rows))
+
+def fill(grid, s, d) -> Grid:
+    """Eliminate all the other digits (except d) from grid[s]."""
+    if grid[s] == d or all(eliminate(grid, s, d2) for d2 in grid[s] if d2 != d):
+        return grid
+    else:
+        return Fail
+
+def eliminate(grid, s, d) -> Grid:
+    """Eliminate d from grid[s]; implement the two constraint propagation strategies."""
+    if d not in grid[s]:
+        return grid        ## Already eliminated
+    grid[s] = grid[s].replace(d, '')
+    if not grid[s]:
+        return Fail        ## Fail: no legal digit left
+    elif len(grid[s]) == 1:
+        # 1. If a square has only one possible digit, then eliminate that digit from the square's peers.
+        d2 = grid[s]
+        if not all(eliminate(grid, s2, d2) for s2 in peers[s]):
+            return Fail    ## Fail: can't eliminate d2 from some square
+    for u in units[s]:
+        dplaces = [s for s in u if d in grid[s]]
+        # 2. If a unit has only one possible square that can hold a digit, then fill the square with the digit.
+        if not dplaces or (len(dplaces) == 1 and not fill(grid, dplaces[0], d)):
+            return Fail    ## Fail: no place in u for d
+    return grid
+
+def constrain(grid) -> Grid:
+    "Propagate constraints on a copy of grid to yield a new constrained Grid."
+    constrained: Grid = {s: digits for s in squares}
+    for s in grid:
+        d = grid[s]
+        if len(d) == 1:
+            fill(constrained, s, d)
+    return constrained
+
+def search(grid) -> Grid:
+    "Depth-first search with constraint propagation (`fill`) to find a solution."
+    if grid is Fail: 
+        return Fail
+    unfilled = [s for s in squares if len(grid[s]) > 1]
+    if not unfilled: 
+        return grid
+    s = min(unfilled, key=lambda s: len(grid[s]))
+    for d in grid[s]:
+        solution = search(fill(grid.copy(), s, d))
+        if solution:
+            return solution
+    return Fail
+
+
+def solve(puzzles, verbose=True) -> int:
+    "Solve and verify each puzzle, and if `verbose`, print puzzle and solution."
+    sep = '    '
+    for puzzle in puzzles:
+        solution = search(constrain(puzzle))
+        assert is_solution(solution, puzzle)
+        if verbose:
+            print('\nPuzzle            ', sep, 'Solution')
+            for p, s in zip(picture(puzzle).splitlines(), picture(solution).splitlines()):
+                print(p, sep, s)
+    return len(puzzles)
+
+
+def solve_all(puzzles, name, showif=0.0, nbthreads=1):
+    """Attempt to solve a sequence of grids. Report results.
+    When showif is a number of seconds, display puzzles that take longer.
+    When showif is None, don't display any puzzles."""
+    def time_solve(puzzle):
+        start = time.time()
+        solution = search(constrain(puzzle))
+        t = time.time()-start
+        ## Display puzzles that take long enough
+        if showif is not None and t > showif and is_solution(solution, puzzle):
+            print('\nPuzzle            ', sep, 'Solution')
+            for p, s in zip(picture(puzzle).splitlines(), picture(solution).splitlines()):
+                print(p, sep, s)
+            print('(%.2f seconds)\n' % t)
+        return (t, is_solution(solution, puzzle)==True )
+    with ThreadPoolExecutor(max_workers=nbthreads) as e:
+        times, results = zip(*e.map(time_solve, puzzles))
+    # without threading:
+    #    times, results = zip(*map(time_solve, puzzles))
+    N = len(puzzles)
+    if N > 1:
+        print("Solved %d of %d %s puzzles (avg %.2f secs (%d Hz), max %.2f secs)." % (
+            sum(results), N, name, sum(times)/N, N/sum(times), max(times)))
+
+def solved(values):
+    "A puzzle is solved if each unit is a permutation of the digits 1 to 9."
+    def unitsolved(unit): return set(values[s] for s in unit) == set(digits)
+    return values is not False and all(unitsolved(unit) for unit in unitlist)
+
+
+def unit_tests():
+    "A suite of unit tests."
+    assert len(squares) == 81
+    assert len(all_units) == 27
+    for s in squares:
+        assert len(units[s]) == 3
+        assert len(peers[s]) == 20
+    assert units['C2'] == (('A2', 'B2', 'C2', 'D2', 'E2', 'F2', 'G2', 'H2', 'I2'),
+                           ('C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'C8', 'C9'),
+                           ('A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3'))
+    assert peers['C2'] == {'A2', 'B2',       'D2', 'E2', 'F2', 'G2', 'H2', 'I2',
+                           'C1',       'C3', 'C4', 'C5', 'C6', 'C7', 'C8', 'C9',
+                           'A1', 'A3', 'B1', 'B3'}
+    return 'All tests pass.'
+
+def parse_grids(pictures):
+    """Parse an iterable of picture lines into a list of grids."""
+    return [parse(p) for p in pictures if p]
+
+def shuffled(seq):
+    "Return a randomly shuffled copy of the input sequence."
+    seq = list(seq)
+    random.shuffle(seq)
+    return seq
+
+def random_puzzle(N=17):
+    """Make a random puzzle with N or more assignments. Restart on contradictions.
+    Note the resulting puzzle is not guaranteed to be solvable, but empirically
+    about 99.8% of them are solvable. Some have multiple solutions."""
+    values = dict((s, digits) for s in squares)
+    for s in shuffled(squares):
+        if not assign(values, s, random.choice(values[s])):
+            break
+        ds = [values[s] for s in squares if len(values[s]) == 1]
+        if len(ds) >= N and len(set(ds)) >= 8:
+            return ''.join(values[s] if len(values[s])==1 else '.' for s in squares)
+    return random_puzzle(N) ## Give up and make a new puzzle
+
+grid1  = '003020600900305001001806400008102900700000008006708200002609500800203009005010300'
+grid2  = '4.....8.5.3..........7......2.....6.....8.4......1.......6.3.7.5..2.....1.4......'
+hard1  = '.....6....59.....82....8....45........3........6..3.54...325..6..................'
+hard2  = '8..........36......7..9.2...5...7.......457.....1...3...1....68..85...1..9....4..'    
+    
+if __name__ == '__main__':
+    unit_tests()
+    #grid1 = parse("53..7.... 6..195... .98....6. 8...6...3 4..8.3..1 7...2...6 .6....28. ...419..5 ....8..79")
+    #print(picture(grid1))
+    nbsudoku = 40
+    thread_list = ( 1, 2, 4, 8, 16)
+    print(f'there is {os.cpu_count()} logical processors, {os.cpu_count()/2} physical processors')
+    reference_delta = 0
+    my_puzzles = parse_grids([hard2]*nbsudoku)
+    for nbthreads in thread_list:
+        startall = time.time()
+        #hardest  = parse_grids(open('hardest.txt'))
+        #grids10k = parse_grids(open('sudoku10k.txt'))
+        #solve(puzzles=my_puzzles, verbose=False)
+        solve_all(puzzles=my_puzzles, name='hard2', showif=None, nbthreads=nbthreads) 
+        new_delta = time.time()-startall
+        if reference_delta ==0 :
+           reference_delta = new_delta
+        ratio = reference_delta/(new_delta) 
+        print(f'solved {nbsudoku} tests with {nbthreads} threads in {new_delta:.2f} seconds, {ratio:.2f} speed-up' + '\n')
+
+
+
+## References used:
+## http://www.scanraid.com/BasicStrategies.htm
+## http://www.sudokudragon.com/sudokustrategy.htm
+## http://www.krazydad.com/blog/2005/09/29/an-index-of-sudoku-strategies/
+## http://www2.warwick.ac.uk/fac/sci/moac/currentstudents/peter_cock/python/sudoku/
diff --git a/docs/pyomo/04.03-Job-Shop-Scheduling.ipynb b/docs/pyomo/04.03-Job-Shop-Scheduling.ipynb
new file mode 100644
index 0000000..3eead28
--- /dev/null
+++ b/docs/pyomo/04.03-Job-Shop-Scheduling.ipynb
@@ -0,0 +1,1480 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## from the excellent https://github.com/jckantor/ND-Pyomo-Cookbook"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "w4B3OoY-shn-",
+    "pycharm": {}
+   },
+   "source": [
+    "# Job Shop Scheduling\n",
+    "\n",
+    "Keywords: job shop, scheduling, cbc usage, neos usage, cplex, gdp, disjunctive programming, batch processes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "r4uB65VcPHBR",
+    "pycharm": {}
+   },
+   "source": [
+    "## Imports\n",
+    "\n",
+    "The following cell specifies the solver to used in the subsequent calculations. Some of these problems can become quite larger, and therefore the `gurobi` solver has been set as a default. If you don't have the `gurobi` solver then adjust the code to use the `glpk` solver, but know the calculations may take longer (and the benchmark problem will not solve at all). If you do have the `gurobi` solver, edit the location of the executable to match the location on your computer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 529,
+     "status": "ok",
+     "timestamp": 1603817900912,
+     "user": {
+      "displayName": "Jeffrey Kantor",
+      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gg_n8V7bVINy02QRuRgOoMo11Ri7NKU3OUKdC1bkQ=s64",
+      "userId": "09038942003589296665"
+     },
+     "user_tz": 240
+    },
+    "id": "eY36JajosjKK",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "%matplotlib inline\n",
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib as mpl\n",
+    "import pandas as pd\n",
+    "\n",
+    "import shutil\n",
+    "import sys\n",
+    "import os.path\n",
+    "\n",
+    "# not in WinPython\n",
+    "#if not shutil.which(\"pyomo\"):\n",
+    "#    !pip install -q pyomo\n",
+    "#    assert(shutil.which(\"pyomo\"))\n",
+    "\n",
+    "#if not (shutil.which(\"cbc\") or os.path.isfile(\"cbc\")):\n",
+    "#    if \"google.colab\" in sys.modules:\n",
+    "#        !apt-get install -y -qq coinor-cbc\n",
+    "#    else:\n",
+    "#        try:\n",
+    "#            !conda install -c conda-forge coincbc \n",
+    "#        except:\n",
+    "#            pass\n",
+    "#\n",
+    "#assert(shutil.which(\"cbc\") or os.path.isfile(\"cbc\"))\n",
+    "from pyomo.environ import *\n",
+    "from pyomo.gdp import *"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "lffHCSpHshoF",
+    "pycharm": {}
+   },
+   "source": [
+    "## Background\n",
+    "\n",
+    "A job shop consists of a set of distinct machines that process jobs. Each job is a series of tasks that require use of particular machines for known duration, and which must be completed in specified order. The job shop scheduling problem is to schedule the jobs on the machines to minimize the time necessary to process all jobs (i.e, the makespan) or some other metric of productivity. Job shop scheduling is one of the classic problems in Operations Research. \n",
+    "\n",
+    "Data consists of two tables. The first table is decomposition of the jobs into a series of tasks. Each task lists a job name, name of the required machine, and task duration. The second table list task pairs where the first task must be completed before the second task can be started. This formulation is quite general, but can also specify situations with no feasible solutions.  "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "N5nzDplWPHBV",
+    "pycharm": {}
+   },
+   "source": [
+    "## Job shop example\n",
+    "\n",
+    "The following example of a job shop is from from Christelle Gueret, Christian Prins, Marc Sevaux, \"Applications of Optimization with Xpress-MP,\" Dash Optimization, 2000.\n",
+    "\n",
+    "In this example, there are three printed paper products that must pass through color printing presses in a particular order. The given data consists of a flowsheet showing the order in which each job passes through the color presses\n",
+    "\n",
+    "![jobshopdiagram.jpg](https://github.com/jckantor/ND-Pyomo-Cookbook/blob/master/notebooks/figures/jobshopdiagram.jpg?raw=1)\n",
+    "\n",
+    "and a table of data showing, in minutes, the amount of time each job requires on each machine.\n",
+    "\n",
+    "| Machine | Color | Paper 1 | Paper 2 | Paper 3 |\n",
+    "| :-----: | :---: | :-----: | :-----: | :-----: |\n",
+    "| 1       | Blue  | 45      | 20      | 12      |\n",
+    "| 2       | Green | -       | 10      | 17      |\n",
+    "| 3       | Yellow| 10      | 34      | 28      |\n",
+    "\n",
+    "What is the minimum amount of time (i.e, what is the makespan) for this set of jobs?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "6aYVOOd7PHBV",
+    "pycharm": {}
+   },
+   "source": [
+    "## Task decomposition\n",
+    "\n",
+    "The first step in the analysis is to decompose the process into a series of tasks. Each task is a (job,machine) pair. Some tasks cannot start until a prerequisite task is completed.\n",
+    "\n",
+    "| Task (Job,Machine) | Duration | Prerequisite Task |\n",
+    "| :----------------: | :------: | :---------------: |\n",
+    "| (Paper 1, Blue)    | 45       | -                 |\n",
+    "| (Paper 1, Yellow)  | 10       | (Paper 1,Blue)    |\n",
+    "| (Paper 2, Blue)    | 20       | (Paper 2, Green)  |\n",
+    "| (Paper 2, Green)   | 10       | -                 |\n",
+    "| (Paper 2, Yellow)  | 34       | (Paper 2, Blue)   |\n",
+    "| (Paper 3, Blue)    | 12       | (Paper 3, Yellow) |\n",
+    "| (Paper 3, Green)   | 17       | (Paper 3, Blue)   |\n",
+    "| (Paper 3, Yellow)  | 28       | -                 |\n",
+    "\n",
+    "We convert this to a JSON style representation where tasks are denoted by (Job,Machine) tuples in Python. The task data is stored in a Python dictionary indexed by (Job,Machine) tuples. The task data conists of a dictionary with duration ('dur') and (Job,Machine) pair for any prerequisite task."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 666,
+     "status": "ok",
+     "timestamp": 1603817901060,
+     "user": {
+      "displayName": "Jeffrey Kantor",
+      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gg_n8V7bVINy02QRuRgOoMo11Ri7NKU3OUKdC1bkQ=s64",
+      "userId": "09038942003589296665"
+     },
+     "user_tz": 240
+    },
+    "id": "0k5vVxKIshoF",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "TASKS = {\n",
+    "    ('Paper_1','Blue')   : {'dur': 45, 'prec': None},\n",
+    "    ('Paper_1','Yellow') : {'dur': 10, 'prec': ('Paper_1','Blue')},\n",
+    "    ('Paper_2','Blue')   : {'dur': 20, 'prec': ('Paper_2','Green')},\n",
+    "    ('Paper_2','Green')  : {'dur': 10, 'prec': None},\n",
+    "    ('Paper_2','Yellow') : {'dur': 34, 'prec': ('Paper_2','Blue')},\n",
+    "    ('Paper_3','Blue')   : {'dur': 12, 'prec': ('Paper_3','Yellow')},\n",
+    "    ('Paper_3','Green')  : {'dur': 17, 'prec': ('Paper_3','Blue')},\n",
+    "    ('Paper_3','Yellow') : {'dur': 28, 'prec': None},   \n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "F4nmNpnhshoI",
+    "pycharm": {}
+   },
+   "source": [
+    "## Model formulation\n",
+    "\n",
+    "Each task is indexed by an ordered pair $(j,m)$ where $j$ is a job, and $m$ is a machine. Associated with each task is data describing the time needed to perform the task, and a preceding task that must be completed before the index task can start.\n",
+    "\n",
+    "| Parameter | Description |\n",
+    "| :-------- | :-----------|\n",
+    "| $\\text{dur}_{j,m}$ | Duration of task $(j,m)$ | \n",
+    "| $\\text{prec}_{j,m}$ | A task $(k,n) = \\text{prec}_{j,m}$ that must be completed before task $(j,m)$| \n",
+    "\n",
+    "The choice of decision variables for this problem are key to modeling. We introduce $makespan$ as the time needed to complete all tasks. $makespan$ is a candidate objective function. Variable $start_{j,m}$ denotes the time when task $(j,m)$ begins.  \n",
+    "\n",
+    "| Decision Variables | Description |\n",
+    "| :-------- | :-----------|\n",
+    "| $\\text{makespan}$  | Completion of all jobs | \n",
+    "| $\\text{start}_{j,m}$ | Start time for task $(j,m)$ |\n",
+    "\n",
+    "The constraints include lower bounda on the start and an upper bound on the completion of each task $(j,m)$\n",
+    "\n",
+    "$$\n",
+    "\\begin{align}\n",
+    "\\text{start}_{j,m} & \\geq 0\\\\\n",
+    "\\text{start}_{j,m}+\\text{dur}_{j,m} & \\leq \\text{makespan}\n",
+    "\\end{align}\n",
+    "$$\n",
+    "\n",
+    "Any preceding tasks must be completed before task $(j,m)$ can start.\n",
+    "\n",
+    "$$\n",
+    "\\begin{align}\n",
+    "\\text{start}_{k,n}+\\text{dur}_{k,n}\\leq\\text{start}_{j,m}\\ \\ \\ \\ \\text{for } (k,n) =\\text{prec}_{j,m}\n",
+    "\\end{align}\n",
+    "$$\n",
+    "\n",
+    "Finally, for every task performed on machine $m$, there can be no overlap among those tasks. This leads to a set of pair-wise disjunctive constraints for each machine.\n",
+    "\n",
+    "$$\n",
+    "\\begin{align}\n",
+    "\\left[\\text{start}_{j,m}+\\text{dur}_{j,m} \\leq \\text{start}_{k,m}\\right] \\vee \\left[\\text{start}_{k,m}+\\text{dur}_{k,m} \\leq \\text{start}_{j,m}\\right]\n",
+    "\\end{align}\n",
+    "$$\n",
+    "\n",
+    "avoids conflicts for use of the same machine. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "HdNWs72ZPHBY",
+    "pycharm": {}
+   },
+   "source": [
+    "## Pyomo implementation\n",
+    "\n",
+    "The job shop scheduling problem is implemented below in Pyomo. The implementation consists of of a function JobShopModel(TASKS) that accepts a dictionary of tasks and returns a Pyomo model. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 34
+    },
+    "executionInfo": {
+     "elapsed": 658,
+     "status": "ok",
+     "timestamp": 1603817901061,
+     "user": {
+      "displayName": "Jeffrey Kantor",
+      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gg_n8V7bVINy02QRuRgOoMo11Ri7NKU3OUKdC1bkQ=s64",
+      "userId": "09038942003589296665"
+     },
+     "user_tz": 240
+    },
+    "id": "2nJ72N-rshoI",
+    "outputId": "6786b332-59e7-4c44-83e1-1341657c5942",
+    "pycharm": {}
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<pyomo.core.base.PyomoModel.ConcreteModel at 0x7f8082e1a400>"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def jobshop_model(TASKS):\n",
+    "    \n",
+    "    model = ConcreteModel()\n",
+    "\n",
+    "    # tasks is a two dimensional set of (j,m) constructed from the dictionary keys\n",
+    "    model.TASKS = Set(initialize = TASKS.keys(), dimen=2)\n",
+    "    \n",
+    "    # the set of jobs is constructed from a python set\n",
+    "    model.JOBS = Set(initialize = list(set([j for (j,m) in model.TASKS])))\n",
+    "    \n",
+    "    # set of machines is constructed from a python set\n",
+    "    model.MACHINES = Set(initialize = list(set([m for (j,m) in model.TASKS])))\n",
+    "    \n",
+    "    # the order of tasks is constructed as a cross-product of tasks and filtering\n",
+    "    model.TASKORDER = Set(initialize = model.TASKS * model.TASKS, dimen=4, \n",
+    "        filter = lambda model, j, m, k, n: (k,n) == TASKS[(j,m)]['prec'])\n",
+    "    \n",
+    "    # the set of disjunctions is cross-product of jobs, jobs, and machines\n",
+    "    model.DISJUNCTIONS = Set(initialize = model.JOBS * model.JOBS * model.MACHINES, dimen=3,\n",
+    "        filter = lambda model, j, k, m: j < k and (j,m) in model.TASKS and (k,m) in model.TASKS)\n",
+    "    \n",
+    "    # load duration data into a model parameter for later access\n",
+    "    model.dur = Param(model.TASKS, initialize=lambda model, j, m: TASKS[(j,m)]['dur'])\n",
+    "\n",
+    "    # establish an upper bound on makespan\n",
+    "    ub = sum([model.dur[j, m] for (j,m) in model.TASKS])\n",
+    "    \n",
+    "    # create decision variables\n",
+    "    model.makespan = Var(bounds=(0, ub))\n",
+    "    model.start = Var(model.TASKS, bounds=(0, ub))\n",
+    "    \n",
+    "    model.objective = Objective(expr = model.makespan, sense = minimize)\n",
+    "\n",
+    "    model.finish = Constraint(model.TASKS, rule=lambda model, j, m:  \n",
+    "        model.start[j,m] + model.dur[j,m] <= model.makespan)\n",
+    "    \n",
+    "    model.preceding = Constraint(model.TASKORDER, rule=lambda model, j, m, k, n: \n",
+    "        model.start[k,n] + model.dur[k,n] <= model.start[j,m])\n",
+    "    \n",
+    "    model.disjunctions = Disjunction(model.DISJUNCTIONS, rule=lambda model,j,k,m:\n",
+    "        [model.start[j,m] + model.dur[j,m] <= model.start[k,m], \n",
+    "         model.start[k,m] + model.dur[k,m] <= model.start[j,m]])\n",
+    "    \n",
+    "    TransformationFactory('gdp.hull').apply_to(model)\n",
+    "    return model\n",
+    "\n",
+    "jobshop_model(TASKS)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# WinPython interlude, getting cbc from Pulp\n",
+    "import pulp\n",
+    "from pathlib import Path\n",
+    "import platform \n",
+    "plt = platform.system()\n",
+    "if plt == \"Windows\":# on linux:\n",
+    "    cbc_address = str(Path(pulp.__file__).parent/'solverdir'/'cbc'/'win'/'64'/'cbc.exe')\n",
+    "elif plt == \"Linux\":\n",
+    "    cbc_address = Path(pulp.__file__).parent/'solverdir'/'cbc'/'linux'/'64'/'cbc'\n",
+    "else:\n",
+    "    cbc_address = Path(pulp.__file__).parent/'solverdir'/'cbc'/'osx'/'64'/'cbc'\n",
+    "# print(cbc_address)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# WinPython interlude, using this below instead of official address\n",
+    "solvername = 'cbc'\n",
+    "solverexe = cbc_address\n",
+    "solverx=SolverFactory(solvername,executable=solverexe)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 697
+    },
+    "executionInfo": {
+     "elapsed": 1025,
+     "status": "ok",
+     "timestamp": 1603817901438,
+     "user": {
+      "displayName": "Jeffrey Kantor",
+      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gg_n8V7bVINy02QRuRgOoMo11Ri7NKU3OUKdC1bkQ=s64",
+      "userId": "09038942003589296665"
+     },
+     "user_tz": 240
+    },
+    "id": "VtQDkBmBPHBc",
+    "outputId": "649f46f0-31f8-4113-e667-858fee72a315",
+    "pycharm": {}
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[{'Job': 'Paper_1',\n",
+       "  'Machine': 'Blue',\n",
+       "  'Start': 42.0,\n",
+       "  'Duration': 45,\n",
+       "  'Finish': 87.0},\n",
+       " {'Job': 'Paper_1',\n",
+       "  'Machine': 'Yellow',\n",
+       "  'Start': 87.0,\n",
+       "  'Duration': 10,\n",
+       "  'Finish': 97.0},\n",
+       " {'Job': 'Paper_2',\n",
+       "  'Machine': 'Blue',\n",
+       "  'Start': 10.0,\n",
+       "  'Duration': 20,\n",
+       "  'Finish': 30.0},\n",
+       " {'Job': 'Paper_2',\n",
+       "  'Machine': 'Green',\n",
+       "  'Start': 0.0,\n",
+       "  'Duration': 10,\n",
+       "  'Finish': 10.0},\n",
+       " {'Job': 'Paper_2',\n",
+       "  'Machine': 'Yellow',\n",
+       "  'Start': 30.0,\n",
+       "  'Duration': 34,\n",
+       "  'Finish': 64.0},\n",
+       " {'Job': 'Paper_3',\n",
+       "  'Machine': 'Blue',\n",
+       "  'Start': 30.0,\n",
+       "  'Duration': 12,\n",
+       "  'Finish': 42.0},\n",
+       " {'Job': 'Paper_3',\n",
+       "  'Machine': 'Green',\n",
+       "  'Start': 42.0,\n",
+       "  'Duration': 17,\n",
+       "  'Finish': 59.0},\n",
+       " {'Job': 'Paper_3',\n",
+       "  'Machine': 'Yellow',\n",
+       "  'Start': 0.0,\n",
+       "  'Duration': 28,\n",
+       "  'Finish': 28.0}]"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def jobshop_solve(model):\n",
+    "    #SolverFactory('cbc').solve(model)\n",
+    "    solverx.solve(model)\n",
+    "    results = [{'Job': j,\n",
+    "                'Machine': m,\n",
+    "                'Start': model.start[j, m](), \n",
+    "                'Duration': model.dur[j,m], \n",
+    "                'Finish': model.start[(j, m)]() + model.dur[j,m]}\n",
+    "               for j,m in model.TASKS]\n",
+    "    return results\n",
+    "\n",
+    "def jobshop(TASKS):\n",
+    "    return jobshop_solve(jobshop_model(TASKS))\n",
+    "\n",
+    "results = jobshop(TASKS)\n",
+    "results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "7uDCIyqpshoO",
+    "pycharm": {}
+   },
+   "source": [
+    "## Printing schedules"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 425
+    },
+    "executionInfo": {
+     "elapsed": 1015,
+     "status": "ok",
+     "timestamp": 1603817901439,
+     "user": {
+      "displayName": "Jeffrey Kantor",
+      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gg_n8V7bVINy02QRuRgOoMo11Ri7NKU3OUKdC1bkQ=s64",
+      "userId": "09038942003589296665"
+     },
+     "user_tz": 240
+    },
+    "id": "ZmtO_2EeshoO",
+    "outputId": "fecdce9c-ddca-4aad-d7fe-c3d8fcebde8a",
+    "pycharm": {}
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Schedule by Job\n",
+      "                 Start  Duration  Finish\n",
+      "Job     Machine                         \n",
+      "Paper_1 Blue      42.0        45    87.0\n",
+      "        Yellow    87.0        10    97.0\n",
+      "Paper_2 Green      0.0        10    10.0\n",
+      "        Blue      10.0        20    30.0\n",
+      "        Yellow    30.0        34    64.0\n",
+      "Paper_3 Yellow     0.0        28    28.0\n",
+      "        Blue      30.0        12    42.0\n",
+      "        Green     42.0        17    59.0\n",
+      "\n",
+      "Schedule by Machine\n",
+      "                 Start  Duration  Finish\n",
+      "Machine Job                             \n",
+      "Blue    Paper_2   10.0        20    30.0\n",
+      "        Paper_3   30.0        12    42.0\n",
+      "        Paper_1   42.0        45    87.0\n",
+      "Green   Paper_2    0.0        10    10.0\n",
+      "        Paper_3   42.0        17    59.0\n",
+      "Yellow  Paper_3    0.0        28    28.0\n",
+      "        Paper_2   30.0        34    64.0\n",
+      "        Paper_1   87.0        10    97.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "schedule = pd.DataFrame(results)\n",
+    "\n",
+    "print('\\nSchedule by Job')\n",
+    "print(schedule.sort_values(by=['Job','Start']).set_index(['Job', 'Machine']))\n",
+    "\n",
+    "print('\\nSchedule by Machine')\n",
+    "print(schedule.sort_values(by=['Machine','Start']).set_index(['Machine', 'Job']))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "EBvet1ACshoS",
+    "pycharm": {}
+   },
+   "source": [
+    "## Visualizing Results with Gantt Charts"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 477
+    },
+    "executionInfo": {
+     "elapsed": 1586,
+     "status": "ok",
+     "timestamp": 1603817902020,
+     "user": {
+      "displayName": "Jeffrey Kantor",
+      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gg_n8V7bVINy02QRuRgOoMo11Ri7NKU3OUKdC1bkQ=s64",
+      "userId": "09038942003589296665"
+     },
+     "user_tz": 240
+    },
+    "id": "RtQ5NWPTshoU",
+    "outputId": "bab2addd-0b90-45ef-d5eb-e65eb43d823f",
+    "pycharm": {}
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x468 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light",
+      "tags": []
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def visualize(results):\n",
+    "    \n",
+    "    schedule = pd.DataFrame(results)\n",
+    "    JOBS = sorted(list(schedule['Job'].unique()))\n",
+    "    MACHINES = sorted(list(schedule['Machine'].unique()))\n",
+    "    makespan = schedule['Finish'].max()\n",
+    "    \n",
+    "    bar_style = {'alpha':1.0, 'lw':25, 'solid_capstyle':'butt'}\n",
+    "    text_style = {'color':'white', 'weight':'bold', 'ha':'center', 'va':'center'}\n",
+    "    colors = mpl.cm.Dark2.colors\n",
+    "\n",
+    "    schedule.sort_values(by=['Job', 'Start'])\n",
+    "    schedule.set_index(['Job', 'Machine'], inplace=True)\n",
+    "\n",
+    "    fig, ax = plt.subplots(2,1, figsize=(12, 5+(len(JOBS)+len(MACHINES))/4))\n",
+    "\n",
+    "    for jdx, j in enumerate(JOBS, 1):\n",
+    "        for mdx, m in enumerate(MACHINES, 1):\n",
+    "            if (j,m) in schedule.index:\n",
+    "                xs = schedule.loc[(j,m), 'Start']\n",
+    "                xf = schedule.loc[(j,m), 'Finish']\n",
+    "                ax[0].plot([xs, xf], [jdx]*2, c=colors[mdx%7], **bar_style)\n",
+    "                ax[0].text((xs + xf)/2, jdx, m, **text_style)\n",
+    "                ax[1].plot([xs, xf], [mdx]*2, c=colors[jdx%7], **bar_style)\n",
+    "                ax[1].text((xs + xf)/2, mdx, j, **text_style)\n",
+    "                \n",
+    "    ax[0].set_title('Job Schedule')\n",
+    "    ax[0].set_ylabel('Job')\n",
+    "    ax[1].set_title('Machine Schedule')\n",
+    "    ax[1].set_ylabel('Machine')\n",
+    "    \n",
+    "    for idx, s in enumerate([JOBS, MACHINES]):\n",
+    "        ax[idx].set_ylim(0.5, len(s) + 0.5)\n",
+    "        ax[idx].set_yticks(range(1, 1 + len(s)))\n",
+    "        ax[idx].set_yticklabels(s)\n",
+    "        ax[idx].text(makespan, ax[idx].get_ylim()[0]-0.2, \"{0:0.1f}\".format(makespan), ha='center', va='top')\n",
+    "        ax[idx].plot([makespan]*2, ax[idx].get_ylim(), 'r--')\n",
+    "        ax[idx].set_xlabel('Time')\n",
+    "        ax[idx].grid(True)\n",
+    "        \n",
+    "    fig.tight_layout()\n",
+    "\n",
+    "visualize(results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "JMWyAp2MshoW",
+    "pycharm": {}
+   },
+   "source": [
+    "## Application to the scheduling of batch processes\n",
+    "\n",
+    "We will now turn our attention to the application of the job shop scheduling problem to the short term scheduling of batch processes. We illustrate these techniques using Example II from Dunn (2013).\n",
+    "\n",
+    "![flowshop-Dunn-2013.png](https://github.com/jckantor/ND-Pyomo-Cookbook/blob/master/notebooks/figures/flowshop-Dunn-2013.png?raw=1)\n",
+    "\n",
+    "| Recipe  | Mixer | Reactor | Separator | Packaging |\n",
+    "| :-----: | :---: | :-----: | :-------: | :-------: |\n",
+    "| A       | 1.0   | 5.0     | 4.0       | 1.5       |\n",
+    "| B       | -     | -       | 4.5       | 1.0       |\n",
+    "| C       | -     | 3.0     | 5.0       | 1.5       |"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "FllAPz4KshoX",
+    "pycharm": {}
+   },
+   "source": [
+    "### Single product strategies\n",
+    "\n",
+    "Before going further, we create a function to streamline the generation of the TASKS dictionary."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 459
+    },
+    "executionInfo": {
+     "elapsed": 2006,
+     "status": "ok",
+     "timestamp": 1603817902449,
+     "user": {
+      "displayName": "Jeffrey Kantor",
+      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gg_n8V7bVINy02QRuRgOoMo11Ri7NKU3OUKdC1bkQ=s64",
+      "userId": "09038942003589296665"
+     },
+     "user_tz": 240
+    },
+    "id": "xfurTCWyshoY",
+    "outputId": "d027a1a6-e465-426e-b800-4c5ff3522443",
+    "pycharm": {}
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x450 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light",
+      "tags": []
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def recipe_to_tasks(jobs, machines, durations):\n",
+    "    TASKS = {}\n",
+    "    for j in jobs:\n",
+    "        prec = (None,None)\n",
+    "        for m,d in zip(machines,durations):\n",
+    "            task = (j,m)\n",
+    "            if prec == (None,None):\n",
+    "                TASKS.update({(j,m): {'dur': d, 'prec': None}})\n",
+    "            else:\n",
+    "                TASKS.update({(j,m): {'dur': d, 'prec': prec}})\n",
+    "            prec = task\n",
+    "    return TASKS\n",
+    "        \n",
+    "recipeA = recipe_to_tasks('A', ['Mixer', 'Reactor', 'Separator', 'Packaging'], [1, 5, 4, 1.5])\n",
+    "visualize(jobshop(recipeA))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 423
+    },
+    "executionInfo": {
+     "elapsed": 2441,
+     "status": "ok",
+     "timestamp": 1603817902899,
+     "user": {
+      "displayName": "Jeffrey Kantor",
+      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gg_n8V7bVINy02QRuRgOoMo11Ri7NKU3OUKdC1bkQ=s64",
+      "userId": "09038942003589296665"
+     },
+     "user_tz": 240
+    },
+    "id": "QndOwo19shoc",
+    "outputId": "65bcc252-7e07-409c-ab29-23761ff73567",
+    "pycharm": {}
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x414 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light",
+      "tags": []
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "recipeB = recipe_to_tasks('B', ['Separator', 'Packaging'], [4.5, 1])\n",
+    "visualize(jobshop(recipeB))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 441
+    },
+    "executionInfo": {
+     "elapsed": 2809,
+     "status": "ok",
+     "timestamp": 1603817903280,
+     "user": {
+      "displayName": "Jeffrey Kantor",
+      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gg_n8V7bVINy02QRuRgOoMo11Ri7NKU3OUKdC1bkQ=s64",
+      "userId": "09038942003589296665"
+     },
+     "user_tz": 240
+    },
+    "id": "VR2QKxzRshof",
+    "outputId": "a7ed824a-4176-462a-e613-7c3b46f6ea7c",
+    "pycharm": {}
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x432 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light",
+      "tags": []
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "recipeC = recipe_to_tasks('C', ['Separator', 'Reactor', 'Packaging'], [5, 3, 1.5])\n",
+    "visualize(jobshop(recipeC))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "s1U47NNXshoj",
+    "pycharm": {}
+   },
+   "source": [
+    "### Multiple Overlapping tasks\n",
+    "\n",
+    "Let's now consider an optimal scheduling problem where we are wish to make two batches of Product A."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 530
+    },
+    "executionInfo": {
+     "elapsed": 4166,
+     "status": "ok",
+     "timestamp": 1603817904648,
+     "user": {
+      "displayName": "Jeffrey Kantor",
+      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gg_n8V7bVINy02QRuRgOoMo11Ri7NKU3OUKdC1bkQ=s64",
+      "userId": "09038942003589296665"
+     },
+     "user_tz": 240
+    },
+    "id": "EGU9wmLoshoj",
+    "outputId": "04c36086-113c-42aa-de15-ad126e748291",
+    "pycharm": {}
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Makespan = 26.5\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x504 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light",
+      "tags": []
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "TASKS = recipe_to_tasks(['A1','A2','A3', 'A4'],['Mixer','Reactor','Separator','Packaging'],[1,5,4,1.5])\n",
+    "results = jobshop(TASKS)\n",
+    "visualize(results)\n",
+    "print(\"Makespan =\", max([task['Finish'] for task in results]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "j9-oR-tIshop",
+    "pycharm": {}
+   },
+   "source": [
+    "Earlier we found it tood 11.5 hours to produce one batch of product A.  As we see here, we can produce a second batch with only 5.0 additional hours because some of the tasks overlap.  The overlapping of tasks is the key to gaining efficiency in batch processing facilities.\n",
+    "\n",
+    "Let's next consider production of a single batch each of products A, B, and C."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 665
+    },
+    "executionInfo": {
+     "elapsed": 4593,
+     "status": "ok",
+     "timestamp": 1603817905087,
+     "user": {
+      "displayName": "Jeffrey Kantor",
+      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gg_n8V7bVINy02QRuRgOoMo11Ri7NKU3OUKdC1bkQ=s64",
+      "userId": "09038942003589296665"
+     },
+     "user_tz": 240
+    },
+    "id": "mnntHP1jshoq",
+    "outputId": "a657efa0-2122-48d5-f3c7-3dd19a55f5e9",
+    "pycharm": {}
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "('A', 'Mixer') {'dur': 1, 'prec': None}\n",
+      "('A', 'Reactor') {'dur': 5, 'prec': ('A', 'Mixer')}\n",
+      "('A', 'Separator') {'dur': 4, 'prec': ('A', 'Reactor')}\n",
+      "('A', 'Packaging') {'dur': 1.5, 'prec': ('A', 'Separator')}\n",
+      "('B', 'Separator') {'dur': 4.5, 'prec': None}\n",
+      "('B', 'Packaging') {'dur': 1, 'prec': ('B', 'Separator')}\n",
+      "('C', 'Separator') {'dur': 5, 'prec': None}\n",
+      "('C', 'Reactor') {'dur': 3, 'prec': ('C', 'Separator')}\n",
+      "('C', 'Packaging') {'dur': 1.5, 'prec': ('C', 'Reactor')}\n",
+      "Makespan = 15.0\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x486 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light",
+      "tags": []
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# update is used to append dictionaries\n",
+    "TASKS = recipeA\n",
+    "TASKS.update(recipeB)\n",
+    "TASKS.update(recipeC)\n",
+    "\n",
+    "for k, v in TASKS.items():\n",
+    "    print(k, v)\n",
+    "\n",
+    "results = jobshop(TASKS)\n",
+    "visualize(results)\n",
+    "print(\"Makespan =\", max([task['Finish'] for task in results]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "daGJ6KE7shot",
+    "pycharm": {}
+   },
+   "source": [
+    "The individual production of A, B, and C required 11.5, 5.5, and 9.5 hours, respectively, for a total of 25.5 hours. As we see here, by scheduling the production simultaneously, we can get all three batches done in just 15 hours. \n",
+    "\n",
+    "As we see below, each additional set of three products takes an additionl 13 hours.  So there is considerable efficiency gained by scheduling over longer intervals whenever possible."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 566
+    },
+    "executionInfo": {
+     "elapsed": 14311,
+     "status": "ok",
+     "timestamp": 1603817914815,
+     "user": {
+      "displayName": "Jeffrey Kantor",
+      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gg_n8V7bVINy02QRuRgOoMo11Ri7NKU3OUKdC1bkQ=s64",
+      "userId": "09038942003589296665"
+     },
+     "user_tz": 240
+    },
+    "id": "tmmIFHETshov",
+    "outputId": "189eb366-cb64-4da1-d5ad-0ee5317c8fd4",
+    "pycharm": {}
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Makespan = 28.0\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x540 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light",
+      "tags": []
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "TASKS = recipe_to_tasks(['A1','A2'],['Mixer','Reactor','Separator','Packaging'],[1,5,4,1.5])\n",
+    "TASKS.update(recipe_to_tasks(['B1','B2'],['Separator','Packaging'],[4.5,1]))\n",
+    "TASKS.update(recipe_to_tasks(['C1','C2'],['Separator','Reactor','Packaging'],[5,3,1.5]))\n",
+    "\n",
+    "results = jobshop(TASKS)\n",
+    "visualize(results)\n",
+    "print(\"Makespan =\", max([task['Finish'] for task in results]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "68wdMOQ9sho0",
+    "pycharm": {}
+   },
+   "source": [
+    "### Adding time for unit clean out\n",
+    "\n",
+    "A common feature of batch unit operations is a requirement that equipment be cleaned prior to reuse. \n",
+    "\n",
+    "In most cases the time needed for clean out would be specific to the equipment and product. But for the purposes this notebook, we implement can implement a simple clean out policy with a single non-negative parameter $t_{clean} \\geq 0$ which, if specified, requires a period no less than $t_{clean}$ between the finish of one task and the start of another on every piece of equipment.\n",
+    "\n",
+    "This policy is implemented by modifying the usual disjunctive constraints to avoid machine conflicts to read\n",
+    "\n",
+    "$$\n",
+    "\\begin{align}\n",
+    "\\left[\\text{start}_{j,m}+\\text{dur}_{j,m} + t_{clean} \\leq \\text{start}_{k,m}\\right] \\vee \\left[\\text{start}_{k,m}+\\text{dur}_{k,m} + t_{clean} \\leq \\text{start}_{j,m}\\right]\n",
+    "\\end{align}\n",
+    "$$\n",
+    "\n",
+    "For this purpose, we write a new JobShopModel_Clean"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 566
+    },
+    "executionInfo": {
+     "elapsed": 23784,
+     "status": "ok",
+     "timestamp": 1603817924300,
+     "user": {
+      "displayName": "Jeffrey Kantor",
+      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gg_n8V7bVINy02QRuRgOoMo11Ri7NKU3OUKdC1bkQ=s64",
+      "userId": "09038942003589296665"
+     },
+     "user_tz": 240
+    },
+    "id": "HjvMPceePHBz",
+    "outputId": "b282c450-7024-47ec-faa2-b428ae65f24e"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Makespan = 30.5\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x540 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light",
+      "tags": []
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def jobshop_model_clean(TASKS, tclean=0):\n",
+    "   \n",
+    "    model = ConcreteModel()\n",
+    "\n",
+    "    # tasks is a two dimensional set of (j,m) constructed from the dictionary keys\n",
+    "    model.TASKS = Set(initialize = TASKS.keys(), dimen=2)\n",
+    "    \n",
+    "    # the set of jobs is constructed from a python set\n",
+    "    model.JOBS = Set(initialize = list(set([j for (j,m) in model.TASKS])))\n",
+    "    \n",
+    "    # set of machines is constructed from a python set\n",
+    "    model.MACHINES = Set(initialize = list(set([m for (j,m) in model.TASKS])))\n",
+    "    \n",
+    "    # the order of tasks is constructed as a cross-product of tasks and filtering\n",
+    "    model.TASKORDER = Set(initialize = model.TASKS * model.TASKS, dimen=4, \n",
+    "        filter = lambda model, j, m, k, n: (k,n) == TASKS[(j,m)]['prec'])\n",
+    "    \n",
+    "    # the set of disjunctions is cross-product of jobs, jobs, and machines\n",
+    "    model.DISJUNCTIONS = Set(initialize = model.JOBS * model.JOBS * model.MACHINES, dimen=3,\n",
+    "        filter = lambda model, j, k, m: j < k and (j,m) in model.TASKS and (k,m) in model.TASKS)\n",
+    "    \n",
+    "    # load duration data into a model parameter for later access\n",
+    "    model.dur = Param(model.TASKS, initialize=lambda model, j, m: TASKS[(j,m)]['dur'])\n",
+    "\n",
+    "    # establish an upper bound on makespan\n",
+    "    ub = sum([model.dur[j,m] for (j,m) in model.TASKS])\n",
+    "    \n",
+    "    model.makespan = Var(bounds=(0, ub))\n",
+    "\n",
+    "    model.start = Var(model.TASKS, bounds=(0, ub))\n",
+    "    \n",
+    "    model.objective = Objective(expr = model.makespan, sense = minimize)\n",
+    "\n",
+    "    model.finish = Constraint(model.TASKS, rule=lambda model, j, m:  \n",
+    "        model.start[j,m] + model.dur[j,m] <= model.makespan)\n",
+    "    \n",
+    "    model.preceding = Constraint(model.TASKORDER, rule=lambda model, j, m, k, n: \n",
+    "        model.start[k,n] + model.dur[k,n] <= model.start[j,m])\n",
+    "    \n",
+    "    model.disjunctions = Disjunction(model.DISJUNCTIONS, rule=lambda model,j,k,m:\n",
+    "        [model.start[j,m] + model.dur[j,m] + tclean <= model.start[k,m], \n",
+    "         model.start[k,m] + model.dur[k,m] + tclean <= model.start[j,m]])\n",
+    "\n",
+    "    TransformationFactory('gdp.hull').apply_to(model)\n",
+    "    return model\n",
+    "\n",
+    "model = jobshop_model_clean(TASKS, tclean=0.5)\n",
+    "results = jobshop_solve(model)\n",
+    "visualize(results)\n",
+    "print(\"Makespan =\", max([task['Finish'] for task in results]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "HrHUYrQUsho7",
+    "pycharm": {}
+   },
+   "source": [
+    "### Adding a zero wait policy\n",
+    "\n",
+    "One of the issues in the use of job shop scheduling for chemical process operations are situations where there it is not possible to store intermediate materials. If there is no way to store intermediates, either in the processing equipment or in external vessels, then a **zero-wait** policy may be required. \n",
+    "\n",
+    "A zero-wait policy requires subsequent processing machines to be available immediately upon completion of any task. To implement this policy, the usual precident sequencing constraint of a job shop scheduling problem, i.e.,\n",
+    "\n",
+    "$$\n",
+    "\\begin{align*}\n",
+    "\\text{start}_{k,n}+\\text{Dur}_{k,n} \\leq \\text{start}_{j,m}\\ \\ \\ \\ \\text{for } (k,n) =\\text{Prec}_{j,m}\n",
+    "\\end{align*}\n",
+    "$$\n",
+    "\n",
+    "is changed to \n",
+    "\n",
+    "$$\n",
+    "\\begin{align*}\n",
+    "\\text{start}_{k,n}+\\text{Dur}_{k,n} = \\text{start}_{j,m}\\ \\ \\ \\ \\text{for } (k,n) =\\text{Prec}_{j,m}\\text{ and ZW is True}\n",
+    "\\end{align*}\n",
+    "$$\n",
+    "\n",
+    "if the zero-wait policy is in effect. \n",
+    "\n",
+    "While this could be implemented on an equipment or product specific basis, here we add an optional ZW flag to the JobShop function that, by default, is set to False."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 566
+    },
+    "executionInfo": {
+     "elapsed": 25811,
+     "status": "ok",
+     "timestamp": 1603817926340,
+     "user": {
+      "displayName": "Jeffrey Kantor",
+      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gg_n8V7bVINy02QRuRgOoMo11Ri7NKU3OUKdC1bkQ=s64",
+      "userId": "09038942003589296665"
+     },
+     "user_tz": 240
+    },
+    "id": "owKSMRnHPHB2",
+    "outputId": "495434fa-efb5-4111-8eba-6df5974387cb"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Makespan = 32.0\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x540 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light",
+      "tags": []
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def jobshop_model_clean_zw(TASKS, tclean=0, ZW=False):\n",
+    "   \n",
+    "    model = ConcreteModel()\n",
+    "    \n",
+    "    # tasks is a two dimensional set of (j,m) constructed from the dictionary keys\n",
+    "    model.TASKS = Set(initialize = TASKS.keys(), dimen=2)\n",
+    "    \n",
+    "    # the set of jobs is constructed from a python set\n",
+    "    model.JOBS = Set(initialize = list(set([j for (j,m) in model.TASKS])))\n",
+    "    \n",
+    "    # set of machines is constructed from a python set\n",
+    "    model.MACHINES = Set(initialize = list(set([m for (j,m) in model.TASKS])))\n",
+    "    \n",
+    "    # the order of tasks is constructed as a cross-product of tasks and filtering\n",
+    "    model.TASKORDER = Set(initialize = model.TASKS * model.TASKS, dimen=4, \n",
+    "        filter = lambda model, j, m, k, n: (k,n) == TASKS[(j,m)]['prec'])\n",
+    "    \n",
+    "    # the set of disjunctions is cross-product of jobs, jobs, and machines\n",
+    "    model.DISJUNCTIONS = Set(initialize = model.JOBS * model.JOBS * model.MACHINES, dimen=3,\n",
+    "        filter = lambda model, j, k, m: j < k and (j,m) in model.TASKS and (k,m) in model.TASKS)\n",
+    "    \n",
+    "    # load duration data into a model parameter for later access\n",
+    "    model.dur = Param(model.TASKS, initialize=lambda model, j, m: TASKS[(j,m)]['dur'])\n",
+    "\n",
+    "    # establish an upper bound on makespan\n",
+    "    ub = sum([model.dur[j,m] for (j,m) in model.TASKS])\n",
+    "    \n",
+    "    # to implement a zero-wait policy\n",
+    "    model.bigM = Param(initialize=ub if ZW else 0)\n",
+    "    \n",
+    "    model.makespan = Var(bounds=(0, ub))\n",
+    "    \n",
+    "    model.start = Var(model.TASKS, bounds=(0, ub))\n",
+    "    \n",
+    "    model.objective = Objective(expr = model.makespan, sense = minimize)\n",
+    "\n",
+    "    model.finish = Constraint(model.TASKS, rule=lambda model, j, m:  \n",
+    "        model.start[j,m] + model.dur[j,m] <= model.makespan)\n",
+    "    \n",
+    "    def _preceding(model, j, m, k, n):\n",
+    "        if ZW:\n",
+    "            return  model.start[k,n] + model.dur[k,n] == model.start[j,m]\n",
+    "        else:\n",
+    "            return model.start[k,n] + model.dur[k,n] <= model.start[j,m]\n",
+    "\n",
+    "    model.preceding = Constraint(model.TASKORDER, rule=_preceding)\n",
+    "    \n",
+    "    model.disjunctions = Disjunction(model.DISJUNCTIONS, rule=lambda model,j,k,m:\n",
+    "        [model.start[j,m] + model.dur[j,m] + tclean <= model.start[k,m], \n",
+    "         model.start[k,m] + model.dur[k,m] + tclean <= model.start[j,m]])\n",
+    "\n",
+    "    TransformationFactory('gdp.hull').apply_to(model)\n",
+    "    return model\n",
+    "\n",
+    "model = jobshop_model_clean_zw(TASKS, tclean=0.5, ZW=True)\n",
+    "results = jobshop_solve(model)\n",
+    "visualize(results)\n",
+    "print(\"Makespan =\", max([task['Finish'] for task in results]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "AFy7ULi_shpA",
+    "pycharm": {}
+   },
+   "source": [
+    "## Solving the LA19 benchmark problem with NEOS\n",
+    "\n",
+    "The file [`jobshop1.txt` contains 82 benchmark problems](http://people.brunel.ac.uk/~mastjjb/jeb/orlib/files/jobshop1.txt) from a well-known collection of job shop scheduling problems in the [OR-Library maintained by J. E. Beasley](http://people.brunel.ac.uk/~mastjjb/jeb/info.html). The data format for each example consists of a single line for each job.  The data on each line is a sequence of (machine number, time) pairs showing the order in which machines process each job.\n",
+    "\n",
+    "LA19 is a benchmark problem for job shop scheduling introduced by Lawrence in 1984, and a solution presented by Cook and Applegate in 1991. The following cell may take many minutes to hours to run, depending on the choice of solver and hardware. To run, uncomment the the last lines in the cell."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 25802,
+     "status": "ok",
+     "timestamp": 1603817926341,
+     "user": {
+      "displayName": "Jeffrey Kantor",
+      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gg_n8V7bVINy02QRuRgOoMo11Ri7NKU3OUKdC1bkQ=s64",
+      "userId": "09038942003589296665"
+     },
+     "user_tz": 240
+    },
+    "id": "RAxBT2KeshpC",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "data = \"\"\"\n",
+    "2  44  3   5  5  58  4  97  0   9  7  84  8  77  9  96  1  58  6  89\n",
+    "4  15  7  31  1  87  8  57  0  77  3  85  2  81  5  39  9  73  6  21\n",
+    "9  82  6  22  4  10  3  70  1  49  0  40  8  34  2  48  7  80  5  71\n",
+    "1  91  2  17  7  62  5  75  8  47  4  11  3   7  6  72  9  35  0  55\n",
+    "6  71  1  90  3  75  0  64  2  94  8  15  4  12  7  67  9  20  5  50\n",
+    "7  70  5  93  8  77  2  29  4  58  6  93  3  68  1  57  9   7  0  52\n",
+    "6  87  1  63  4  26  5   6  2  82  3  27  7  56  8  48  9  36  0  95\n",
+    "0  36  5  15  8  41  9  78  3  76  6  84  4  30  7  76  2  36  1   8\n",
+    "5  88  2  81  3  13  6  82  4  54  7  13  8  29  9  40  1  78  0  75\n",
+    "9  88  4  54  6  64  7  32  0  52  2   6  8  54  5  82  3   6  1  26\n",
+    "\"\"\"\n",
+    "\n",
+    "TASKS = {}\n",
+    "for job, line in enumerate(data.splitlines()[1:]):\n",
+    "    nums = line.split()\n",
+    "    prec = None\n",
+    "    for m, dur in zip(nums[::2], nums[1::2]):\n",
+    "        task = (f\"J{job}\",f\"M{m}\")\n",
+    "        TASKS[task] = {'dur':int(dur), 'prec':prec}\n",
+    "        prec = task\n",
+    "    \n",
+    "#pd.DataFrame(TASKS).T"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "yUXuahgpPHB6"
+   },
+   "source": [
+    "Depending on the choice of solver, this benchmark example may require from minutes to hours of computational effort on a laptop. An alternative to solving on a laptop is to submit the job to [NEOS](https://neos-server.org/neos/), a free internet-based service for solving optimization problems hosted by the University of Wisconsin and utilizing high performance servers at locations across the globe.\n",
+    "\n",
+    "The following cell shows how to solve a model using [CPLEX](https://www.ibm.com/analytics/cplex-optimizer), a high performance commericial solver, on NEOS. The solution may take several minutes, and depends on the current length of the NEOS job queue."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 729
+    },
+    "executionInfo": {
+     "elapsed": 89691,
+     "status": "ok",
+     "timestamp": 1603817990240,
+     "user": {
+      "displayName": "Jeffrey Kantor",
+      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gg_n8V7bVINy02QRuRgOoMo11Ri7NKU3OUKdC1bkQ=s64",
+      "userId": "09038942003589296665"
+     },
+     "user_tz": 240
+    },
+    "id": "p-dA89fhPHB6",
+    "outputId": "766aa8e7-3b6a-4547-ad95-34250b3df143"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x720 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light",
+      "tags": []
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def jobshop_solve_neos(model):\n",
+    "    solver_manager = SolverManagerFactory('neos')\n",
+    "    solver_manager.solve(model, opt='cplex')\n",
+    "    results = [{'Job': j,\n",
+    "                'Machine': m,\n",
+    "                'Start': model.start[j, m](), \n",
+    "                'Duration': model.dur[j,m], \n",
+    "                'Finish': model.start[(j, m)]() + model.dur[j,m]}\n",
+    "               for j,m in model.TASKS]\n",
+    "    return results\n",
+    "\n",
+    "model = jobshop_model(TASKS)\n",
+    "results = jobshop_solve_neos(model)\n",
+    "visualize(results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "mINloyXxPHB8"
+   },
+   "source": [
+    "## References\n",
+    "\n",
+    "* Applegate, David, and William Cook. [\"A computational study of the job-shop scheduling problem.\"](https://doi.org/10.1287/ijoc.3.2.149) ORSA Journal on computing 3, no. 2 (1991): 149-156. [pdf available](http://www.math.uwaterloo.ca/~bico/papers/jobshop.pdf)\n",
+    "* Beasley, John E. [\"OR-Library: distributing test problems by electronic mail.\"](https://www.jstor.org/stable/pdf/2582903.pdf?casa_token=RWUXQ6e2VngAAAAA:g-dwMXjJfCUWqoLJk5y-MpDDhLmJKSGE36YU5kpkXZ71dmos25vntN0RlDFLxDme_QsOw8Oc3oi6juXCkVCfm2gcycCK0SYNoOnOZqRYDp3EqSrXP6nDeQ) Journal of the operational research society 41, no. 11 (1990): 1069-1072. [OR-Library](http://people.brunel.ac.uk/~mastjjb/jeb/info.html)\n",
+    "* Guéret, Christelle, Christian Prins, and Marc Sevaux. [\"Applications of optimization with Xpress-MP.\"](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.69.9634&rep=rep1&type=pdf) contract (1999): 00034.\n",
+    "* Manne, Alan S. [\"On the job-shop scheduling problem.\"](https://doi.org/10.1287/opre.8.2.219) Operations Research 8, no. 2 (1960): 219-223."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "9ubGM7r1PHB8"
+   },
+   "source": [
+    "## Exercises"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "gagPe62ZPHB9"
+   },
+   "source": [
+    "### Task specific cleanout\n",
+    "\n",
+    "Clean out operations are often slow and time consuming. Further more, the time required to perform a clean out frequently depends on the type of machine, and the task performed by the machine. For this exercise, create a data format to include task-specific clean out times, and model the job shop model to accomodate this additional informaton."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "g21rYpmhPHB9"
+   },
+   "source": [
+    "### Computational impact of a zero-wait policy\n",
+    "\n",
+    "Repeat the benchmark problem calculation, but with a zero-wait policy. Does the execution time increase or descrease as a consequence of specifying zero-wait?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 89689,
+     "status": "ok",
+     "timestamp": 1603817990241,
+     "user": {
+      "displayName": "Jeffrey Kantor",
+      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gg_n8V7bVINy02QRuRgOoMo11Ri7NKU3OUKdC1bkQ=s64",
+      "userId": "09038942003589296665"
+     },
+     "user_tz": 240
+    },
+    "id": "tBiBhQBa_Uoa"
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "name": "04.03-Job-Shop-Scheduling.ipynb",
+   "provenance": [],
+   "toc_visible": true
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}