Hey PaperLedge Learning Crew, Ernis here, ready to dive into some fascinating research! Today, we're heading to the farm... but with a high-tech twist.
We're talking about using cutting-edge AI, specifically something called Vision Transformers or ViTs, to help farmers detect plant diseases before they decimate entire crops. Think of it like this: imagine you're a doctor, but instead of examining people, you're examining fields of plants. Early detection is key, right? That's what we're aiming for.
Traditionally, farmers would walk the fields, looking for signs of trouble, or they might use older types of AI. But these methods can be slow, expensive, and sometimes miss subtle signs. This paper looks at how ViTs could be a game changer.
So, what exactly are Vision Transformers? Well, they started out in the world of Natural Language Processing, or NLP – that's the tech that helps computers understand and generate human language. Think of how your email filters spam or how your smart speaker understands your commands. ViTs are particularly good at understanding relationships between different parts of something.
Now, picture a sentence. Each word has a relationship to other words in the sentence. ViTs excel at figuring out those relationships. It turns out that this skill translates really well to images! A ViT breaks down an image into smaller patches, almost like puzzle pieces, and then figures out how those pieces relate to each other to understand what it's seeing.
This is different from older AI models called Convolutional Neural Networks, or CNNs. CNNs have a built-in inductive bias – essentially, they're pre-programmed to look for certain patterns. That can be good, but it can also limit their ability to see the bigger picture or adapt to new situations. ViTs are more flexible.
"ViTs offer improved handling of long-range dependencies and better scalability for visual tasks."
The paper dives deep into how researchers are using ViTs to classify, detect, and even segment plant diseases. Classification is simply identifying what disease is present. Detection is pinpointing where the disease is located on the plant. And Segmentation is drawing a precise outline around the infected area. All this, automatically!
The authors reviewed a bunch of recent studies, looking at the different ways people are using ViTs, the datasets they're using to train the AI, and how well the AI is performing. They even compare ViTs to those older CNN models to see which one comes out on top, and explore hybrid models that combine the strengths of both.
Of course, there are challenges. ViTs need a lot of data to train effectively, and they can be computationally expensive, meaning they require powerful computers. Plus, it can be hard to understand why a ViT made a certain decision – a problem known as model interpretability.
But the potential benefits are huge. Imagine drones equipped with ViT-powered cameras flying over fields, automatically identifying diseased plants and alerting farmers in real-time. This could lead to more targeted treatments, reduced pesticide use, and ultimately, higher crop yields. Think of the impact on food security and the environment!
The paper concludes by outlining future research directions, suggesting ways to improve ViTs and make them even more useful for farmers. This is a rapidly evolving field, and there's a lot of exciting work happening.
So, what does this all mean for you, the PaperLedge Learning Crew?
For the tech enthusiasts: This is a great example of how AI is transforming industries beyond just software and tech.
For the environmentally conscious: Precision agriculture can lead to more sustainable farming practices.
For everyone: Ultimately, this research could help ensure a more stable and affordable food supply.
Here are a couple of things that really got me thinking:
If ViTs require so much data, how can we ensure that farmers in developing countries, who might not have access to large datasets, can still benefit from this technology?
As AI becomes more prevalent in agriculture, how do we balance the benefits of automation with the potential impact on jobs for farmworkers?
That's all for today's deep dive, Learning Crew. Until next time, keep those minds curious!Credit to Paper authors: Saber Mehdipour, Seyed Abolghasem Mirroshandel, Seyed Amirhossein Tabatabaei

