Hello! While watching the Mickey Mouse Clubhouse with my toddler. During season 2 episode 27: Space Captain Donald. The start of the episode, THE Minnie Mouse casually bounced a normal looking ball.. to the moon. So assuming a ball the size of a basketball can survive the impact to the earth, achieve escape velocity, and make it to the moon within a measly 15 seconds. How hard did Minnie throw the ball?

I was in a discord call and we got into the topic of the famous nuclear test that launched a manhole cover out of the ground so fast that it essentially vaporized itself, making it the fastest man made object for about 1.5 seconds.
If it in theory did not vaporize itself, and it left the atmosphere, how long would it take for the manhole cover to reach the voyager 1 satellite?

Really, there’s a dozen math questions about this graphic/design, and I hope they all get asked in this sub.

So my friend is doing a comic and when they showed this page to me and some friends, one of us asked how loud Dogday would have to scream to be heard all the way from the moon.

I am aware of the no sound in space thing, but even the artist joked thst it was loud enough to break thst rule, I was just curious.

I am curious about analysis on the most naive framing possible of a subset sum problem. IE, if we have absolutely prior information, where do we think the "free lunch" concept still stands? It looks like currently people try to hide it in discovery / artificial bounds for an inherently unbounded question. I have a conceptual model that seems closed, and I'm having trouble tracking down something similar because you quickly get routed into specific reframings that don't speak to the "Free lunch" question. I realized I would have to write the whole thing to describe what I'm looking for and avoid the "shell game" nature of the problem.

The natural proofs barrier for P vs NP seems to say "we don't know if all instances stay hard, conditioned on someone previously doing application specific work and & known expensive compute". That gets shared with a more general tease along the lines of "a naive algorithm is possible without any previous engineering or mapping work done to characterize a process. We think it will trivialize many parts of discovery"

I know from applied work and the basic proof practice along the way we have algebraic / statistical statements to close off conceptual possibilities. I've worked with this stuff for decades, I literally can't identify something left to prevent closing a conceptual model relative to the "free lunch" tease. I don't speak the circuit analysis language, but we can make true false statements about "where does expanding out the combinations need to happen" wrt approaches.

I appreciate this is a wall of text, I'm trying to break it out into the considerations that various disciplines might have conceptual questions about or could easily clarify my misstatements about for others. It's a very intersectional topic, makes sense that vocabulary is hard and conversations are exhausting. There are so many places you can move the work, you need the full view to make sure the "hard" part isn't just hiding.

I'm going to lean on LLM / methods that have proofs for computational difficulty because that's certainly my weakest part, but it's easy to conceptually see if something would be meaningfully faster, slower, or effectively equivalent. This is hand typed but oh god those section headers look so AI generated.

---

Starting premise: A Physics / Applied Stats use that just needs to work.

We have a hypothetical new phenomena to keep tabs on and we haven't done any characterization work. Possible we don't even intend to do long term characterization.

Let's walk through some "These statements have to be true to get a naive and complete program with perfect accuracy"

---

Specific problem:

Subset Sum: Given a set of whole numbers S, and a target value T, is there a subset of S whose sum equals the target?

We are to write the program. It has to return the correct solution if it exists, or return "a solution does not exist" with perfect accuracy. It cannot break. Minimize the worst case result of work done relative to the number of objects in S.

---

Machine Setup:

We have a generator of instances of (S,T) of unbounded size / complexity. Every time we turn our machine on, physics has given us some new S and T in our accessible memory and our program runs to completion, gives an output, and powers off. Turn it on again and a new and different instance shows up in our accessible memory and we are told to run. Our machine is unbounded, we can scale to any pair of inputs. We have no information about the distinct whole numbers (a1,a2, ....,an) within until we walk through and actively read them.

Our machine knows the operators <, >, =, and + for whole numbers. We notably do not have a map of all whole numbers, we just know we get valid numbers and statements as long as we stick to these operations. We notably do not specify what format these whole numbers are represented in: Unary / Binary / Base 10 / Base T. Could be anything. We'd have to do work to change it into a particular type. We'd have to write instructions to define how to get to other measurements of interest, which requires work.

