SeniorMars

I am conflicted by current Mathematics

SeniorMars — Fri, 26 Dec 2025 00:00:00 +0000

Motivation</a></h1>
For the last three months, I’ve been preparing applications to graduate schools in Mathematics. The process has forced me to ask questions I’ve been avoiding: do I actually want to commit the next five to seven years of my life to this field? Not just the mathematics itself (I love that part) but the culture and the unspoken rules that govern who gets to do mathematics and how we talk about what mathematics even is.
This post is an attempt to articulate my conflicted feelings; maybe get some answers from people who’ve thought about these things longer than I have. What follows is filled with anecdotal observations and personal experiences, so take it with however many grains of salt you need. But I hope it sparks something worth discussing.
The culture of Mathematics</a></h1>
One of the PhD programs I’m applying to lists where their current graduate students did their undergraduate work. I went through the list, then looked up their profiles. The pattern was immediate: top-tier universities, nearly all of them. MIT, Harvard, Berkeley, a few international equivalents; maybe one or two state schools if you squint. I go to Rice, which has a solid math program: I can take graduate courses as an undergrad, work with professors on research. I’m extremely lucky. But scrolling through those names made something sit wrong in my stomach, and it’s not just me being insecure about my chances. I can’t prove this, but I find it hard to believe that someone from a “weaker” school would implcitly have less mathematical ability than these students. So why does the list look like this?
I found the people who end up at top undergraduate programs tend to have done serious mathematics in high school. Many competed in olympiads, attended elite summer programs, had access to university-level material before they turned seventeen. This creates what looks like meritocracy but functions more like a pipeline. The students who discover mathematics later, or come from schools without advanced math offerings, or didn’t have parents who knew these opportunities existed — they start disadvantaged the system never lets them close. Many hobbies are like this, but mathematics is just one I feel is particularly stark about. I’m not even talking about the idea of a child genius, though that exists too.
This isn’t about individual students being talented or hardworking. It’s about how the field has built a self-perpetuating cycle that selects for access rather than ability. The olympiad kids had olympiad coaching; the coaching started in middle school; the middle school programs required parents who knew they existed and could afford the time and money to support them. By the time someone reaches graduate admissions, we’re looking at the result of a decade-long filtering process that has nothing to do with mathematical potential and everything to do with circumstances of birth. I understand I’m oversimplifying, but I went to Stuyvesant High School, a school filled with extremely strong math individuals, and I saw this pattern play out in real life multiple times. Only after seriously engaging with math did I realize how privileged my own path had been even when I didn’t “do math stuff” in high school.
Even more troubling: I’ve noticed another pattern. Students from small liberal arts colleges, even excellent ones, seem to have a harder time getting into top graduate programs compared to students from research universities. The liberal arts students might have the same level of passion and preparation, but they lack something quantifiable that admissions committees trust. Maybe it’s research experience at the frontier; maybe it’s letters from famous mathematicians; maybe it’s just name recognition. The result is that many liberal arts students, unless they’re exceptionally exceptional, end up filtered out of the top tier of graduate programs.
Here’s what bothers me: many liberal arts colleges are women’s colleges, HBCUs, or other minority-serving institutions. By favoring students from prestigious research universities, even unintentionally, graduate admissions may be indirectly reducing diversity in mathematics. I don’t have hard data on this, but it seems worth asking whether the selection mechanisms we use encode biases about race, gender, and class through the proxy of undergraduate institution.
Computer science has made visible efforts in the last decade to reach underrepresented groups through programs, scholarships, explicit diversity initiatives. Mathematics has been around much longer; such efforts seem less prevalent, less systematic, less central to how the field thinks about itself. I find myself wondering if mathematics is resistant to change or if there are structural reasons this is harder in math than in CS. Either way, the relative lack of progress is striking.
Mathematics and subjectivity</a></h1>
This will sound absurd coming from someone who’s taken real analysis and studied the foundations’ crisis of the early twentieth century, but I’m troubled by how mathematics presents itself as the shining example of objective science. Yes, I know we had to rebuild the foundations after paradoxes threatened the whole edifice. Yes, I know Gödel showed us incompleteness; we survived. But the way mathematics gets taught in academia often glosses over the subjective choices embedded in what we do.
Most mathematicians work in ZFC set theory without ever explicitly saying so. We talk about “the universe” of sets but never define what that phrase means rigorously. The foundations are assumed to be consistent because they’ve held up so far, not because we’ve proven they’re safe: we literally cannot prove ZFC is consistent from within ZFC itself. In my opinion, that’s the entire field resting on “well, nothing’s broken yet.” We can get arbitrarily far from foundational questions because most mathematicians don’t care. The working mathematician doesn’t lose sleep over whether ZFC might harbor a contradiction. We proceed as if the foundations are settled when they’re really just accepted.
There are theorems that make the subjectivity explicit. Joel David Hamkins proved that there exists a universal algorithm, a Turing machine capable of computing any desired function, provided you run it in the right model of arithmetic. Which “right model” you pick changes what’s computable. In this setting subjectivity isn’t a technicality, but a choice about what mathematical universe you inhabit, and different choices give different answers to questions that look purely mathematical.
We could have chosen homotopy type theory instead of ZFC as our foundation. HoTT would still be valid mathematics, just different mathematics. The fact that we picked one foundation over another reflects historical contingency, aesthetic preference, and practical utility — we have been using ZFC for years. Yet we teach mathematics as if the structures we study exist independently of these choices. And I know we have some good reasons for this, but still it feels like a glossing over of important philosophical issues.
Yes, our proofs and theorems are truths; I’m not disputing that. But at a larger scale, it strikes me as almost funny how we claim to be the shining example of science without acknowledging some important details. You can argue that everything reduces to axioms and we’re just exploring consequences, fine. But which axioms we choose, which logical framework we work in, whether we accept the law of excluded middle or work constructively — these are subjective decisions that shape what counts as mathematics. The subjectivity is everywhere once you start looking for it.
Every so often, I watch mathematicians criticize social sciences for being subjective, for not having the rigor of mathematics. The irony is that mathematics has its subjectivity; we’ve just convinced ourselves it doesn’t count.
Consider the Dirac delta function. Physicists used it productively for nearly two decades before we provided rigorous foundations. In this case, intuition ran ahead of formalization, and the formalization eventually caught up. Ramanujan’s work showed the same pattern: results that seemed nonsensical under the standards of his time turned out to be correct when we developed the right framework to understand them. In these two cases, the demand for proof blocks mathematical progress. I understand why we need proofs. I really do, but the insistence on formalization before acceptance has costs we don’t always count.
Even our current formalization efforts run into these issues. Proof assistants like Lean require choosing whether to use the law of excluded middle, whether to work constructively, whether to use cubical methods for homotopy type theory. These may be implementation details, but end up being philosophical commitments that affect what theorems you can state and prove (for instance fomralizing temporal logic in lean is difficult). Different proof assistants make different choices, and while that might be interesting, it undercuts the narrative that mathematics is a single objective edifice.
The broader problem, I think, is that we may be creating a culture where the general public are afraid to criticize mathematicians. We treat mathematics as hard, exclusive, requiring special talent. Combined with the assumption of objectivity, this makes mathematical authority almost unquestionable. But mathematicians make mistakes — our proofs have errors, our definitions need revision, our intuitions mislead us. The mythology of objectivity makes it harder to have those conversations honestly.
The ethics of Mathematics</a></h1>
I’m also a linguistics major, which means I notice things about language and naming that maybe pure math people don’t. Take the name “algorithm.” It’s based on the Latinization of محمد بن موسى الخوارزميّ, the Persian mathematician who wrote foundational texts on algebra and arithmetic in the ninth century. His name got corrupted through Latin into something that sounds European; most people learning about algorithms have no idea they’re named after a Muslim scholar from Baghdad.
This is part of a broader pattern. Mathematics has uncredited work everywhere, especially from non-Western cultures. The number system we use daily came from India; the concept of zero as a number, not just a placeholder, came from Indian and later Islamic mathematics. Yet we don’t teach the history of mathematics in a way that makes these contributions visible. We name theorems after Western mathematicians; we teach a narrative where real mathematics started with the Greeks and resumed with the Europeans.
Even when we do credit people, we sometimes get it wrong in ways that reflect power dynamics. Hyperbolic geometry was discovered independently by Gauss, Lobachevsky, and Bolyai, but Gauss was already famous and didn’t publish his work. Lobachevsky and Bolyai get more credit, but often the narrative erases how close Gauss was to the same ideas. The history gets simplified into priority disputes that miss how mathematics actually develops in favor a narrative (one that I’m guilty of repeating here).
Mathematics also gets used in ways that have ethical consequences we rarely discuss in math departments. Algorithms perpetuate bias because they’re trained on biased data or designed by people who don’t consider how they’ll be used. Financial models led to the 2008 economic crisis because the models made assumptions that turned out catastrophically incorrect. Mathematics isn’t neutral when it’s applied; we teach it as if the applications are someone else’s problem.
The field itself often feels elitist in ways that go beyond who gets admitted to graduate programs. There’s a culture of genius worship, of problems being interesting only if they’re hard enough to stump everyone, of mathematics as a game played by an intellectual elite. I don’t see many mathematicians asking whether we have obligations to make our work accessible, to think about who benefits from our research, to consider whether the way we structure the field excludes people who could contribute.
Maybe these questions seem tangential to doing mathematics; maybe they’re outside the scope of what a mathematician should worry about. But if I’m going to spend the next decade in this field, I need to know whether it’s possible to care about these things and still be taken seriously as a mathematician. Right now, I’m not sure it is.
I understand this reads like a crackpot essay at times, but these are genuine concerns I have.