Hey PaperLedge learning crew! Ernis here, ready to dive into some fascinating physics today. We're talking about fusion energy, that holy grail of clean power, and the super-complex computer simulations that help us understand it.
Specifically, we're unpacking a paper that introduces a new tool called TRIMEG-GKX. Think of it as a souped-up weather forecasting model, but instead of predicting rain, it's predicting the behavior of super-hot, electrically charged gas – plasma – inside a fusion reactor. Imagine trying to predict the movement of a swarm of angry bees, but those bees are hotter than the sun and controlled by magnetic fields!
What makes TRIMEG-GKX special? Well, it does a few things differently than other similar codes. First, it's built using something called object-oriented programming. Imagine building with LEGOs instead of just using a lump of clay. You can create reusable pieces and build much more complex structures. This makes the code more organized and easier to update.
Second, it uses a "filter/buffer-free" approach. Other codes often have to smooth out the data or store lots of intermediate steps, which can slow things down. TRIMEG-GKX is designed to be lean and mean, processing the data directly without unnecessary steps. Think of it like taking the express lane on the highway.
Perhaps the most innovative feature of TRIMEG-GKX is its use of a high-order piecewise field-aligned finite element method. Okay, that's a mouthful, but here's the gist: It's a super-precise way of breaking down the simulation into tiny pieces and solving the equations on each piece. Think of it like creating a super-detailed map of the plasma, allowing for a much more accurate simulation.
Why does this matter? Because understanding plasma behavior is crucial for building efficient fusion reactors. If the plasma becomes unstable, it can damage the reactor. TRIMEG-GKX helps us predict and prevent these instabilities.
The paper highlights that TRIMEG-GKX uses a "particle-in-cell" method. Think of it like tracking individual marbles rolling around in a bowl – each marble represents a particle in the plasma. The code also accounts for different types of particles (like different flavors of marbles) and the effect of magnetic fields (shear Alfvén physics, in the lingo). It even uses a clever trick called the "mixed-variable/pullback scheme" to accurately simulate electromagnetic effects.
To handle the huge amount of computation needed, TRIMEG-GKX is cleverly parallelized. Instead of dividing the simulation area into pieces (domain decomposition), it divides the particles among different computers and duplicates the simulation space among them. It's like having multiple teams tracking different groups of marbles, all working on the same bowl at the same time.
The researchers tested TRIMEG-GKX by simulating different types of instabilities that can occur in fusion reactors, including:
Energetic-particle-driven Alfvén eigenmodes: Think of these as plasma "waves" that can be excited by high-energy particles.
Ion temperature gradient modes: Instabilities caused by differences in temperature within the plasma.
Kinetic ballooning modes: Instabilities that can cause the plasma to "balloon" outwards.
The code performed well in simulations based on real-world data from existing fusion reactors like ASDEX Upgrade (AUG), Tokamak à configuration variable (TCV), and the Joint European Torus (JET). This shows that TRIMEG-GKX is a valuable tool for studying and improving fusion energy.
Looking ahead, the researchers are planning to use similar techniques in another code called TRIMEG-C1 to study the edge of the plasma, which is a particularly challenging area. This will use even more advanced mathematical techniques to handle the complex shapes found there.
So, what does all this mean for you, the PaperLedge listener? If you're a physicist, this is a new tool for your toolbox. If you're an engineer, it's a step towards building better fusion reactors. And if you're just curious about the future of energy, it's a glimpse into the cutting-edge research that's trying to solve one of the biggest challenges facing humanity.
"The development of advanced simulation tools like TRIMEG-GKX is crucial for accelerating progress in fusion energy research."
Here are a few questions that popped into my head:
How long does a typical simulation run using TRIMEG-GKX?
What are the biggest limitations of current fusion simulations, and how can we overcome them?
Could breakthroughs in AI and machine learning further enhance these simulations?
That's all for today's episode. Keep learning, keep exploring, and I'll catch you next time on PaperLedge!Credit to Paper authors: Zhixin Lu, Guo Meng, Roman Hatzky, Philipp Lauber, Matthias Hoelzl

