#Algorithms

There is a very insidious push to deanonymize the entire internet. Very disappointing that X is following suit and just mindlessly following the lead of subversive foreign run companies like google and meta.

WARNING: X now tracks copied links SANITIZE THEM TO AVOID BEING DOXXED

@Anc_Aesthetics Feedback from my team. Links are just used for improving the algorithm recommendations and making advertising relevance suck less.

You can start an AI digital products business with $0 upfront and be making $15K–$80K/month within 90 days and nobody talks about how simple the actual setup is here's the exact sequence: Day 0: Pick a niche and audience. Women 35–65. Ecom operators. YouTube creators. Doesn't matter. Takes 3 minutes. Day 1: Use AI to generate a 200-page ebook on that niche's #1 pain point. Takes 15 minutes. Price it at $300. Day 2: Create an X theme page for that niche. Faceless. AI-generated content. Takes 10 mins to set up. Day 3: Use AI to generate 300 tweets in 15 minutes. Schedule them out. Page runs on autopilot. For 30 days, post 3–5 times per day. Educational value. No selling yet. You're building what Twitter's algorithm rewards: consistent activity and engagement signals. Day 30: Turn on the auto-DM software. Every person who likes or comments gets an instant personalized DM with a link to buy. AI bots handle the entire conversation. Objections. Follow-ups. Closing. 24/7 without you touching it. Results from one of my pages targeting women 35–65: Without the system (random posting, no automation): Sales: 0 Followers gained: minimal Revenue: $0 Same niche, WITH the full system running: Less than 5,000 total views on 1 post 17 sales at $300 each $5,100 from a brand new page with almost no reach The cost to build this entire operation: under $45/month in tools The AI generates the content. The AI generates the product. The bots do the selling. You collect the money. Here's the full sequence for maximum output: Week 1: Set up page, generate ebook, load 300 tweets into scheduler Week 2: Page posts automatically while you do nothing Week 3: Layer in auto-DM software, connect to sales page Week 4: First sales start hitting. Optimize the DM sequence. Month 2: Add a second page in a second niche. Stack the income. then third. keep repeating. Month 3: You have 3–5 pages each generating $15K–$80K/month Total time investment after setup: 3-7 hours per week Every "make money online" guru tells you to grind content manually, build an audience slowly, and hope something converts. Nobody mentions that AI can do 95% of the work and the pages that win aren't run by humans at all. Because the gurus are selling you their time-for-money model. This is the leverage model. Completely different game. if you want the full gameplan, then comment "X" and I'll DM it to you **must be following + retweet

This guy used Grok Bot to build an asynchronous complete-set trading system on Polymarket Result: +$319,430 The system makes 131 trades an hour in short-term crypto Up/Down markets, with an average trade size of $30.58 Several Grok Bot AI agents work together as one algorithm: 1. Builds positions on both sides It bought both Up and Down in 88.76% of markets The median gap between its first trades on each side is 35 seconds It then keeps switching between them as the market reprices, turning directional inventory into matched Up/Down pairs Average cost per pair: > Up + Down before fees = 96.35¢ > Up + Down after taker fees = 98.69¢ > Structural edge = 1.31¢ 2. Builds directional positions Only 58.66% of two-sided markets ended up with an average cost per pair below $1 after fees Some shares remain directional and provide an additional edge Its Polymarket account: norm1e69 The system’s main edge comes from asynchronous pairing: > It uses repricing to turn part of its Up and Down inventory into complete sets < $1 > It holds the unpaired remainder as a directional position until resolution

Writing 🔥 7 REGRESSION ALGORITHMS EVERY MACHINE LEARNING ENTHUSIAST SHOULD KNOW! 🤖📊 Want to understand how Machine Learning predicts the future? Start with these powerful regression algorithms! 🚀 1️⃣ Linear Regression — Predicts outcomes using linear relationships. 📈 2️⃣ Ridge Regression — Reduces overfitting with L2 regularization. 🛡️ 3️⃣ Lasso Regression — Selects important features and simplifies models. 🎯 4️⃣ Elastic Net Regression — Combines Ridge + Lasso for balanced regularization. ⚖️ 5️⃣ Support Vector Regression (SVR) — Handles complex, non-linear relationships using kernels. 🧠 6️⃣ Random Forest Regressor — Combines multiple decision trees for powerful predictions. 🌳 7️⃣ XGBoost Regressor — Uses gradient boosting to deliver high-performance predictions. ⚡ 💡 Quick Tips: ✅ Start with Linear Regression as your baseline. ✅ Use Ridge, Lasso, or Elastic Net to control overfitting. ✅ Try Random Forest or XGBoost for complex patterns. ✅ Evaluate your model using MAE, MSE, RMSE, and R². Machine Learning isn't just about algorithms—it's about choosing the RIGHT algorithm for the RIGHT problem! 🔥 💾 Save this cheat sheet for your next ML project! 🔁 Repost to help other AI & Data Science learners. 👇 Which regression algorithm do you use most? Comment below! Tighten this for X's character limit Make the explanations more technically precise Add a beginner-friendly model selection guide