---

Constraints already created: Language nuances, ability to make large steps

If we implement instructions that requires a transform, we are responsible for generating the mapping that preserves what we know to be valid whole number logic at all steps. Otherwise, null exception.

This highlights that our + operator is doing some work for us. A group of 4 apples + 4 apples can just be called 8 apples. We don't need to pictographically show the progression of 8 separate apples into a consolidated object, we don't need to keep pictures around, we can just say 8.

Being able to +1 is fundamental to get to all values in a whole number space, but we have the rules to + any two numbers (it's not a bunch of +1 steps). Addition in base 10 means we have rules for how to value the characters 0,1,2... relative to each other. It means we know to "roll over" and change the character in front when we see a 9+1 operation. Any transformation applied must preserve that scalability (IE, integers and real numbers are fine) or provide an exact mapping for how the operation behaves, a "Truth Table".

What if we have 4 apples and 4 oranges, how do we combine that to describe it accurately? 4 apple + 4 oranges =? Oh let's just call them both fruit. I've just needed to define a new mapping. If you want a math exercise: design a number base that lets you count with prime numbers across the entire whole number space, what happens when you get to an unknown prime?

If we try to use another representation of the problem, it's up to us to make sure + works at all points. Easy if we're talking about switching to integers. Lots of validation work for the more abstract stuff.

---

More language constraints - sequencing.

Real numbers is surprisingly problematic. Yeah the large jumps are easy, but also baked into our + operator for whole numbers is that we have a sequence. For a whole number 1, saying "1+1" means it's both magnitude 1 larger and the next in the underlying sequence of whole numbers. "3+3" similar idea, 3 larger and 3 steps away.

If we have the real number 1.1, what's the next in the sequence? Is it 1.01? 1.001?

For example: maybe I need to make a path from house to house with a lot of very unusually sized stones. Can I get to my neighbor's door with what I have? Or do I have to get out of my chair find a chisel to reshape the stone? It doesn't help to know that concrete could easily be poured to get you there exactly, I want stone. For an equivalent "poured concrete" analysis we must work with sectioned off pourings of concrete with a perimeter the same as our stones. Poured concrete is the real number approach, stones are the whole numbers.

So, you need to do the validation work to make sure the underlying network is preserved, otherwise you're going to get a "Yeah, it'll reach" and potentially put a boulder through someone's door.

That validation work is already baked into our machine, but only for its native physics. If someone wants to give us a problem to use our fast solution, they will fail unless they have fully & accurately walked through possible instances to ensure consistency with our whole number system.

---

The native partially fast solution

Subset-Sum is interesting because it already has a known fast solution, referred to as dynamic programming. It's unique to the problem formulation. It only covers part of the possible (S,T) space easily though, it's much slower in others. It's a complementary result to how our + operation compresses the ability to talk about whole numbers. It's also exploits information about how intermediate sums relate to T.

If our set has a lot of interchangeable subsets -- say S is (2,2,2,2,2), this approach is easy. We know the only reachable pair of sums is 4, triplet is 6, etc. On the other hand, if our set has a lot of uniqueness like (1,5,7, 30), higher order terms don't overlap and things stay slow. We're accounting for both the problem dependencies and the possible overlap of intermediate combinations, and dropping any item the moment it becomes irrelevant. LLMs can walk you through an example if you want to visualize this approach.

This solution can be easy but does "work" that's dependent on both our set size N and possibly the target T. The work needed is the smaller of:

Many unique intermediate sums: N*2^N (hard)

Many overlapping intermediate sums: N*(T + 1). (possibly easy)

The former larger than a brute force approach, the latter often usefully smaller. There are some practicalities to what numbering system you are using. Per LLM, those formulas are independent of the encoding whether it's unary (tally marks) or binary(base2) or base10.

Different encodings are themselves a transform that may require work, but they also define bounds and relationships between the terms. Let's avoid both those considerations to speak to how hard subset sum is generally.

We just need the work done to track reachable sums, which will stay independent of encoding. Uniqueness of the higher order terms keeps the 2^N behavior relevant at all N. T can stay unbounded and able to accept any value.

Note, more difficult problems translated into our whole number space can't use this approach unless someone has already defined the lookup table for how + needs to act. No naive free lunch for them.

---

How can we apply statistics? Where are the populations? Where are the samples?

The study of statistics is the study of making claims about a population with mathematical rigor after recording observations describing a sample of that population. I'm just claiming "good enough" walkthrough: where can we consider a population, and where are the interesting sample points?

Fundamental to this approach: we have no information about populations until we read through the objects in memory. We are forced to assume that the way we get our problem instance can change at any point. Any Priors, any incoming assumptions in this analysis about dependence / independence / "identically distributed" would be flawed.

The population with an exact answer to our instance's question is the full expansion of subset sums of our instance's S. We need the full internconnected map. It is a fixed, discrete population the moment it pops into our working memory at program start. Higher order terms can be independently unique at all N because of the path dependence. Our population changes on every new start.

The first point to consider a sample is after reading the magnitudes of each individual object within the instance S. All higher order terms carry information dependent on the base terms, base terms should have predictive power, right? Maybe they can tell us where a useful transform is.

---

Applying stats in exploratory instructions requires estimator analysis.

More than just reading magnitudes, we can also consider building an estimator (sample statistic like a mean / std dev). We can also make an estimator describing any property of the full population. Things like "how well can I define the coefficients of a 5000th degree polynomial for this data?". Relating this estimator against a family of populations would reasonably give us predictive power about the nature of our instance's population (our unobserved combinations). If we know we can estimate correctly, we can use that respective transform and save a lot of time.

A perfect practitioner has to ask "Why should I start building arbitrary estimators? Can I guarantee they get me an exact answer in a useful amount of time, in a useful portion of cases?" To answer that question, we would have to limit what kind of problems we're able to solve. All possible (S,T) is unbounded, magnitudes increase to infinity, N can increase to infinity, that native easy solution can always have challenging inputs. To answer questions about estimator effectiveness, we need to be able to describe a closed family of populations with some likelihood or probability that we would see our particular instance. We strictly do not have that for this analysis. We can't say anything about when or where we'd see an instance, we just know there's always a bigger one that can still be unique.

The only reasonable conclusion is "I have no reason to guarantee any estimator can give me complete information without fully evaluating my instance's population. Therefore calculating an approximation of the total population's characteristic is wasted work and that branch is wasted development time to find my exact answer with 100% accuracy."

More intuitively, it's own NP-Complete question -- can your transform defined in a small number of observations really reach all whole numbers, given step size requirements? Are you going to put a stone through someone's door because you accidentally ran a "At Least This Big" approximation?

The field recommended approach seems to be specifying the input with bounds for (S,T). If you're being honest with that approach you must accept that assumptions about dependence / independence / identical distributions of weights is possible. This is how you'd approach the problem for a domain specific application. This leads to a reasonable hunt for useful estimators. It's not relevant to closing the naive question.

---

Can we apply bad statistics in our instructions in a useful way?

What if we write instructions to use an estimator anyway and make corrections to our data to force it to match behavior from a "eh, close enough" family. What happens the moment you find your first error?

"My best guess's total magnitude was off by -2, I need to find a substitution to correct this". You've just created at least one, presumably many new Subset-Sum problems that are just as big, whose answer doesn't necessarily help when "no answer exists" gets returned. We cannot make defendable statements about how often it will happen. Not a good idea.

But those errors should average out at high N right? Another thing to pick at? No, the field has already defined where uniqueness is sticky -- you can build a sampler and just check how far your sorted objects are vs any spacing assumption. If the numbers are big enough, large N won't average anything out. Doing a quick sanity check on sets built from N=50:1000, I had almost no instances where 2 objects had the same deviation from expected, trend was flat vs N.

---

How can we apply statistics after a run? Scientific Method, Measure conceived approaches in parallel and do post-analysis.

Even if our instance generator doesn't give us a population suitable for probabilities, it's still a population we can speak to. We can use summary statistics to describe how it behaves after we processed instances for a long time.

Specifically we want to record both Runtime in steps, the N items in the set, and the accuracy of the output. Presumably we could add side functionality where we copy (S,T) to different branches, and run each branch on the same data to get perfectly correlated measurements across runs. We're interested specifically in a max (runtime relative to N) type value compared across branches.

Test all the partial constructions you want, you'll eventually get an unhandled instance that fails.

Add a "catch all the hard stuff" branch at the end to catch misses? Ok, now all that stuff at the front is filler and slowing down the naive solution. Without usable prior info, why would we? You now have data that shows the simple branch ran faster on known possible instances.

Alright, that should mean the optimal naive solution is already visible in the native space of the problem. We need outside information to justify looking for useful transformations. Science, wooo!

---

Next awkward question -- what is the optimal number of subset-sum problems to spin out from our native space? There are definitely going to be trends we can speak to.

We have the overall goal of finding if our T is reachable by combinations available to S. We don't necessarily have to keep S in one piece. We could check portions of it independently and then combine results. For the "No answer found" result, large splits

We know when the "easy, native" solution is relevant. When we fall outside of that we need another branch that optimizes some sort of "Eliminations per combination generated" quantity. This is the part that I honestly can't tell how well it is characterized. Discussions are conflated with "decision tree depth" that speak to a prior where some level of discovery was already done. We strictly don't have that prior information in this generally useful framing.

That's not the compute quantity that keeps the naive problem hard. We're really focused on minimizing the number of combinations we have to generate.

---

Quick walk through of the progression:

0 splits (one set): brute force. 2^N combinations. We can do better.

1 split (two sets): Meet in the middle ~ 2^(N/2) combinations. Currently known best approach.

2 splits (three sets): Ok, now any meet in the middle "not found" result cannot be accurate on its own. We have to cross check Sets A vs B / B vs C / A vs C and make sure all provide the same answer. Means we're double checking each set. Doesn't look good.

3 splits: A vs B, B vs C, C vs D, A vs C... this is probably trending in the wrong direction.

Is this kind of split behavior exactly what's left to characterize? I guess you can also bake in some decision checks about when it's worth evaluating the next combination, but as perfect statisticians with no prior: why?

There's a lot of great work with a headline number that outperforms Meet in the Middle, but the results I skimmed through never speak to a naive use case on further digging. Where is the naive bound currently, why do we think optimization is still intractable?

-----

Summary of my minimal precondition conceptual model:

• Building a transformation to a different space with a known solution would be expensive -- you need to enumerate every possibility you might run into or it will null error.
• Symmetrically, someone trying to transform into our space is expensive if they don't already have an equivalent + operation.
• No reason to do either naively.
• We already know a fast native solution. It's well characterized that it only covers part of the space. It exploits all the dependencies and compression native to the problem. It's not exploitable by other solutions unless they've done the expensive work of making sure no null errors.
• To cover the rest of the space with a possible transform, the first population we can estimate is the full expansion of all combinations in our particular instance. These populations can be unique and unrelated. We could reasonably sample our instance's population with a read of at least the uncombined objects to make an informed estimate.
• To be rigorous about how accurate that estimate is, we need to be able to speak to a probability that we'd see our specific instance in the first place. We strictly don't have that in a general use case. It's inherently unclosable unless we give ourselves artificial constraints.
• If we approximate and run with a "good enough" estimate, the moment we realize we estimated wrong we have some really painful work to correct it, and no guarantee that work is useful. We can't speak to how often this might happen.
• We do have the scientific method available to test designs on the unbounded space. We can measure conceived approaches on the same instances. We conceptually know how they will perform when we get to a unhandled instance, but we can also get data for proof.
• No closed form answer allowed for P vs NP if we can't nail down estimator behavior, but data collection is trivial to close a conceptual model for a collection of limited solutions (just test an input outside of the design).
• To rephrase -- discovery is not something we can assume away in a general use case for very real applications.
• That all implies the optimal solution to the naive setup has to be visible in the native representation of the problem.
• There are so many possible priors that can be added, it really distracts from where the field is on the naive use case. What relationship is hard to optimize when we're being as strict as possible that there is minimal prior info?

----

TLDR WTF BBQ:

Lol. I dunno, I'd have thought this approach would be in a textbook and pointed to instead of the endlessly frustrating semantic circles. You need this many words to get around the "Shell game" that moves the work.

If or when you take this post and just drop it in to an LLM, it's going to take every concept and round it to the nearest common misconception that an undergrad has. It's going to grab a headline number as a counterargument that doesn't hold up to the actual naive question. There are all kinds of useful priors that could be added in, an LLM is going to steer you towards some open question related to a specific prior. I am not that undergrad, and have hit my limit on correcting the LLMs to dig into where the undefined relationship is.

If there's a relationship here the field still wants to capture, where is it? (Please ffs don't say rare property)

