I collaborated with Jayadev Acharya, Clément L. Canonne, and Himanshu Tyagi on the problem of locally private distribution testing (full paper online here). We introduce a new public-coin data collection mechanism RAPTOR (Randomized Aggregated Private Testing Optimal Response) which yields algorithms for uniformity and independence testing with provably optimal sample complexity. We also analyze existing private-coin mechanisms (which are optimal for locally private distribution learning) and show that these mechanisms are inherently suboptimal for hypothesis testing. Furthermore, this separation for locally private hypothesis testing holds generically for any private-coin mechanism (as shown in a subsequent work).
I presented this work as a poster at the TPDP 2018 workshop, and it was accepted for publication to AISTATS 2019. This work is part of a series of publications by my co-authors looking at distribution testing under information constraints. For more information, check out this talk by Jayadev given at the ''Privacy and the Science of Data Analysis'' workshop at the Simons Institute.
As part of my undergraduate honors thesis at UT Austin, I worked with Eric Price and William Swartworth on testing hereditary properties of sequences. A hereditary property of a sequence is a property that is closed under taking subsequences. We showed that there exist hereditary properties on sequences that require linear queries to test, as long as the sequence's alphabet is infinite. In contrast, we show that any hereditary property of sequences over a finite alphabet can be tested with constant queries, suggesting this case may be more similar to the well known result that hereditary properties of graphs can be test with constant queries. For more details, you can check out our paper here.
While working on the above project, we also focused on the problem of testing pattern avoiding sequences. A pattern avoiding sequence is a generalization of monotonicity in the following sense. A sequence x_1,x_2,...,x_n avoids a (3,1,2) pattern if there are no indices i< j< k such that (x_i,x_j,x_k) have the same relative order as (3,1,2). As an example, (2,1) avoiding sequences are simply sorted sequences. Pattern avoidance, like monotonicity, is a hereditary property. We made an attempt to characterize the complexity of testing pattern avoiding sequences, which is written up in my undergraduate thesis, available publicly here. Another interesting open question is whether or not hereditary properties of sequences that only depend on the relative ordering of the sequence can be tested with sublinear queries.
A second topic I focused on in my thesis was that of searching in pattern avoiding or nearly pattern avoiding sequences. Binary search has been long known as a way to efficiently search in a sorted sequence. What if instead you are only guaranteed that the sequence is "close" to being sorted? In general, you won't be able to find the corrupted elements, but perhaps you can still find most elements efficiently. In my thesis, we define what it means to "approximately" search in a nearly sorted sequence and give a O(log n loglog n) algorithm to do so. We also investigate a related problem of searching in a pattern avoiding sequence for more complicated patterns. While this may be less interesting on its own, it has potential applications in answering questions above on characterizing the complexity of testing pattern avoiding sequences.
In a pan-private streaming algorithm, data is received by the curator, processed, and then cannot affect the distribution of the internal state of the algorithm. This model of differential privacy lies between the standard trusted curator model, where the algorithm's internal state need not be private, and the newer local model, where the data point transmitted itself must be private. I explored the question of designing pan-private streaming algorithms for graph and geometric problems.
This work was done as part of the NSF-funded 2016 DIMACS REU program. For more information, check out my website from the program here.
We looked at what happens if you allow signature schemes to have randomized verification. For more details, check out the corresponding paper here.
As part of the 2015 REU CAAR program, I worked with Jon Katz and Nathan Klein on a variant of symmetric-key broadcast encryption where every user in the system can broadcast an encrypted message decipherable only by a specified subset of the users. Our main result is a scheme that in which each user stores a linear (in the number of users) number of keys and linear (in the size of the revoked set of user) bandwidth. Furthermore, we establish that this is asymptotically optimal. For more details, see our paper here.
While a high school student in the
TAMS program,
I worked with Thomas Cundari on various projects in computational chemistry.
In my main project, I used computational techniques to analyze the
catalytic properties of various transition metals in metathesis reactions.
For more details, check out my paper
here.
Additionally, I worked on a project to develop the structure of the Keap1 protein
using tools from bioinformatics.
I have worked as a consultant for Zeutro, Yeletech Security, and Bolt Labs. From the summer of 2016 until early 2018, I consulted for Zeutro, mainly developing software for their Attribute Based Encryption technology. From mid to late 2018, I was a security consultant with a focus on blockchain technologies for Yeletech Security and Bolt Labs.
In the summer of 2014, I was a software R&D intern at Bloomberg in New York. I worked on building improved search and analytics tools for their equities databases.
In the summer of 2013, I was a software engineering intern at
L-3 Communications in
Greenville, TX.
I worked on a resource management system for equipment on
Intelligence, Surveillance and Reconnaissance aircrafts.
In spring 2019, I was a teaching assistant for CS 5854: Networks and Markets taught by Rafael Pass at Cornell Tech. I prepared supplementary material, held office hours, oversaw the grading for nearly 100 students, and even gave a lecture on coordination games for modeling social networks.
The course is intended for masters students at Cornell Tech and covers various topics at the interplay of game theory and graph theory towards building a formal framework to model and reason about social networks and markets. For more information, the course website should be available here.
In the first half of the spring 2016 semester, I was an undergraduate TA for CS 311: Discrete Math taught by William Bulko at UT Austin. For CS 311, I mostly prepared supplementary material, led discussion sections, and graded. Because of changing needs in the department, I spent the second half of the semester TAing for CS 331: Algorithms and Complexity taught by Vijaya Ramachandran. For CS 331, I was mostly in charge of preparing homework solutions and grading in addition to holding office hours.
Discrete math was the introductory CS theory course for CS majors at UT Austin. The course covers topics such as logics, proofs, and basic algorithmic analysis. Algorithms and Complexity is the second CS theory course that CS majors take. It covers standard topics in algorithmic analysis and complexity, ranging from graph algorithms, greedy algorithms, divide and conquer, dynamic programming, randomized algorithms, NP-completeness, and decidability. The webpage of the latest version of the course should be available here for more information.
In the fall of 2015, I was an undergraduate TA for CS 311H: Honors Discrete Math at UT Austin taught by Işıl Dillig. I primarily prepared supplementary material, led discussion sections and test review sessions, held office hours, and graded.
The course is intended for freshman in the Turing Scholars honors program at UT. It covers topics ranging from logic, proofs, number theory, graph theory, and basic algorithmic analysis. The latest version of the course website should still be maintained here.
In both the fall 2014 and spring 2015 semesters, I was an undergraduate TA for CS 302: Computer Fluency at UT Austin taught by Nathan Clement. The course had nearly 200 students and I was in charge of 2 sections of approximately 30 students each. I primarily prepared supplementary material, led weekly discussion sections, held office hours, and helped with grading.
This course is an introductory computer science course for non-majors. We covered basic topics in algorithms and how to implement these ideas in Python. The course also overviewed a variety of higher-level topics in computer science such as logic, operating systems, security, and artificial intelligence.