Project 20: The Modeling and Combinatorics Studio

Build an end-to-end modeling workflow that combines assumptions, unit checks, counting principles, and probability-based uncertainty analysis.

Quick Reference

Attribute Value
Difficulty Advanced (Level 3)
Time Estimate 14-28 hours
Main Programming Language Python
Alternative Programming Languages R, Julia, JavaScript
Key Topics Combinatorics, probability, dimensional analysis, sensitivity studies
Input Mode Scenario YAML/JSON or CLI parameters
Output Mode Structured modeling report with sensitivity table

1) Learning Objectives

  1. Translate real-world scenarios into explicit assumptions and variables.
  2. Use permutations/combinations correctly for counting models.
  3. Validate equations using dimensional consistency checks.
  4. Quantify uncertainty with scenario and sensitivity analysis.
  5. Produce decision-ready reports that include limitations.

2) All Theory Needed (Per-Concept Breakdown)

Concept A: Combinatorics as Probability Foundation

Counting is the denominator logic of probability. Wrong counting leads to wrong probabilities, even when formulas look correct. Distinguishing order-sensitive and order-insensitive cases is central.

Concept B: Modeling Discipline

A useful model states assumptions, variable definitions, and units explicitly. Unit mismatch is an early warning sign that the model logic is broken.

Concept C: Uncertainty Communication

Single-point estimates hide risk. Sensitivity analysis reveals how output changes under plausible parameter variation.

3) Project Specification

3.1 What You Will Build

A modeling studio that:

  1. Ingests scenario assumptions and variables.
  2. Computes relevant combinatorial outcomes.
  3. Estimates event probabilities.
  4. Runs sensitivity sweeps on key parameters.
  5. Exports markdown report with conclusions and caveats.

3.2 Functional Requirements

  1. Support factorial/permutation/combination computations.
  2. Validate unit consistency for model equations.
  3. Compute baseline and alternative scenarios.
  4. Produce sensitivity table and uncertainty range summary.
  5. Emit a final report artifact with traceable assumptions.

3.3 Non-Functional Requirements

  • Deterministic report format.
  • Input validation for impossible parameter combinations.
  • Human-readable explanation of each computed metric.

3.4 Real World Outcome

$ python modeling_studio.py --scenario "school_event" --participants 120 --teams 5 --team_size 4
[model] objective=team assignment collision and no-show risk
[assumptions] independent no-shows, uniform assignment within constraints
[counting] combinations C(120,4)=8214570
[probability] collision_risk=0.1820
[sensitivity] no_show_rate +/-2% -> expected_shortfall +/-6.0 students
[output] saved report: outputs/modeling_report_school_event.md

4) Solution Architecture

4.1 High-Level Design

Scenario Loader -> Assumption Validator -> Counting Engine -> Probability Engine -> Sensitivity Runner -> Reporter

4.2 Key Components

Component Responsibility
Scenario Loader Parse inputs and defaults
Unit Validator Check dimensional consistency
Counting Engine Compute permutations/combinations
Probability Engine Build event probability estimates
Sensitivity Runner Parameter sweep and delta analysis
Reporter Generate markdown summary artifact

5) Implementation Guide

Phase 1: Scenario and Counting Core

  • Define schema for scenario inputs.
  • Add combination/permutation calculators.
  • Add baseline probability outputs.

Phase 2: Unit and Assumption Validation

  • Add unit metadata for variables.
  • Check equation compatibility.
  • Emit assumption checklist section.

Phase 3: Sensitivity and Reporting

  • Sweep key parameters over configurable ranges.
  • Summarize best/base/worst outcomes.
  • Export final markdown report.

6) Validation Checklist

  • Counting outputs match hand calculations on small cases.
  • Unit validator catches intentionally broken equations.
  • Sensitivity analysis changes outputs in expected direction.
  • Report includes assumptions, uncertainty, and limitations.

7) Extension Ideas

  1. Add Monte Carlo layer as optional extension (not required high-school core).
  2. Add interactive what-if dashboard.
  3. Add historical-data calibration mode.

8) Books and References

  • Concrete Mathematics - counting and binomial sections.
  • Think Stats - probability and uncertainty communication.
  • Introduction to Computation and Programming Using Python - modeling workflow chapters.