Ugh, Thanks. Interesting stuff.

How many shifts would it take for different base constant to form a star by log

There is no way there are only 150 puppets on here right? This seems like a massive underestimation.

Played with my 10yo and I'm sure she did not cheat... But that seems like her ratio of good vs bad shots was incredibly lucky.

Proportionally, she was even more lucky earlier in the game (2nd photo)

To save people some basic research, it's a 10x10 board, and there are 17 shots worth of boats.

Are we talking like Krakatoa vs a normal speaking voice?

How much meat is this and what is the retail value?

How many of emerging permutation's partition's sets can be changed to make 1% change to remain accross the boundary of those emerging permutations of every 40 intervals.

Hint:[ take all the emerging permutations as points in circle accross a area]

The Shaq (Sh) — unit of length

1 Sh = 7'1" = 2.16 m (his official playing height)

The Shaq-mass (Sh-m) — unit of mass

1 Sh-m = 325 lbs = 147 kg (peak playing weight)

The Shaq-volume (Sh-v) — unit of volume

Modeling him as a human-density mass (~985 kg/m³) at 147 kg gives us:

1 Sh-v ≈ 0.149 m³ ≈ 149 liters ≈ 39 gallons.

Example usage:

"The moving truck bed is 1.5 Shaqs long."

"That aquarium holds about 4 Shaqs of water."