Many of you don't understand how serious this is, so let me break it down. In computer science there is a famous kind of puzzle called 3-SAT. You are given a long list of yes-or-no switches and a set of rules about how they must be arranged, and you have to find a combination that satisfies every rule. The obvious way to solve it is to try every combination, but each new switch doubles the number of possibilities, so a puzzle with a few hundred switches would take longer than the age of the universe to brute force. For decades, the smartest people in the field found clever tricks that made this a little faster, but every trick still hit the same wall: the time required kept exploding as the puzzle grew. About 25 years ago, two computer scientists, Russell Impagliazzo and Ramamohan Paturi, working with Francis Zane, turned that wall into a formal idea. They proposed the Exponential Time Hypothesis, which says this explosion is not a failure of human cleverness but a law of nature. No algorithm, however brilliant, will ever solve 3-SAT without the time blowing up exponentially. Nobody could prove it, but almost everyone believed it, and it became one of the foundations of modern computer science. Researchers used it as a measuring stick. If you could show that solving some other problem quickly would also crack 3-SAT quickly, you had shown that problem was hopelessly hard too. Hundreds of papers, across scheduling, graphs, logic and much more, rest on this one assumption. Now an internal AI model at OpenAI claims to have broken it. It says it found an algorithm that solves these puzzles meaningfully faster than the hypothesis allows, and it has checked the proof in a computer verification system called Lean. And here is the remarkable part: the very people who proposed the hypothesis, Impagliazzo and Paturi, along with MIT's Ryan Williams, are now leading the public review of whether a machine has disproved their own idea. So what happens next? If the disproof holds, a large part of theoretical computer science has to be revisited. Every result that said "this problem cannot be solved faster, assuming ETH" loses its foundation, and researchers will have to work out which of those walls were real and which were simply where we stopped looking. It does not mean everything becomes easy. The new algorithm is still slow in absolute terms and this is not the famous P versus NP problem being solved. But it means our map of what is possible was wrong in a place we were very confident about, and it was an AI that redrew it. If the disproof fails, the hypothesis survives and the field breathes out, but we will still have watched an AI produce serious, checkable work on one of the deepest questions in the discipline, closely enough that the founders of the idea had to take it seriously. Either way, something has shifted.

An internal model at OpenAI has produced a claimed refutation of ETH! Russell Impagliazzo, Mohan Paturi, and I have been asked to help organize an open and independent examination of this claim. 1/4

This guy used Grok Bot to build a Quant Volume system and it made $1,072 a day on Polymarket The result is already +$13,937 PnL in 13 days with about $144 per market traded, repeating the same setup roughly 42 times every hour across ETH "Up or Down" markets Several AI agents work together as one algorithm: 1. On-Balance Volume tracks whether trading activity supports the current ETH move The bot combines ETH movement with volume: Higher close → OBV = Previous OBV + Volume Lower close → OBV = Previous OBV - Volume Rising OBV means volume is accumulating behind upward movement Falling OBV means downward movement is receiving more confirmation This helps the bot distinguish sustained pressure from isolated moves 2. The OBV Signal Line confirms whether that pressure is continuing The system smooths the indicator: OBV Signal = EMA(OBV, 10) Then: OBV crosses above Signal → stronger Up confirmation OBV crosses below Signal → stronger Down confirmation A single volume spike is not enough. The bot waits for the accumulated flow to move in the same direction as the signal This is the first agent that will create a trading bot strategy for you and then build it: This trader’s Polymarket account: ply-pm2 Most profitable trades: $206 → $1,050 (+$844) $37 → $839 (+$802) $116 → $853 (+$737) The system uses OBV to detect volume pressure and its signal line to confirm whether that movement is continuing