Hey PaperLedge crew, Ernis here, ready to dive into some fascinating math! Today, we're tackling a paper that's all about the spherical mean transform. Now, don't let that sound scary. Think of it like this: imagine you're baking a perfectly round pizza, and instead of slicing it into wedges, you want to know the average temperature of the pizza at different distances from the center. That's kind of what the spherical mean transform helps us do – it finds the average value of a function over spheres.
This paper specifically looks at these averages for functions living inside a "unit ball". Imagine a perfectly round ball with a radius of 1. We're only interested in what's happening inside that ball.
Now, the authors of this paper have been on a mission. In a previous study, they cracked this spherical mean transform problem for balls in odd dimensions (think 3D). But even dimensions (like 2D, which is a flat circle) turned out to be trickier. This paper is the sequel, the even-dimensional solution! They've figured out exactly what the "transformed" function looks like if it started inside that even-dimensional unit ball.
So, what did they find? Their description involves some special symmetry relations. Imagine folding your pizza in half and it perfectly matching up on both sides. These symmetry relations are kind of like that, but for the transformed function. They use something called elliptic integrals to describe these symmetries. Elliptic integrals are like fancy integrals that show up in all sorts of places, like calculating the circumference of an ellipse, or even the motion of a pendulum. They're a bit complex, but the key takeaway is that they precisely define the fingerprint of functions that come from averaging over spheres in even dimensions.
But wait, there's more! The paper isn't just about the spherical mean transform. Along the way, the authors stumbled upon some cool new relationships between Bessel functions. Bessel functions are like the unsung heroes of physics and engineering – they pop up when you're dealing with waves, heat flow, and all sorts of other phenomena with circular symmetry. These researchers discovered two brand new formulas involving Bessel functions:
A new integral identity connecting different Bessel functions (the first kind and the second kind)
A new “Nicholson-type” identity, which is a special kind of relationship between Bessel functions.
These formulas are kind of like finding hidden connections between different ingredients in your kitchen – you might not have realized they went so well together! The authors even found a cool new relationship between those elliptic integrals we mentioned earlier.
So, why should you care?
For mathematicians: This provides a complete characterization of the range of the spherical mean transform, which is a fundamental problem in integral geometry.
For physicists and engineers: These new Bessel function identities could lead to more efficient ways to solve problems involving waves and oscillations.
For anyone curious about math: It's a reminder that even in well-studied areas like Bessel functions, there are still new discoveries to be made!
Here are a few questions that popped into my head:
Could these new Bessel function identities be used to simplify calculations in fields like acoustics or electromagnetism?
Are there any practical applications for understanding the spherical mean transform in even dimensions?
What other hidden connections between special functions are waiting to be discovered?
That's it for this episode! I hope you found this journey into the world of spherical mean transforms and Bessel functions as interesting as I did. Until next time, keep exploring the PaperLedge!Credit to Paper authors: Divyansh Agrawal, Gaik Ambartsoumian, Venkateswaran P. Krishnan, Nisha Singhal

Hey PaperLedge crew, Ernis here, ready to dive into some seriously cool image compression research! Now, we all know how annoying it is when photos or videos take forever to load or eat up all the space on our phones. That’s where image compression comes in – it’s like squeezing a big file into a smaller package without losing too much of the picture quality.
But here’s the thing: the fancier the compression, the more powerful the computer you need to do it. Think of it like trying to fold a fitted sheet perfectly. A simple fold is quick and easy, but a super-neat, Marie Kondo-level fold takes time and effort. The same goes for advanced image compression techniques; they require a lot of processing power.
This paper tackles that problem head-on. The researchers basically found a clever way to streamline the compression process, making it much faster and more efficient. They did this by using a clever "hierarchical feature extraction transforms" – I know, sounds complicated, but stay with me!
Imagine you're sorting LEGO bricks. You could look at every single brick and decide where it goes, or you could first sort them into broad categories: big bricks, small bricks, special pieces. Then, you sort each category further. That's kind of what this new method does. It processes the image in stages, focusing on the most important details first and then refining the smaller ones.
Specifically, the researchers figured out that they don't need to look at every single pixel at the highest resolution with the same level of detail. Instead, they use fewer "channels" (think of them as different filters or lenses) for the high-resolution parts of the image. For the parts where the image is smaller, they use lots of channels. This saves a lot of computation power without sacrificing image quality.
"This strategy effectively reduces the forward pass complexity from 1256 kMAC/Pixel to just 270 kMAC/Pixel!"
Okay, that's a mouthful, but basically, they made the process much less complex. It's like going from needing a supercomputer to compress an image to doing it on your phone.
Why does this matter? Well, for starters:
For everyday users: Faster loading times for images and videos, less storage space used on your devices.
For developers: The ability to build more efficient image compression into apps and websites without slowing things down.
For researchers: A foundation for developing even better image compression techniques in the future.
This research could really pave the way for better image compression that can be used on all kinds of devices. It’s a step towards a world where we can share high-quality images and videos without the frustrating lag and storage issues.
So, here are a couple of things I've been pondering:
Will this new technique make its way into our everyday apps and devices soon?
Could this approach be applied to other types of data compression, like audio or video?
Let me know your thoughts, PaperLedge crew!Credit to Paper authors: Ayman A. Ameen, Thomas Richter, André Kaup

