Private Data Pipelines with Type-Checked Budgeting

ISEF Category: Systems Software

Subcategory: Languages and Operating Systems  ·  Difficulty: Advanced  ·  Setup: University Lab  ·  Time: Full Year

The Hook

Every query over private data spends a little privacy money. If you spend too much, you lose protection. Your project can turn that idea into code that refuses illegal pipelines before they run. That makes privacy budgeting visible, checkable, and much harder to mess up.

What Is It?

Differential privacy is a way to analyze data while limiting how much any one person can be identified. Think of it like adding just enough fog to a photo. You still see the shape of the scene, but you cannot zoom in on one face with full clarity.

This project asks you to build a small programming language for privacy-safe data analysis. The language keeps track of an epsilon budget, which is a number that measures how much privacy loss you spend. If a pipeline tries to use more budget than allowed, the type system blocks it. A type system is the part of a language that checks whether code follows the rules before it runs.

Implementing the language as an MLIR dialect means you define a special layer inside a compiler framework that can represent and check your privacy rules. That lets you test whether static analysis can catch privacy mistakes early, before data ever gets processed.

Why This Is a Good Topic

This is a strong science fair topic because it is both testable and realistic. You can measure whether the type system catches invalid pipelines, whether it tracks budget correctly across chained operations, and whether it produces usable compiler output on small analytics examples. The project connects directly to real problems in census analysis, medical data, and public policy, where privacy mistakes can have real consequences. You can learn compiler design, formal reasoning, and privacy-preserving data analysis in one project.

Research Questions

• How does a type system that tracks epsilon budget compare to a manual budgeting approach for catching invalid privacy pipelines?
• What is the effect of adding branching dataflow on the accuracy of end-to-end epsilon tracking?
• Does the MLIR dialect reject pipelines with hidden budget reuse more reliably than a handwritten checker?
• To what extent does the compiler surface privacy violations at the source-code level instead of after lowering?
• Which pipeline structures produce the largest gap between estimated and actual privacy budget use?
• How does the number of transformations in a toy census workflow affect the complexity of static privacy checks?

Basic Materials

• Laptop or desktop computer with enough memory to run compiler tools.
• A code editor with syntax highlighting.
• Python for scripting tests and small analyses.
• MLIR build tools and a local LLVM toolchain.
• Version control software such as Git.
• Spreadsheet software for tracking tests and outcomes.
• Sample toy census datasets with no real personal data.
• Documentation for differential privacy basics and compiler IR concepts.

Advanced Materials

• Workstation or lab machine that can build LLVM and MLIR from source.
• Access to a compiler research environment or university cluster.
• Benchmark suite of toy analytics pipelines.
• Property-based testing framework for compiler validation.
• Formal specification notes for the privacy type rules.
• Visualization tools for control flow and dataflow graphs.
• Logging and profiling tools for compiler passes.
• Synthetic dataset generator for privacy experiments.

Software & Tools

• MLIR: Hosts the custom dialect and compiler passes for your privacy-aware language.
• LLVM: Provides the backend infrastructure needed to lower and test the dialect.
• Python: Automates test generation, result checking, and analysis scripts.
• Git: Tracks versioned changes as you refine the language and its checker.
• Graphviz: Draws pipeline graphs so you can inspect where budget flows through the program.

Experiment Steps

1. Define the privacy rule you want the type system to enforce, including how epsilon should flow through sequential and branching operations.
2. Choose a minimal set of pipeline operations that can represent toy census analytics without adding extra complexity.
3. Design the MLIR dialect so each operation carries enough type information to support static budget checking.
4. Build test cases that include valid pipelines, invalid pipelines, and edge cases that try to reuse budget in hidden ways.
5. Compare the compiler’s rejection or acceptance decisions against a manual privacy budget ledger.
6. Measure how well your checker scales as you add more steps, more branches, and more analysis patterns.

Common Pitfalls

• Treating epsilon like a simple variable, which misses how privacy cost composes across branches and repeated queries.
• Forgetting to model one operation as privacy spending, which makes an unsafe pipeline look valid.
• Designing the dialect so later compiler passes erase the information your checker needs.
• Testing only happy-path pipelines, which hides failure cases where budget is reused or split incorrectly.
• Using real census data instead of synthetic data, which creates privacy and ethics problems before the system is ready.

What Makes This Competitive

A competitive version of this project would do more than prove the idea works. You would compare multiple type rules, test tricky pipeline shapes, and show where one design catches errors that another misses. Strong entries also quantify false accepts, false rejects, and compile-time overhead. If you can tie your checker to a real privacy failure mode in a toy census workflow, your project gets much stronger.

Project Variations

• Adapt the language to track multiple privacy costs, such as epsilon and delta, instead of only one budget.
• Test the dialect on synthetic health analytics pipelines rather than toy census workflows to see how the type rules generalize.
• Compare static budget checking with a runtime assertion system and measure which one catches more mistakes earlier.

Learn More

• MIT OpenCourseWare: Search for compiler design, type systems, and program analysis materials that explain the ideas behind IRs and static checking.
• MLIR Documentation: Read the official project docs to learn how dialects, operations, and passes work.
• LLVM Documentation: Use the compiler framework docs to understand lowering and code generation basics.
• NIST Privacy Framework: Review public guidance on privacy risk and data handling concepts.
• PubMed: Search review articles on differential privacy in health and census data analysis.
• arXiv: Search for papers on differential privacy, type systems, and verified data analysis pipelines.