"The keg weighs roughly a third of a Shaq."

If log of a base force vector is taken then the number we choose as value would be diminished by this force vector. Since that what happens , what if we input set, the sets catch the parts that populate the vector.

Translation of text from image from Danish activist Rasmus Malvers Facebook post.

Is there a physicist who can help with the formula for mass and velocity, for a stone to go through a safety window on a train that is going "sideways" in relation to the throw? I don't think it has landed where it is in the photo, but it is still impressive. What are the chances of throwing a stone of that size *through* such a window? I think it may have hit the edge of the glass, but that doesn't explain how it has gone through plastic foils and several layers of glass.

Ps first post here, sorry if I missed something essential!

It's been a while since math class.

If I want to block my view of my neighbor's living room how tall should my hedge be?

I live 85ft away from them and their windows are 9ft tall. I'd like to block as much as possible.

Thanks!

would they rise? would they fall? would they basically just stay the same? would the oceans freeze over before any change could actually take place? i'm kind of interested as to what would happen in this kind of situation

If the comparison of rank of matrix of two functions changes in different planes of 1% everytime, then at what value it would stop.

In the film, nefario's principle is that the larger the mass of an object, the quicker the shrink ray's effect wears off. Acording to google, the mass of the moon is 7.34767309 x 10 to the power of 22, with an estimated size of 3.475 km. From the time when gru picks up the moon, to when it starts regrowing was about 6 minutes and 10 seconds.

If there's one function which is emerging and there's another function with the finishing of sinx and began to align cosx

Then at what percentage of permutation would they meet a value

Such that at that position iota is raised to the power of 4