Hey PaperLedge crew, Ernis here, ready to dive into some seriously cool robotics research! Today, we're talking about teaching robots to do stuff, but with a twist that could save us a ton of time and effort.
So, imagine you're trying to teach a robot how to, say, stack blocks. One way is Imitation Learning (IL). You show the robot how you do it, hoping it picks up the moves. Think of it like learning a dance by watching a video – you try to copy the steps.
But here's the catch: IL often struggles because the robot's experience changes as it learns. It's like the dance floor suddenly changing shape mid-routine! This violates a key assumption, making it hard for the robot to learn perfectly.
Then there's Interactive Imitation Learning (IIL). This is like having a dance instructor giving you real-time feedback: "No, no, move your arm like this!" It's better, but it requires constant human input, which is, well, exhausting and expensive.
That's where this paper comes in! These researchers asked: what if we could replace the human teacher with something... smarter? Something that can reason and give human-like feedback?
Enter Large Language Models (LLMs) – the brains behind AI chatbots like ChatGPT. These things are amazing at understanding language and generating creative text formats, like code. The researchers used an LLM to create a new framework called LLM-iTeach.
Think of it this way: instead of a human patiently correcting the robot, the LLM acts as a virtual coach. The LLM is first given a set of instructions to generate a Python code that can be used to control the robot. Then, it looks at what the robot is doing, compares it to what should be happening, and then offers feedback on how to improve.
The core idea is that the LLM coaches the robot by:
First, it generates a policy in Python code that guides the robots actions.
Then, comparing what the robot should be doing with what it's actually doing.
Finally, giving feedback (both corrective and evaluative) to the robot.
Here's a good analogy: Imagine teaching someone to bake a cake. With LLM-iTeach, the LLM is like a smart recipe book that not only tells you the ingredients and steps but also watches you bake and says, "Hey, you're adding too much sugar," or "Mix it a bit longer."
"LLM-iTeach uses an LLM as an interactive teacher to enhance agent performance while alleviating the dependence on human resources."
The researchers put LLM-iTeach to the test on various robotic tasks, like manipulating objects. They compared it to simpler methods (like just copying the human) and even to IIL with a real human teacher.
The results? LLM-iTeach did amazingly well! It outperformed the simple methods and even matched, or sometimes beat, the performance of the human-guided learning.
That means we could potentially teach robots complex tasks without needing a human babysitter every step of the way. This saves time, money, and lets humans focus on more creative and strategic roles.
Why does this matter?
For robotics engineers: LLM-iTeach offers a powerful new tool for training robots more efficiently.
For businesses: It could lead to more automation in manufacturing, logistics, and other industries.
For everyone: It brings us closer to robots that can truly assist us in our daily lives.
This research opens up some fascinating questions for future discussion:
Could LLM-iTeach be used to teach robots completely new skills that humans don't even know how to do yet?
What are the ethical implications of relying on AI to train robots? Could it lead to biases or unintended consequences?
How far can we push the capabilities of LLMs in robotics? Could they eventually design robots themselves?
What do you all think? Let me know your thoughts in the comments! This is Ernis, signing off from PaperLedge. Keep learning, crew!Credit to Paper authors: Jonas Werner, Kun Chu, Cornelius Weber, Stefan Wermter