When “Complexity” Means Twelve Different Things: A Map of the Chaos

SeniorMars — Wed, 24 Dec 2025 00:00:00 +0000

Motivation</a></h2>
For the last six months, I’ve been doing research on SAT solvers. More specifically, model counting. I’m a math major, so naturally I thought “let’s count things” sounded like a good summer project. The question was simple: does the phase transition phenomenon (where SAT instances go from easy to hard to easy again as you increase constraints) extend to counting solutions?
Quick primer: the #SAT problem asks “given a Boolean formula $\phi$, how many assignments make it true?” It’s #P-complete, which means it’s at least as hard as NP-complete problems, probably harder.
Yes, the phase transition extends to counting. Paper coming soon.
But here’s what happened while I was running experiments. I kept measuring different things without realizing they were different. Circuit size would explode at one density. Solver runtime would spike somewhere else. The number of random XOR constraints needed would climb in a third region. And I’d think “okay, the problem is getting complex here,” without being precise about what “complex” meant.
Then PhD application season hit. I started reading papers from professors I wanted to work with. One paper would talk about “proof complexity lower bounds.” Another about “circuit complexity barriers.” A third about “communication complexity of distributed protocols.” And I realized something annoying: they were all using the word “complexity” to mean completely different things. [I know this sounds obvious, but it hadn’t clicked before how broad complexity is.]
Time complexity (how long does it take) is different from circuit complexity (how many gates do you need). Both are different from query complexity (how many input bits must you read). All three are different from proof complexity (how long is the certificate). And none of them are Kolmogorov complexity (how compressible is this object).
Wait, what?
This post is me trying to make sense of that mess. Not comprehensively (that would take a textbook I’m not qualified to write), but enough so that when someone says “oh that’s communication-complex” or “the query complexity is too high,” you’ll know what lens they’re using to measure hardness.
Because here’s the thing: when I was measuring #SAT difficulty this summer, I was simultaneously measuring like five different complexity types without realizing it. They all spiked at roughly the same place (the phase transition), but for different structural reasons. Understanding why requires knowing what each complexity measure actually captures.
So let’s map the zoo.
Time & Space</a></h2>
Let’s start with the classics, the ones everyone learns first.
Time complexity</a>: how many steps does the algorithm take? Space complexity</a>: how much memory does it use?
For a Turing machine solving problem $A$, time complexity $T(n)$ is the maximum number of steps on any input of length $n$. Space complexity $S(n)$ is the maximum number of tape cells used. Both are measured in the worst case (usually).
This gives us the standard hierarchy. P is polynomial time (the “tractable” class). NP is nondeterministic polynomial time (or equivalently, polynomial-time verifiable). PSPACE is polynomial space. And so on.
For #SAT (counting satisfying assignments), we know it’s #P-complete. Again, this means it’s at least as hard as any NP problem, probably harder. Toda’s Theorem tells us the entire polynomial hierarchy collapses to $\text{P}^{\#\text{P}}$ (if you can count, you can solve anything in PH) 1</a>. Counting is powerful.
But time complexity doesn’t tell you why something is hard. It just says “this takes a long time.” When my #SAT solver was slow at the phase transition, time complexity told me “yep, it’s slow,” but not what structural property of the formula caused that slowness.
For that, I needed different lenses.
Circuit Complexity</a></h2>
When I compiled CNF formulas to d-DNNF (decision diagrams for model counting), I was measuring circuit complexity</a>: how many logical gates (AND, OR, NOT) does it take to represent this Boolean function?
Two main measures exist here. Size is the total number of gates. Depth is the longest path from input to output (this measures parallelizability).
Classes like NC (polylog depth, polynomial size) capture “efficiently parallelizable” problems. AC$^0$ is constant-depth circuits with unbounded fan-in. P/poly is polynomial-size circuits, the most general non-uniform class.
Here’s the interesting part: we can’t prove any superlinear lower bounds for explicit functions. Shannon proved in 1949 that most functions need exponential circuits (by counting) 2</a>, but we can’t point to a specific function and prove it needs more than $O(n)$ gates. The best result is Ryan Williams’ 2011 breakthrough: NEXP is not in ACC$^0$ (circuits with modular counting gates</a>) 3</a>.
That’s it. That’s all we have. We think 3SAT needs exponential circuits, but we can’t prove it. If we could, P would not equal NP.
For my #SAT experiments, the compiled circuits exploded in size at the phase transition. Why? Because the solution space fragments. The circuit has to branch on many variables before determining satisfiability. The formula has high “treewidth” (a graph measure of branching structure). This structural complexity causes the circuit blow-up.
But size isn’t the only way to think about accessing information.
Query Complexity</a></h2>
Query complexity</a> (also called decision tree complexity) asks a purer question: ignoring computation entirely, how many input bits must you examine to compute the answer?
Model: you have input $x \in {0,1}^n$. You can query “what is $x_i$?” The deterministic query complexity $D(f)$ is the minimum number of queries needed in the worst case to determine $f(x)$. There are also randomized ($R(f)$) and quantum ($Q(f)$) versions.
Example: the OR function (is there a 1 in the input?). Deterministically, you need $D(\text{OR}) = n$ queries because the 1 might be in the last position you check. But Grover’s algorithm gives $Q(\text{OR}) = O(\sqrt{n})$ with a quantum computer 4</a>. This quadratic speedup is the canonical quantum search advantage.
Another example: sorting $n$ items requires $\Omega(n \log n)$ comparisons in the comparison model. This is a query complexity lower bound (each comparison is a query), and it immediately implies that no comparison-based sorting algorithm can be faster than $O(n \log n)$.
Now, how does this relate to #SAT? Strictly speaking, my XOR-constraint approach isn’t classical query complexity (which queries input bits). Instead, it’s more like sampling complexity or solution space probing: we’re adding random XOR constraints and observing how the solution count changes. Each XOR constraint gives us one “query” into the structure of the solution space. The number of constraints needed to get an $(\epsilon, \delta)$-approximation is, in spirit, a query-like measure.
At the phase transition, we need more XOR constraints because the solution distribution is neither uniform nor sparse. It’s structured in this weird fragmented way that requires more samples to characterize accurately.
One of my favorite results in query complexity is Hao Huang’s 2019 proof of the Sensitivity Conjecture</a>. Sensitivity $s(f)$ measures how many bits you can flip in an input to change the output. Block sensitivity $bs(f)$ is similar but for blocks of bits. For 25 years, people wondered if $bs(f)$ was polynomially bounded by $s(f)$. Huang proved $bs(f) \leq s(f)^4$ with a two-page argument 5</a> using spectral graph theory and the Cauchy Interlace Theorem.
Two pages. 25-year-old problem. That’s the kind of math that makes you spill coffee.
Proof Complexity</a></h2>
Here’s where things get weird. Proof complexity</a> asks: how many steps does it take to prove something is unsatisfiable?
Most modern SAT solvers use CDCL (Conflict-Driven Clause Learning), which is essentially doing Resolution</a>: a proof system where you derive new clauses from existing ones.
Rule: from clauses $(A \vee x)$ and $(B \vee \neg x)$, derive $(A \vee B)$.
To prove a CNF is unsatisfiable, derive the empty clause (contradiction). The proof complexity is the number of clauses in the shortest derivation.
Haken’s 1985 result: the Pigeonhole Principle ($n+1$ pigeons in $n$ holes) requires exponential-size Resolution proofs 6</a>. This means CDCL solvers must take exponential time on these formulas. The hardness isn’t in the problem (easy to state), it’s in the structure of reasoning required.
For random 3-CNF at the critical density, Resolution proofs are also hard. The unsatisfiable core is hidden deep. You can’t find a small, easily refutable subformula. The refutation requires reasoning about many clauses simultaneously, leading to exponential blow-up.
Ben-Sasson and Wigderson formalized this with the width-size tradeoff 7</a>: if a Resolution proof has small width (short clauses), then it’s short. But if every proof requires wide clauses (mentioning many variables), then every proof is long. Random 3-CNF at the critical density has high proof width, hence high proof complexity, hence hard for CDCL.
This is a different kind of hardness than “the circuit is big” or “you need many queries.” It’s about the logical certificates themselves.
MOreover, Cook-Reckhow (1979) proved that if there exists a proof system where every tautology has polynomial-size proofs, then $\text{NP} = \text{coNP}$ 8</a>. So proving lower bounds for increasingly strong proof systems is a path toward separating complexity classes. We’ve done it for Resolution, Cutting Planes, bounded-depth Frege. For general Frege (standard propositional logic)? Still open.
Kolmogorov Complexity</a></h2>
Okay, curveball time. Kolmogorov complexity</a> measures something completely different: information content, independent of computation time.
Definition: $K(x)$ is the length of the shortest program that outputs $x$. Random strings have $K(x) \approx |x|$ (incompressible). Structured strings like “0000…0” have low $K(x)$ (program is “print ‘0’ $n$ times”).
This is uncomputable. You can’t write an algorithm that takes $x$ and outputs $K(x)$. Proof: Berry’s paradox (“the smallest number not definable in under sixty characters” defines itself in under sixty characters, contradiction).
Why does this matter for SAT? Because time-bounded Kolmogorov complexity connects to cryptography.
Levin’s Kt complexity measures program length plus log runtime:
$$Kt(x) = \min { |p| + \log t \mid U(p) = x \text{ in } t \text{ steps} }$$
Liu and Pass (2020) proved: one-way functions exist if and only if Kt complexity is hard to compute on average 9</a>. This connects cryptographic hardness to meta-complexity (the complexity of computing complexity).
For SAT at the phase transition, formulas are neither maximally random nor maximally structured. They’re in a weird middle ground where their Kolmogorov complexity is interesting and hard to compute. I’m not saying this directly impacts my experiments (it doesn’t), but it’s a reminder that “complexity” can mean “information content” rather than “computational cost.”
Communication Complexity</a></h2>
What if the input isn’t all in one place?
Communication complexity</a>: Alice has $x$, Bob has $y$, they want to compute $f(x, y)$. They exchange bits. The communication complexity $D(f)$ is the minimum number of bits needed in the worst case.
Example: Equality (is $x = y$?). Any deterministic protocol needs $n$ bits. Essentially, one party sends their entire input. But with randomness, you can do it in $O(\log n)$ bits (hash functions!).
The canonical hard problem is Set Disjointness: Alice has set $A$, Bob has set $B$, are they disjoint? This needs $\Omega(n)$ communication. Proof uses a “fooling set” argument (a set of input pairs forcing the protocol to distinguish them all).
Why does this matter? Because communication lower bounds imply circuit lower bounds. The Karchmer-Wigderson relation connects circuit depth to communication complexity: the depth of a circuit computing $f$ equals the communication complexity of a certain two-party game about $f$ 10</a>. This is how we prove AC$^0$ lower bounds.
For distributed model counting (formula split across machines), communication is the bottleneck. You can’t send the whole formula (too big). You need protocols that minimize communication while getting accurate counts. Active research area.
Algebraic Complexity</a></h2>
Here’s where things get elegant. Algebraic complexity</a> (also called arithmetic complexity) studies computation over fields instead of bits. Instead of Boolean circuits with AND/OR/NOT gates, we have arithmetic circuits with $+, -, \times$ gates over fields like $\mathbb{R}$ or $\mathbb{C}$.
Leslie Valiant defined two classes to mirror P and NP 11</a>:
VP (Valiant’s P): families of polynomials ${f_n}$ computable by arithmetic circuits of polynomial size and polynomial degree.
Example: The determinant of an $n \times n$ matrix. It’s computable in $O(n^3)$ operations (Gaussian elimination) or $O(\log^2 n)$ depth (Berkowitz’s algorithm). Determinant is in VP.
VNP (Valiant’s NP): polynomials definable as a sum over exponentially many terms, where each term is efficiently computable.
Example: The permanent of a matrix:
$$\text{Perm}(X) = \sum_{\sigma \in S_n} \prod_{i=1}^n x_{i,\sigma(i)}$$
This looks almost identical to the determinant (which has $(-1)^{\text{sgn}(\sigma)}$ terms), but without the sign. Computing permanents is #P-complete in the Boolean world. In the algebraic world, permanent is complete for VNP.
Valiant’s Hypothesis: $\text{VP} \neq \text{VNP}$.
This is the algebraic analog of $\text{P} \neq \text{NP}$. If VP = VNP, then the permanent has polynomial-size arithmetic circuits, which would imply $\text{P}^{\#\text{P}} \subseteq \text{P/poly}$, collapsing the polynomial hierarchy. So algebraically proving VP $\neq$ VNP would be huge.
Why is this “cleaner” than Boolean complexity? Because the algebraic setting has more structure. We can use tools from algebraic geometry, representation theory, and commutative algebra. The Geometric Complexity Theory</a> (GCT) program, launched by Mulmuley and Sohoni, tries to prove VP $\neq$ VNP using representation-theoretic obstructions.
The core idea: frame permanent vs determinant as a question about orbit closures in representation theory. Can the permanent be approximated by a linear projection of a slightly larger determinant? GCT tries to prove “no” by finding representations that appear in the permanent’s orbit but not the determinant’s.
It hasn’t succeeded yet (and recent results show simple “occurrence obstructions” don’t work), but the program drives deep research connecting complexity to algebraic geometry.
For my work, this is tangential. But it’s a reminder that choosing the right mathematical setting matters. Boolean complexity is stuck on lower bounds. Algebraic complexity has more tools available. Sometimes the right lens makes all the difference.
Descriptive Complexity</a></h2>
Completely different angle. Descriptive complexity</a> measures problems by the logical formulas needed to describe them.
Fagin’s Theorem (1974): NP = Existential Second-Order Logic 12</a>. A problem is in NP iff it’s expressible as “there exists a relation $R$ such that $\phi(R)$ holds” for some first-order $\phi$.
Example: 3-colorability. “There exist three sets of vertices (Red, Green, Blue) such that every vertex is in one set, and no two adjacent vertices share a set.” The existential quantification is the “guessing” in NP. The first-order part is the “verification.”
This extends:

AC$^0$ = First-Order Logic</li>
P = First-Order + Least Fixed Point (on ordered structures) 13</a></li>
NP = Existential Second-Order</li>
PH = Full Second-Order</li>
PSPACE = First-Order + Partial Fixed Point</li> </ul>
So P vs NP becomes: is FO + LFP equal to Existential Second-Order?
This is a question about expressive power of logical languages, not Turing machines. Same question, different lens.
I find this beautiful but not directly useful for experiments. It’s more philosophical: “What kind of logic expresses this problem?” But it’s a reminder that complexity isn’t just about machines. It’s about languages, logic, expressiveness.
Parameterized Complexity</a></h2>
Parameterized complexity</a> refines P vs NP by acknowledging inputs have structure.
Instead of measuring complexity as just $f(n)$, pick a parameter $k$ (solution size, treewidth, number of variables) and ask: is it solvable in $f(k) \cdot \text{poly}(n)$ time?
If yes, it’s Fixed-Parameter Tractable (FPT). Exponential blow-up is confined to $k$, not $n$.
Example: Vertex Cover. Find $k$ vertices covering all edges. Brute force: $O(n^k)$, not FPT. But branching algorithm: pick an edge, one endpoint must be in the cover, branch on both. Recursion depth $k$, each level $O(n)$. Total: $O(2^k \cdot n)$. This is FPT.
For SAT parameterized by treewidth, the problem becomes FPT. Low-treewidth formulas are easier.
At the #SAT phase transition, treewidth explodes. The constraint graph becomes highly interconnected. This is why compilation struggles: dynamic programming over the constraint graph has exponential blow-up with high treewidth.
Parameterized complexity gives vocabulary to say “this problem is hard because this parameter is large.” More fine-grained than P vs NP.
Data vs Expression Complexity</a></h2>
So here is the thing: Dr. Vardi is my undergraduate advisor, and it so happens that I had to read one of papers to lecture for a class he teaches where he talks about another type of complexity. In his 1982 paper “The Complexity of Relational Query Languages,” he made a distinction that should have been obvious but somehow wasn’t standard at the time 14</a>.
Vardi asked: when we talk about the complexity of a query language</a>, what are we actually measuring?
He split it into two types:
Data complexity: Fix a specific query. How hard is it to evaluate that query as a function of the database size? This measures “how difficult are the individual questions asked in this language?”
Expression complexity: Fix a specific database. How hard is it to evaluate arbitrary queries (represented by expressions in the language) on that database, as a function of the expression size? This measures “how difficult is answering different questions in this language?”
Same query language. Two completely different complexity measures. And they’re not just different by a constant factor. Vardi showed that expression complexity is typically one exponential higher than data complexity.
Example: First-order logic (relational calculus). Data complexity? LOGSPACE. Expression complexity? PSPACE. That’s not a small gap.
For fixed-point queries (related to my #SAT work), data complexity is PTIME, but expression complexity jumps to EXPTIME. The pattern holds across multiple query languages: the expression complexity hierarchy mirrors the data complexity hierarchy, shifted up by one exponential.
This matters because when database people say “this query language is complex,” you have to ask: complex for users who run the same query repeatedly on growing data? Or complex for users who run many different queries on fixed-size data? Different questions, different answers, same word.
It’s the same confusion I had with #SAT, just in a different domain. And it reinforces the point: “complexity” without context is meaningless.
And There Are More</a></h2>
I could keep going. Topological complexity (robot controller modes). Instance complexity (how hard is this specific input). Logical depth (computation time for near-shortest programs). State complexity (automata states for regular languages). Learning complexity (VC dimension vs Rademacher complexity).
Each isolates a different resource or structural property.
Why This Actually Matters</a></h2>
Back to my summer experiments. When measuring #SAT hardness, I was simultaneously measuring:

Time complexity: solver runtime</li>
Circuit complexity: compiled decision diagram size</li>
Query/Sampling complexity: XOR constraints needed</li>
Proof complexity: Resolution width (implicitly)</li>
Parameterized complexity: formula treewidth</li> </ul>
These all spike at the same place (phase transition) because they measure different facets of the same structure. The formula at critical density is hard in multiple senses. Not just slow, but structurally complicated.
That’s why the phase transition is interesting. It’s not “solvers are slow here.” It’s “the formula itself, in multiple formal senses, is complex here.”
And that’s the broader lesson. When someone says “this problem is complex,” the first question should be: complex in what sense? Time? Space? Communication? Proof length? Circuit size? Information content?
Each lens reveals something different. The real breakthroughs happen when you connect them. Communication lower bounds imply circuit lower bounds. Kolmogorov complexity connects to one-way functions. Query complexity connects to spectral graph theory (Huang’s sensitivity proof). Proof complexity connects to solver runtime.
The zoo isn’t a mess. It’s a toolkit. Yay.
General Resources</a></h2>
For readers wanting to dive deeper into complexity theory broadly:
Textbooks:

Arora, S., & Barak, B. (2009). Computational Complexity: A Modern Approach. [Free draft available online]</li>
Goldreich, O. (2008). Computational Complexity: A Conceptual Perspective. Cambridge University Press.</li>
Papadimitriou, C. H. (1994). Computational Complexity. Addison-Wesley.</li>
Jukna, S. (2012). Boolean Function Complexity: Advances and Frontiers. Springer. [Comprehensive modern treatment]</li>
Vollmer, H. (1999). Introduction to Circuit Complexity: A Uniform Approach. Springer. [Classic introduction]</li>
Krajíček, J. (1995). Bounded Arithmetic, Propositional Logic and Complexity Theory. Cambridge University Press. [Deep dive into proof complexity]</li>
Kushilevitz, E., & Nisan, N. (1997). Communication Complexity. Cambridge University Press. [Classic textbook]</li>
Li, M., & Vitányi, P. (2008). An Introduction to Kolmogorov Complexity and Its Applications (3rd ed.). Springer. [The definitive textbook]</li>
Bürgisser, P., Clausen, M., & Shokrollahi, M. A. (1997). Algebraic Complexity Theory. Springer. [Comprehensive reference]</li>
Immerman, N. (1999). Descriptive Complexity. Springer. [The authoritative textbook]</li>
Downey, R. G., & Fellows, M. R. (2013). Fundamentals of Parameterized Complexity. Springer. [Modern comprehensive treatment]</li>
Abiteboul, S., Hull, R., & Vianu, V. (1995). Foundations of Databases. Addison-Wesley. [Chapter 17 covers complexity]</li> </ul>
Surveys:

Fortnow, L., & Homer, S. (2003). “A short history of computational complexity.” Bulletin of the EATCS, 80, 95-133.</li>
Complexity Zoo</a> - Comprehensive catalog of complexity classes</li>
Buhrman, H., & de Wolf, R. (2002). “Complexity measures and decision tree complexity: a survey.” Theoretical Computer Science, 288(1), 21-43. [Excellent survey of the field]</li> </ul>
Blogs:
Computational Complexity Blog</a> by Lance Fortnow and Bill Gasarch</li>
Gödel’s Lost Letter</a> by Dick Lipton and Ken Regan</li>
Scott Aaronson’s Shtetl-Optimized</a></li> </ul>
Video Lectures:
Ryan O’Donnell’s course on Analysis of Boolean Functions</a></li>
Boaz Barak’s complexity theory lectures</a></li> </ul>
Conclusion</a></h2>
As I’m applying to PhD programs, I’m looking for advisors who think about complexity from multiple angles. Who don’t just say “P vs NP” but understand hardness is structural, informational, communicational, logical, computational all at once.
If you’re navigating the complexity landscape (literally), I hope this taxonomy helps. Next time someone says “communication-complex” or “high proof complexity,” you’ll know what lens they’re using.
And maybe you’ll start seeing connections. That’s where it gets fun.

Toda, S. (1991). “PP is as hard as the polynomial-time hierarchy.” SIAM Journal on Computing, 20(5), 865-877. Shows that counting witnesses (even approximately) is remarkably powerful. ↩</a> </li>

Shannon, C. E. (1949). “The synthesis of two-terminal switching circuits.” Bell System Technical Journal, 28(1), 59-98. Shannon showed that almost all Boolean functions require circuits of size at least 2^n/n, though the proof is non-constructive. ↩</a> </li>

Williams, R. (2014). “Non-uniform ACC circuit lower bounds.” Journal of the ACM, 61(1), 2:1-2:32. This breakthrough showed NEXP ⊄ ACC^0, the first major circuit lower bound progress since the 1980s. ↩</a> </li>

Grover, L. K. (1996). “A fast quantum mechanical algorithm for database search.” Proceedings of STOC, 212-219. The canonical quantum speedup, achieving quadratic improvement over classical search. ↩</a> </li>

Huang, H. (2019). “Induced subgraphs of hypercubes and a proof of the Sensitivity Conjecture.” Annals of Mathematics, 190(3), 949-955. A remarkably concise proof using spectral graph theory and the Cauchy Interlace Theorem. ↩</a> </li>

Haken, A. (1985). “The intractability of resolution.” Theoretical Computer Science, 39(2-3), 297-308. The first exponential lower bound for a natural proof system. ↩</a> </li>

Ben-Sasson, E., & Wigderson, A. (2001). “Short proofs are narrow—resolution made simple.” Journal of the ACM, 48(2), 149-169. Established the fundamental width-size tradeoff for resolution proofs. ↩</a> </li>

Cook, S. A., & Reckhow, R. A. (1979). “The relative efficiency of propositional proof systems.” The Journal of Symbolic Logic, 44(1), 36-50. Foundational paper connecting proof complexity to computational complexity. ↩</a> </li>

Liu, Y., & Pass, R. (2020). “On one-way functions and Kolmogorov complexity.” Proceedings of FOCS, 1243-1254. Proved the equivalence between OWF existence and average-case hardness of time-bounded Kolmogorov complexity. ↩</a> </li>

Karchmer, M., & Wigderson, A. (1990). “Monotone circuits for connectivity require super-logarithmic depth.” SIAM Journal on Discrete Mathematics, 3(2), 255-265. Established the fundamental connection between circuit depth and communication complexity. ↩</a> </li>

Valiant, L. G. (1979). “Completeness classes in algebra.” Proceedings of STOC, 249-261. Introduced VP and VNP as algebraic analogs of P and NP, along with Valiant’s Hypothesis. ↩</a> </li>

Fagin, R. (1974). “Generalized first-order spectra and polynomial-time recognizable sets.” Complexity of Computation, 7, 43-73. The foundational result of descriptive complexity theory. ↩</a> </li>

Immerman, N. (1986). “Relational queries computable in polynomial time.” Information and Control, 68(1-3), 86-104. And independently: Vardi, M. Y. (1982). “The complexity of relational query languages.” Proceedings of STOC, 137-146. Together these prove the Immerman-Vardi Theorem characterizing P in logic. ↩</a> </li>

Vardi, M. Y. (1982). “The complexity of relational query languages.” Proceedings of the 14th Annual ACM Symposium on Theory of Computing, 137-146. First systematic distinction between data and expression complexity, showing expression complexity is typically one exponential higher. ↩</a> </li> </ol> </section>

Scratch Paper

SeniorMars — Thu, 06 Nov 2025 00:00:00 +0000

I submitted this to a math poetry contest a while back and got honorable mention! I figured I’d share it here too.

Scratch Paper
Each sheet, a battlefield of crossed-out lines,
arrows veering nowhere, circles chasing dreams.
Three hours deep, seventeen pages sprawled—
my proof still wrong, but now wrong in new ways.
Like archeology in reverse, I stack
layers of failure, each attempt preserved
in smudged graphite and coffee rings.
The answer is here somewhere, buried
beneath epsilon neighborhoods and
desperate margin calculations.
My professor makes it look effortless,
chalk lines flowing like water.
But here in my dorm at 3 AM,
drowning in crumpled attempts,
I remember reading how Erdős
filled notebooks before finding truth.
So I reach for one more blank page,
knowing that ugly paths sometimes lead
to the most beautiful places. </blockquote>

The Computational Trilogy: Three Languages for One Structure

SeniorMars — Thu, 27 Feb 2025 00:00:00 +0000

Motivation</a></h2>
Ask three people what computation is and you may get three answers that barely seem related.
A computer scientist might talk about programs, evaluation, and types. A logician might talk about propositions, derivations, and normalization. A category theorist might draw arrows until everyone else leaves the room.
For a long time I treated these as neighboring subjects. They shared notation, borrowed ideas from each other, and occasionally occupied the same seminar. Then I encountered the claim usually called the computational trilogy or computational trinitarianism:

Propositions correspond to types and objects.
Proofs correspond to programs and morphisms. </blockquote>
The slogan is often compressed even further:

Proofs are programs. Programs are morphisms. </blockquote>
When I first saw this, I thought it was either one of the deepest ideas I had encountered or an elaborate abuse of the word “are.” It is, in a sense, both.
There is a precise theorem underneath the slogan. Intuitionistic propositional logic, the simply typed lambda calculus, and cartesian closed categories present the same basic structure in three different languages. That precision matters, but it also creates more ideas we can explore. Nonetheless, the claim is not that every Python script is secretly a proof, that every mathematical proof should be executable, or that category theory has abolished the distinction between syntax and semantics. Those versions sound exciting and are mostly wrong.
The real correspondence is a bit narrower, but I now find it more interesting because of those limits. It tells us exactly which parts of logic behave computationally, exactly which type systems carry logical meaning, and exactly which categorical structures model those systems. When the correspondence breaks, the way it breaks usually points toward another logic, another language, or another category.
This post is my attempt to explain that triangle without sanding off the technical details that make it true. It began as an accessible companion to the nLab page on the computational trilogy</a>, but it has become partly an argument with my earlier draft.

The Computational Trilogy: Three Perspectives, One Truth

Why We Keep Proving The Same Damn Theorems

Automated Backups Using rclone + Box

Ergo: A collection of short stories

Braille, Dyscalculia, and Mathematics: How?

My life's mission

An Experienced (Neo)Vimmer's Workflow

How To SeniorMars: A Workflow Series

Every day is an Owl's Birthday! A rigorous exploration to a classic problem through math and rust

I decided to write a book

Don't forget about New York! A crucial ingredient to a GREAT Spider-Man movie!

A Terminal Email Client As An Alternative To Gmail: The Old Dog Neomutt And Pals

macOS</a></h3>
I’ll be using Homebrew to install Neomutt:</p>

macOS</a></h4>
`$</span> brew install isync</span> # or at least we hope this would work</span></span></code></pre>`

Running isync</a></h3> To sync your mail, simply run:</p> $</span> mbsync</span> -a</span> # or `mbsync gmail`</span></span></code></pre> This command will sync all channels defined in your .mbsyncrc</code> file and download your emails to your local machine.</p>

The Last Wish, Mental Health, and Hesitation

New Website!

`Testing</a></h2> Here is an example of the note</code> shortcode:</p> This one is static! Note!</p> </div> </div> This blog assumes basic terminal maturity</p> </div> </div> </p> This one is clickable!`

This blog assumes basic terminal maturity</h1> </div> </div> </p>
Literal shortcode:</p>
`{{ note(header="Note!", body="<h1>This blog assumes basic terminal maturity</h1>") }}</span></span></code></pre> Pretty cool, right?</p> Finally, you can do something like this (hopefully):</p>`

Clickable Notes (Collapsible)</a></h3>

Center Alignment</a></h3>

Centered Header</p> </div> </div>

This note has a centered header.</p> </div> </div>

Centered Success</p> </div> </div>

This success note has a centered header.</p> </div> </div>

SeniorMars

I am conflicted by current Mathematics

When “Complexity” Means Twelve Different Things: A Map of the Chaos

Scratch Paper

The Computational Trilogy: Three Languages for One Structure

SeniorMars

I am conflicted by current Mathematics

When “Complexity” Means Twelve Different Things: A Map of the Chaos

Scratch Paper

The Computational Trilogy: Three Languages for One Structure

The Computational Trilogy: Three Perspectives, One Truth

Why We Keep Proving The Same Damn Theorems

Automated Backups Using rclone + Box

Path Issues on Windows</a></h3> Windows users might encounter issues with path formats:</p> Backslash vs. Forward Slash: Windows uses backslashes (\</code>) in file paths, but you need to escape them in batch files with another backslash or use caret (^</code>) before special characters.</p> </li>

Sync Taking Too Long</a></h3> If syncs are taking too long, consider:</p> Refining your exclude list</li> Using --max-age</code> to only sync recent files</li> Using --size-only</code> to compare file sizes instead of modification times</li>

Windows-Specific Performance Tips</a></h3> Windows users can improve performance with:</p> Disable Virus Scanning for rclone: Add exclusions in your antivirus for rclone.exe and your backup directories.</p> </li>

Ergo: A collection of short stories

Braille, Dyscalculia, and Mathematics: How?