Yes, it seems indeed the models even obtained the results on the same day. I haven't had a chance to look through the OAI claimed proof yet, but in the spirit of the AGMAI recommendations to improve exposition before release, some of us did read Claude's proof last week before release to try to incorporate a better quality high level overview and exposition overall, which I hope is reflected in the pdf (published via the AI repository Hexagon, see lean available at also see the google drive shared via @rrwilliams's post in preparation for the upcoming workshops he's organizing with Impagliazzo and Paturi). Sharing what I understood from the proof below: Basic idea (below is for runtime 2^{delta n} for arbitrary constant delta>0; it seems both proofs ultimately get roughly exp(O(n / sqrt(log n))) time with lower order terms in the exponent), * can assume num clauses = O(n) wlog via previous sparsification results (n = num variables) * Solve #3-SAT not 3-SAT (i.e. count satisfying assignments, don't just decide satisfiability) * Convert to graph problem: clauses are nodes, and edges between clauses that share a variable (whether it's x or not(x) doesn't matter; we care about same variable, not same literal). Weight of an edge is # of shared variables. * Divide and Conquer idea: if there's a cut with total weight W, you can iterate over all 2^W fixings of those shared variables, and for each fixing you recurse on both sides and multiply, then add it up. Base case is constant # vertices, then you can just brute force count in 2^O(1) time. Unfortunately, you're not going to always find such a cut. (aside: from now on you can imagine every occurrence of a literal gets its own variable, and edges are functions enforcing equality constraints between those copies) * Instead of the above D&C, group the vertices into g^2 groups for some large constant g = g(delta). It matters how to do this grouping (it's not arbitrary); without getting into the details (see paper), a random grouping has properties the D&C wants (probabilistic method), and this existence is enough to allow for a slow-but-fast-enough algorithm to find a good grouping deterministically. * Imagine laying out the g^2 vertices arbitrarily on a g x g grid. Some edges are "side edges" (purely horizontal or purely vertical) and some are "diagonal" (the rest). There are (g choose 2)^2 = Theta(g^4) diagonal ones (choose two rows and two columns to define the corners) but only 2*g*(g choose 2) = O(g^3) side edges. You can pick g a large enough constant that the side edges have much less total weight than the diagonals -- the D&C will save on the diagonals, so we want there to be many more of them. * The sum we want is sum_z prod_{vertices a} W_a(z_a) * prod_{edges a,b} P(z_a,z_b), where W_a(z_a) at the highest level of recursion is a table of 2^3=8 values for each of the settings of the 3 literals in clause a, with value 0 or 1 indicating whether z_a satisfies clause a or not, and P() is the equality constraint checker I mentioned on the edges (deeper levels of recursion also all involve sums of this form where P() is always an equality checker on some set of bits, but deeper W's have arbitrary integer outputs and not necessarily 0/1) Write prod_{edges} P(..) = prod_{side edges} P(..) prod_{rectangles r} P_1(..) P_2(..) where P_1, P_2 are the diagonals for the rectangle r *The key step* (eqn 15 in the pdf): first assume all edges in the entire graph have exactly 3 bits on them (it turns out reducing to this isn't *too* complicated; see (19)), and replace P_1*P_2 with a hyperedge that involves some function on the corners of the rectangle, times a sum of two products of edge functions. This replacement comes from something called the "eight square identity"; this is related to octonions, which I still know nothing about. :) So P_1*P_2 = HyperEdgeFunction(corners)*(Q_1*Q_2 + Q_3*Q_4) Two interesting things here: (1) Q_1,Q_2,Q_3,Q_4 are all side edges (Q_1,Q_2 are horizontal and Q_3,Q_4 are vertical), and (2) whereas P1,P2 have total weight 6 (3 and 3), if you merge each row of the grid into a supervertex then Q_1,Q_2 vanishes and the hyperedge becomes a regular edge with total weight 3 whereas hyperedge*Q_3*Q_4 still involves 6 bits (and vice versa if you merge each column into a supervertex). In particular, the average weight from using Q_1*Q_2 vs. Q_3*Q_4 is (3+6)/2 = 4.5. We went from weight 6 (P_1*P_2) to weight 4.5 "on average". * So back to the original sum, we can rewrite it: sum_a W_a(z_a) * prod_{side edges} P(..) * prod_{rectangles r} hyperedge(r) * (Q_1*Q_2 + Q_3*Q_4) Now imagine distributing that product over that final sum involving the Q's, to get a new sum that has a factor 2^{# rectangles} more terms multiplicatively. (but there are only poly(g) = O(1) rectangles, so this is only a 2^{poly(g)} = O(1) blowup in the number of summands) * Each one of these terms in the new, bigger sum, has a prod_rectangles in it. Either >=1/2 of the rectangles chose the Q_1*Q_2 when we distributed the product, or >=1/2 chose the Q_3*Q_4. That means we can either merge all row edges or merge all column edges, and one of those wil decrease the total number of weights on edges by a 4.5/6 factor. This is the heart of why D&C makes progress; D&C is supposed to reduce one instance to simpler instances, and "simpler" in this case means decreasing the total weight on all edges (here by a 4.5/6 factor). This overall looks like a recursion with branching factor 2^{poly(g)} = O(1), but in reality the branching factor becomes poly(m) when you account for the trick in the proof to reduce to the case of 3 bits on each edge. In any case, there are more steps to get everything to work, but the above gives some taste of how the Divide & Conquer works. If you optimize the right way to choose g to not be a constant but a slow enough growing function, you get runtime exp(O(n / log^c n)), but for a tiny c. If you replace the eight square identity with something fancier, and replace the black-box invocation of the sparsification lemma with a more white box version that adds in some more ideas, you get down to the exp(O(n loglog n / sqrt(log n))) in the paper.