Hey Learning Crew, Ernis here, ready to dive into some super cool research! Today, we're tackling a paper that's all about making our tech hardware – think the chips inside your phone, computer, even your smart toaster – way more secure.
Now, you might be wondering, "How do we even find security bugs in hardware?" Well, one way is using something called static analysis. Think of it like a super-thorough spellchecker for computer code, but instead of grammar mistakes, it's looking for potential security flaws. It scans the code before the hardware is even built, trying to catch problems early.
But here's the thing: static analysis isn't perfect. It needs to know what to look for, and sometimes it raises false alarms – like a smoke detector going off when you're just making toast! Plus, it often can't tell you why something is a security risk, just that it might be.
That's where our secret weapon comes in: Large Language Models (LLMs)! You know, the AI behind those chatbots that can answer almost any question? These models are trained on mountains of text and code, so they're surprisingly good at understanding complex systems and spotting patterns.
This paper introduces a new system called LASHED, which is like a dynamic duo – it combines the power of static analysis and LLMs to find hardware security bugs. It's like having a super-smart detective working with that vigilant spellchecker to catch the bad guys!
So, static analysis flags potential issues, and then the LLM steps in to:
Figure out what parts of the hardware are most at risk (the "assets").
Filter out the false alarms, so we're not chasing ghosts.
Explain why a particular issue is a security risk and what could happen if it's exploited.
Imagine you're building a house. Static analysis is like checking if the blueprints have the right number of doors and windows. But LASHED, with its LLM, is like having an experienced architect who can say, "Hey, that window placement could let someone easily break in!"
The researchers tested LASHED on some real-world hardware designs – specifically, four open-source Systems-on-a-Chip (SoCs). Think of an SoC as the brain of a device, containing all the essential components. They focused on five common types of hardware weaknesses, things like buffer overflows or incorrect access control.
And guess what? They found that 87.5% of the issues flagged by LASHED were actually plausible security vulnerabilities! That's a pretty high accuracy rate.
They even experimented with different ways of prompting the LLM, kind of like asking the question in different ways to get a better answer. They found that using "in-context learning" – giving the LLM examples to learn from – and asking it to "think again" improved its accuracy even further.
"In-context learning and asking the model to 'think again' improves LASHED's precision."
So, why does this matter? Well, for hardware designers, this is a game-changer. It means they can find and fix security bugs before their chips are manufactured, saving time, money, and potential headaches. For consumers, it means more secure devices that are less vulnerable to hacking. And for security researchers, it's a powerful new tool for understanding and protecting our digital world.
This research is particularly valuable because early detection of vulnerabilities is always less costly and more efficient than dealing with the consequences of a breach. We all benefit from more secure hardware, whether we are aware of it or not.
Here are a couple of questions that popped into my head while reading this paper:
How easily could this LASHED system be adapted to find different types of hardware bugs beyond the five they tested?
Could this approach be used to not only find vulnerabilities, but also suggest potential fixes?
Alright Learning Crew, that's the scoop on LASHED! Hope you found that as fascinating as I did. Until next time, keep learning and stay curious!Credit to Paper authors: Baleegh Ahmad, Hammond Pearce, Ramesh Karri, Benjamin Tan

Hey PaperLedge learning crew, Ernis here, ready to dive into another fascinating piece of research! Today, we're tackling something that sounds super complex – bilateral basic hypergeometric series – but trust me, we'll break it down.
Think of these "hypergeometric series" as really, really fancy equations. Imagine you're building with LEGOs. Regular equations are like using simple bricks. These hypergeometric series are like using specialized, oddly shaped bricks that fit together in specific and beautiful ways. Now, "bilateral basic" just means we're dealing with equations that go in two directions and have some special underlying structure.
What this paper does is essentially find new ways to transform and sum these complicated LEGO structures. It's like discovering new building techniques or finding shortcuts to calculate the total number of bricks you'll need.
The researchers started with two specific, incredibly complex equations – called very-well-poised 8Ψ8. Yeah, I know, sounds like alien code! Just think of them as the ultimate LEGO sets, with eight different parameters influencing how they fit together.
They then figured out how to rewrite these complex equations in simpler terms. One transformation expresses the original equation as a sum of two slightly less intimidating equations called 8W7. The other expresses it as a combination of a 4ψ4 and two balanced 4φ3 equations. Again, focus on the fact that the researchers found ways to simplify something incredibly complex!
It's like finding out you can build that massive LEGO castle not with thousands of individual bricks, but with a few cleverly pre-assembled modules. Makes the whole process a lot easier, right?
But here's where it gets really cool. The researchers then explored what happens when parts of these equations disappear – when elements in the denominator vanish. This might sound like a problem, but it actually reveals hidden properties and relationships within the equations. Think of it like removing a support beam from a building – sometimes it collapses, but sometimes you discover a new, even stronger structural integrity you didn't know was there!
"By studying these vanishing denominator elements, the researchers gained new insights into how these bilateral basic hypergeometric series behave and transform."
Finally, the paper delves into something called tuple product identities. These are connections between multiplication and addition in these equations, specifically for triples, quintuples, sextuples and all the way up to undecuples. Think of it like this: you know how 2 x 2 x 2 is the same as 2 + 2 + 2 + 2? These identities are like finding similar relationships, but with these super complex hypergeometric series.
These identities are expressed as sums of – you guessed it – bilateral basic hypergeometric series. So, the paper is essentially uncovering fundamental relationships within these mathematical structures.
So, why does this matter? Well:
For mathematicians: This provides new tools and insights for working with complex equations, potentially leading to breakthroughs in other areas of math and physics.
For physicists: These types of equations often appear in areas like quantum mechanics and string theory, so understanding them better could help us understand the universe better.
For computer scientists: These equations can be used in algorithm design and optimization, leading to faster and more efficient computer programs.
And for everyone else: It's a reminder that even the most complex things in the universe can be broken down and understood with the right tools and the right approach.
This research might seem abstract, but it's all about finding patterns and relationships in the mathematical world. It's like being a detective, piecing together clues to solve a complex puzzle.
Now, a few questions that popped into my head while reading this:
If these transformations simplify the equations, could they lead to new ways to solve previously unsolvable problems in physics or engineering?
Are there visual representations that could help us understand these "hypergeometric series" and their transformations in a more intuitive way?
Could this research eventually lead to new encryption methods or other technological advancements?
Alright learning crew, that's the gist of this paper. Hopefully, I've demystified it a bit. Until next time, keep exploring and keep questioning!Credit to Paper authors: Howard S. Cohl, Michael J. Schlosser

