General Information

Student: Rahul Ilango
Office: Core 450
School: Rutgers University
E-mail: rahul.ilango@rutgers.edu
Project: Unique Rectification Targets in d-Complete Posets

Project Description

Our goal is to inverstigate the existence of Unique Rectification Targets (URTs) in d-Complete posets. The existence of URTs in a specific poset allows for the computations of certain constants in Comhomological rings of geometric spaces associated with the partial order. These constants help elucidate the nature of the geometric space.

Weekly Log

Week 1:
This week I met with my partner Mik Zlatin, and Professor Pechenik. We had three goals: first, to understand the nature of our project; second, to investigate URTs in trees; and third to create a Presentation to show to the other DIMACs students on Monday. After doing several examples and reading through some relevant papers, I feel comfortable with the definitions and techniques related to the question our research is addressing. Furthermore, we believe we have our first result on trees that completly characterizes their URTs. Finally, we completed our powerpoint presentation.
Week 2:
On Monday, we made our presentation in front of our fellow DIMACS students. The presentation went fairly well; the other students seemed to be able to follow our research, and our professor said we did a good job. We had two meetings with the professor this week. The first was on Monday, and the second was on Thursday. In the Monday meeting we mainly went over some feedback on the presentation and set up requirements for the code we needed to write. The objective of the code was to run through all possible URTs of a given shape. Most of my week was spent coding, and on Friday, I finally finished up the code for it. Additionally, in the Thursday meeting, we went over some of (one of) Proctor's d-complete poset papers. I definitely feel I have a greater understanding of what it means to be d-complete now.
Week 3:
This week was mostly spent debugging the code. Because the calculations run by the code are rather enormous, it is tough to check that the program is doing the correct thing except for very small examples. I was able to write up some tests that checked if the program outputing things that we know is true of rectifications. Additionally, Mik is checking over the code line-by-line to ensure the application logic makes sense. Our goal is to run the code on the irreducible d-complete posets called the "bat" and the "near bat". We know some results (thanks to papers by Anders Buch) about the "bat," and we hope to extend these to the near bat. At the same time as we are testing our conjectures with the code, we are also trying to make theoretical progress on the problem.
Week 4:
We started running into computational issues with our code. Testing it on the Bat was fine. It ran on the iLab machines in a couple minutes, but once we added just a couple more nodes needed for the near bat, the program took forever and ran out of memory. This meant we had to explore solutions to making more robust code. Possible ideas including re-writing the code to be more parallel for speed increases and switching from in-memory storage to disk store. Storing things on disk will take much longer, but at least we will be able to run our code. On the theoretical side, we have been exploring adding "tails". It turns out this was not as easy as it seemed. There are some interesting counter-examples. We have turned away from looking at the near-bat just yet because of this. We need stronger tools to explore it than we had previously thought (It is created by adding a tail to the bat).
Week 5:
First, the coding developments. I wrote up code that stored things in an on-disk database rather than in memory. This solved our memory constraint problems (though I had to deal with a bunch of bureaucracy to expand our alloted disk space), but made our code very, very slow. We kept this running in the background, and we decided to test another idea. We had conjectured that a certain thing was a URT, so instead of doing an analysis of all the URTs in the shape (so that we could figure out what worked), we could just look at these specific things and make sure they were URTs. This let us do everything in memory, and was much faster. Unfortunately, running things for the near bat still took a couple hours, but at least we knew the conjecture was very likely to be true. I also made major theoretical progress on the subject of adding tails to posets. While adding tails above elements can "break" URTs, I proved that adding elements below actually respects URTs in a nice way. Furthermore one can build a tree connecting posets and this also respects URTs.
Week 6:
This week, I explored the slant sum operation on the irreducible d-complete posets. Ideally, we would like to be able to glue these things together in a nice way after we analyzed each one individually. Our results from last week were mostly unapplicable, but they gave us most of the tools and language needed to prove some interesting things. First, I found a characterization of URTs which are preserved in the slant sum operation. These are called p-chain URTs. Furthermore, by analyzing several of the d-complete posets, we can see that for many of them p-chain URTs are exactly the usual URTs in that poset, so we don't even have to do any special p-chain analysis for them.
Week 7:
Now we are finally coming to each of the irreducible d-complete posets individually. In the past, how people have found the URTs for these things has been through tools called reading words, in which one reads a labeling in a specific manner, defines an equivalence relation over these "words", and show that this is slide invariant. If there is only one straight shape in the equivalence class, then it is a URT. This is harder to do in the d-complete posets because the usual way things are read can only be done when the poset is embedded in N^2, but this is not true for many of the d-complete posets. We are working toward doing somehting similar however. Additionally, we have our presentations this week, so Mik and I created our slides to present to the other DIMACS students.
Week 8:
This week was spent working towards an inductive proof that minimal fillings of d-complete posets are URTs. We were not able to establish the entire proof, but we were able to prove several important implications that strictly limit what the other rectifications can look like. This also gives insight as to why the minimal fillings are URTs in other posets as we show that in a general, graded poset that only very limited things can go wrong, so it makes that if there are URTs, looking at minimal ones makes sense.
Week 9:
This was the last week of the program. Almost the entirety of this week was spent on writing up our results. We had kept a running Latex file of our theorems and such, but we had fallen behind toward the end, so it was important we got them all done first so that we could remember them and check all our proofs and second becuase DIMACS requires a written report to be submitted at the end of the program. We met with our professor on Monday, Tuesday, and Wednesday so that he could proofread everything that we had written as well as help us draft an abstract and an introduction. Before we submitted it, we showed it to Lazaros, who was very satisfied with it. I think it was a very successful end to the program.


Additional Information