Neil Araujo

Big result in CS theory from last month: the gap between which problems can be solved in X amount of time and with X amount of space has been widened far beyond a conjecture widely believed for decades. A central question in CS theory is, "Which problems can be solved in X amount of time?" This is formalized in terms of big O class complexities: e.g., if you have a problem and you find an algorithm that solves it in O(n^2) time in the worst case, where n is the size of the input, we can say that the problem is in TIME(n^2): the class of problems that can be solved in quadratic time. For instance, P vs NP is one of the problems under this general umbrella: it's about whether a class of problems (including, e.g., TSP) can be solved in polynomial time (i.e., are in TIME(n^c) for some constant c). We can also formulate the same question in terms of space: "Which problems can be solved in X amount of space?" In this variation, you have *infinite time*--you just can't store more than X amount of data at a time. For instance, TSP can be solved in O(n) space by trying all permutations, so we can say that TSP is in SPACE(n), the class of problems that can be solved in O(n) time. The new result concerns the relationship between TIME(f(n)) and SPACE(f(n)) for any f(n). A trivial result is that if you can solve a problem in O(f(n)) time, then you can also solve it in O(f(n)) space. That's because in O(f(n)) time, you can only write O(f(n)) amount of memory. In other words, TIME(f(n)) is a subset of SPACE(f(n)) for any f(n). The question is, how big is the gap? If a problem can be solved in O(f(n)) time, how much space is actually needed? The long-held conjecture was that the gap between TIME(f(n)) and SPACE(f(n)) is actually very small. It was believed that, if a problem required O(f(n)) time, it couldn't be solved using O(f(n)^(1-epsilon)) space for any epsilon > 0. E.g., the conjecture was that if a problem can be solved in O(n^2) time, then it cannot be solved using only O(n^1.999) space and infinite time. This is a strong conjecture, and I don't remember why it was believed, but in any case, it was shattered last month. It was shown that if you can solve a problem in O(f(n)) time (where f(n) is at least linear), then you can *always* solve it using just O(sqrt(f(n)) * log(f(n))) space. In other words, TIME(f(n)) is a subset of SPACE(f(n)*0.5001). Edit: I wanted to add a clarification: when discussing this type of complexity theory results, it is important to be precise about the computational model. The result above is for multitape Turing machines. They say, "At the present time, we do not know how to extend Theorem 1.1 to arbitrary random-access models of computations." The RAM model of computation is closer to how computers actually work, so the result would be even more interesting if they could also prove it for the RAM model. I imagine they will be trying to do that next :) Paper: https://lnkd.in/g4j_z9b2

254

15 Comments

Shipping today: Cartesia’s Ink-Whisper on Vapi. Latency is critical. Slow STT ruins conversations. With Ink-Whisper, just one line in your Vapi config gets you: - Faster, streaming-optimized transcripts - Better handling of background noise and accents Read more: https://vapi.sh/u4KRN67

111

11 Comments

We were building the right product...five years too early. In 2017, we built an AI contract review tool. It cost us $40 per contract review. Our customers loved it, but the economics were impossible. Fast forward to 2023: The same review costs us $0.004. That’s not a typo. A 10,000x cost reduction in just six years. This isn’t just about cheaper AI. It’s about a product vision that was right all along – we just had to survive long enough for the technology to catch up. Here’s what we learned: Sometimes the best strategy isn’t to chase the technology. It’s to build what customers need today while keeping your original vision alive on the shelf. We pivoted to building a “boring” CLM platform. Contract templates, workflows, approvals – nothing sexy. But it worked. We found product-market fit, built a customer base, and generated recurring revenue. Then when GPT-3 dropped, we dusted off that original vision. Now it’s our biggest differentiator. The companies that win aren’t always the ones with the best technology today. Sometimes they’re the ones willing to wait for tomorrow while building something valuable in the meantime. I unpack the full journey – from failure to pivot to AI renaissance – with 🎙️ Akshay Datt on the Founder Thesis Podcast. Full episode at: https://lnkd.in/gHnyRirY What’s the one product idea you’ve put on the shelf and resurrected when conditions were better? #ProductStrategy #AITransformation #LegalTech #FounderStories

114

2 Comments

I was excited to be featured on ODSC's AIX podcast on mitigating AI risk in practical use cases. Most of the AI risk mitigation guidelines are aimed at foundation model builders -- of which there are maybe a handful of strong contenders. Even two years in, most folks I talk to really struggle to think through what the tactical implications of AI risk look like. Specifically, should they be throwing the kitchen sink at the wall when it comes to adding safeguards to our AI systems, or should we be more judicious thoughtful in terms of only adding what's necessary, and nothing that's not. What does the process of determining what's necessary even look like? I go into these questions and more in the podcast episode -- give it a listen at the link below! https://lnkd.in/g7iyZ5Ba

74

5 Comments

Today I’m excited to introduce Wood Wide AI, founded by Pradeep Ravikumar and Varsha Raj, from our PearX S25 cohort! So many companies today are drowning in numeric data. Generative AI tools can’t make sense of it, but Wood Wide AI can. Pradeep and Varsha are building a table-native numeric AI that combines the flexibility of LLMs with the accuracy of ML and the reasoning power of neuro-symbolic AI to deliver real insights from any table, in any domain. Instead of relying on custom data science tooling and data teams, business users can directly run data analysis and predictions. The next evolution of tabular ML is here, and I’m excited to see what’s next for Wood Wide AI.

133

13 Comments

Stream processing doesn't need to be complex. For years -- stream processors used to be considered powerful, but extremely complex to implement. To run a simple incremental row count on PostgreSQL, you'd typically need: - Debezium for CDC - Avro for schema registry - Kafka for the event queue - Flink to do the actual aggregation - JDBC Sink to push results back to Postgres …plus hours of digging into Kafka, Flink, and Debezium configs. Watermarks, checkpoints, offsets... Fundamentally though -- there isn't a reason stream processing has to be so complex. A new generation of stream processors is flipping the script — combining powerful capabilities with a radically simpler developer experience. They are breaking the traditional tradeoffs between stream processing (fast but complex) vs. batch processing (easy but slower). Parallelism, internal components, fault tolerance, and schema evolution are all abstracted away from the user — and a single simple interface is built to control all the stream processors mechanism (ingesting data, transforming data, sinking data). The result? Companies are building real-time applications that process billions of records in days, not months. The data world is changing, and the barrier to entry for stream processing is getting dramatically lower. If you are interested in learning more about one of these "newer generation" stream processors — welcome to check out Epsio's docs in this link: https://docs.epsio.io

334

28 Comments