The ETH repository has a paper where it appears an Anthropic internal model independently disproved the Exponential Time Hypothesis?

In 1979, Howard Garns published a number puzzle in a New York magazine under the name "Number Place." He died in 1989 without ever knowing it would become a global obsession played by 100,000,000 people daily. He never saw a single dollar from what became Sudoku. The puzzle he invented has exactly 6,670,903,752,021,072,936,960 valid completed grids. Mathematics can solve any one of them in milliseconds. Most humans cannot solve the hardest version in a lifetime. The university test that ended academic careers [Section 7] - A mathematics professor at the University of Tokyo used Sudoku as an entrance filter in 1986. Students who could not solve an expert-level grid were removed from the program. No second chance. No appeal. His logic was simple: if you cannot apply pure deduction to a 9×9 grid, you cannot handle research-level mathematics. The puzzle was never a game. It was a diagnostic. The number that makes computer scientists go quiet [Equation 2] - N = 6,670,903,752,021,072,936,960 valid completed grids. In the worst case the search space reaches 9^81. A human trying random guesses has mathematically zero chance of solving an expert puzzle. The secret most players never discover [Section 9] - Every valid Sudoku has exactly one solution. Not two. One. Guessing is never necessary - it only means the solver missed a logical constraint that already forced the answer. Every stuck position has a move. Mathematics guarantees it. What Algorithm X does to the hardest puzzle ever designed [Section 8] - Backtracking search, constraint propagation and Dancing Links applied simultaneously. The hardest Sudoku a grandmaster needs hours to crack - the algorithm solves it before the question fully loads. Under one millisecond. Every time. Working Note No. 24, September 2026 Discrete Mathematics, Logic and Algorithmic Problem Solving Series save this

This guy used Grok Bot to build an asynchronous arbitrage system on Polymarket Result: +$1,340,486 It makes 340 trades per active hour in crypto Up/Down markets, combining market making, pairing, and a directional residual Several Grok Bot AI agents work together as one algorithm, making $7,406 per day: 1. Buys Up and Down at different times It places BUY limit orders on both sides of the market in advance and waits for temporary price dislocations The goal is: Avg Up price + Avg Down price < $1 2. Keeps a directional residual alongside the matched position when it sees an edge Its valuation model uses external spot/perp data, the distance from the opening price, time remaining, and CLOB liquidity It builds a directional residual when: p_model(Up) > Up price + fees → BUY Up This trader’s Polymarket account: The system’s main edge comes from combining asynchronous pairing with short-term repricing: > It buys each side at different points as the market moves > Locks in an edge on low-cost Up + Down pairs > Keeps additional directional exposure where its model identifies mispricing