Alright learning crew, buckle up! Today we're diving into a fascinating paper about making AI assistants better at coding, and specifically, how to train them effectively. Think of it like this: you want to teach a dog a new trick, but you don't have enough treats or enough situations to practice in. That's the problem facing researchers trying to build really helpful AI coding tools.
The paper highlights a major hurdle: getting enough high-quality training data. The existing datasets, the collections of coding problems and solutions used to teach these AI models, are surprisingly small. We're talking maybe a few thousand examples, pulled from a handful of projects. And creating those datasets is a massive undertaking, requiring tons of human effort and a whole lot of storage space. Imagine painstakingly crafting each training exercise and then setting up a virtual lab for the AI to experiment in – it's a real bottleneck!
That's where the "SWE-smith" pipeline comes in. Think of SWE-smith as a coding problem generator on steroids. Instead of relying on humans to create each training example by hand, SWE-smith automatically generates coding tasks. The coolest part? It does this by taking existing Python code projects, building a virtual environment for them, and then creating problems designed to break the existing tests. It's like a digital demolition crew, but instead of wrecking buildings, it's finding weak spots in the code.
Using SWE-smith, the researchers created a dataset of 50,000 coding problems from 128 different projects. That's way bigger than any dataset that existed before! It's like going from a handful of dog treats to an entire warehouse full of them. Then, they used this massive dataset to train a new AI model called "SWE-agent-LM-32B."
And guess what? It worked! This newly trained model achieved a 40.2% "Pass@1" resolve rate on a challenging coding benchmark. In plain English, that means it solved the problem on the first try almost half the time, outperforming other similar open-source models. Pretty impressive, right?
So, why does this matter? Well, it has implications for a bunch of different people:
For developers: This research paves the way for more helpful AI coding assistants that can automate tedious tasks, catch bugs earlier, and even help write code. Imagine having a reliable AI pair programmer!
For companies: Faster, more reliable code means faster product development and fewer costly errors. This could significantly boost productivity and innovation.
For researchers: SWE-smith is open source, meaning anyone can use it to create their own coding datasets and train their own AI models. This lowers the barrier to entry and accelerates progress in the field. They are making the collection procedure, the models and the trajectories open source.
The best part? The team has made everything available at https://swesmith.com, including the SWE-smith pipeline, the dataset, and even the trained AI model. They're basically giving everyone the tools they need to build the next generation of AI coding assistants.
This research is a big step forward in making AI a truly helpful tool for software engineers. It addresses a key bottleneck in training these models and opens up new possibilities for automated code generation and debugging. It's like giving our coding AI the training montage it desperately needed!
Now, a few things that popped into my head while reading this:
Could SWE-smith be adapted to generate training data for other programming languages besides Python?
How can we ensure that the training data generated by SWE-smith is diverse enough to avoid biases in the resulting AI models?
Does this mean our software engineering jobs will eventually be overtaken by AI?
What do you guys think? Let me know your thoughts in the comments!Credit to Paper authors: John Yang, Kilian Leret, Carlos E. Jimenez, Alexander Wettig, Kabir Khandpur, Yanzhe Zhang, Binyuan Hui, Ofir Press, Ludwig Schmidt, Diyi Yang