Algorithms — Free PDF (472 Pages!) Want to strengthen your problem-solving skills and become a better programmer? This 472-page Algorithms book is a great resource for anyone interested in understanding how algorithms work and how to solve computational problems efficiently. What you can learn: ✅ Algorithm design and problem-solving ✅ Time and space complexity ✅ Efficient approaches to computational problems ✅ A stronger foundation for Data Structures & Algorithms (DSA) ✅ Skills useful for coding interviews and competitive programming Perfect for Python developers, computer science students, software engineers, and aspiring programmers! Get the free PDF here:

Two rival AI laboratories have independently claimed to overturn one of theoretical computer science's deepest assumptions. OpenAI and Anthropic both report algorithms that would refute the Exponential Time Hypothesis. Anthropic's claimed algorithm counts solutions to 3-SAT in subexponential time: T(n) = 2^{O(n log log n / √log n)} The mathematical surprise is that log log n / √log n approaches zero. If correct, this would overturn an assumption used in decades of complexity theory. Both laboratories have released formal proof material, but independent verification is still pending. The real question now is whether these remarkable AI-generated arguments survive mathematical scrutiny.

~14 hours ago, 𝕏 updated the algorithm (again). There are a few new things worth noting: • New "user debias" model: adjusts engagement based on how "generous" each viewer is • Likes from people who like everything will start counting less • Engagement from "picky" users who rarely interact will count more • Engagement pods and "like for like" groups got weaker • Some general search improvements • Media (video and image) are now tracked as their own signals What still matters most: • Posting high-quality, original content • Replies (5x) and quotes (5x) are weighted far above likes (0.5x) • Shares via DM (5x) and copy link (20x) are the strongest positive signals • A predicted follow is worth 4x • Reports, mutes, blocks, and "not interested" are heavily negative • Posts older than 48 hours drop out of For You • Posting too much in a row decays your reach TL;DR: regardless of algo changes, just focus on producing content that is unique to you.

The algorithm will probably hate me. And some of you, too. But my honest opinion is that most of you shouldn't aim for the rewards program. I know, it's tempting, and I don't neglect the fact that it wouldn't be a nice side income either. However, for a small builder, hunting for impressions in order to make money directly isn't a great return on investment and creates a lot of noise. I'm not saying this to upset anyone, but I think there are better ways for founders to spend their time.

Replaced an n^1.5 algorithm with an n^2 algorithm this morning and everything got faster for n &lt; 20K because the former required a single allocation. I wish my undergrad professors would have said something like “you can ignore all this stuff under memory pressure”.

9:50 to 10:10. A macro is 20 minutes where the algorithm has one job. Fill a gap or take a pile of stops. Then it goes quiet. Mark the gap &amp; the stops before the window opens.

X Survival Guide #195 1. Make a post. 2. Write 200 + replay 3. Check your views. 4. Realize you’re still in your little bubble. 5. Try to understand the algorithm. Fail. The algorithm will test your patience. Stay sane, soldier. 💪🏼

Not to start a gender war, but… Why does it feel like the girls are the ones starting most of the fun trends on CT? 🤭 Boys, what’s your defense?

SMALL ARTISTS WHERE ARE YOUUU ‼️‼️ I KNOW YOU’RE OUT THERE 👀 come drop your art below so I can go crazy over your work!!! let’s find more amazing artists before the algorithm hides us again 😭 #artshare #smallartists #artmoots

google shopping is a GOLDMINE for any ecom brand… but only if you know how google picks who’s product shows up most brands never learn it. they just raise bids and pray so i broke down the ENTIRE algorithm in one video: - how google picks who shows - the 3 ad rank factors - why your feed IS the targeting - the title formula - the title fix that revived a dying product - 3-5 titles per product - pmax vs standard shopping - your bestseller in its OWN campaign - feed errors that make you invisible - testing on $30-50 a day - what kills shopping accounts bookmark it. watch it with your merchant center open

MIND-BENDING FACT: OpenAI announced Monday that its AI proved the Exponential Time Hypothesis (ETH) is false — a foundational pillar of theoretical computer science since the 1970s. The ETH holds that NP-complete problems cannot be solved faster than exponential time; cryptographic security, algorithm complexity bounds, and the theoretical ceiling on AI planning have all been calibrated against it being true. One model, running in collaboration with academic partners, disproved it. Simultaneously, OpenAI disclosed it finalized a proof of Yang-Mills existence on October 16 — one of the seven Millennium Prize Problems, each carrying a $1 million Clay Mathematics Institute award. Navier-Stokes was solved September 8. Two Millennium Prize Problems in 49 days. Five remain.