| {: , : , : , : infinitesimal change in $y$ produced by the change in $x$\infinitesimal change in $x$\infinitesimal\Take the point $(a,f(a))$; then add an infinitesimal amount to $a$, $a+dx$, and take the point $(a+dx,f(a+dx))$, and draw the line through those two points.\ However... \fractions\obvious\, : {: , : , : , : , : , : 0.7, : null, : null, : null, : , : false, : null, : false, : null, : true, : 0.7}} |
| {: , : , : , : fence post\, : {: , : , : , : , : , : 0.35, : null, : null, : null, : , : false, : false, : false, : null, : false, : 0.35}} |
| {: , : proof\, : , : , : {: , : , : , : , : , : 0.35, : null, : null, : null, : , : false, : null, : false, : null, : true, : 0.35}} |
| {: , : , : , : Proofs from the book\ paper published a few years earlier by Josef Hofbauer. On Robin's list, the proof most similar to this is number 9 (EDIT: ...which is actually the proof that I read in Aigner & Ziegler). When $0 < x < \\pi/2$ we have $0<\\sin x < x < \\tan x$ and thus $$\\frac{1}{\\tan^2 x} < \\frac{1}{x^2} < \\frac{1}{\\sin^2 x}.$$ Note that $1/\\tan^2 x = 1/\\sin^2 x - 1$. Split the interval $(0,\\pi/2)$ into $2^n$ equal parts, and sum the inequality over the (inner) \"gridpoints\" $x_k=(\\pi/2) \\cdot (k/2^n)$: $$\\sum_{k=1}^{2^n-1} \\frac{1}{\\sin^2 x_k} - \\sum_{k=1}^{2^n-1} 1 < \\sum_{k=1}^{2^n-1} \\frac{1}{x_k^2} < \\sum_{k=1}^{2^n-1} \\frac{1}{\\sin^2 x_k}.$$ Denoting the sum on the right-hand side by $S_n$, we can write this as $$S_n - (2^n - 1) < \\sum_{k=1}^{2^n-1} \\left( \\frac{2 \\cdot 2^n}{\\pi} \\right)^2 \\frac{1}{k^2} < S_n.$$ Although $S_n$ looks like a complicated sum, it can actually be computed fairly easily. To begin with, $$\\frac{1}{\\sin^2 x} + \\frac{1}{\\sin^2 (\\frac{\\pi}{2}-x)} = \\frac{\\cos^2 x + \\sin^2 x}{\\cos^2 x \\cdot \\sin^2 x} = \\frac{4}{\\sin^2 2x}.$$ Therefore, if we pair up the terms in the sum $S_n$ except the midpoint $\\pi/4$ (take the point $x_k$ in the left half of the interval $(0,\\pi/2)$ together with the point $\\pi/2-x_k$ in the right half) we get 4 times a sum of the same form, but taking twice as big steps so that we only sum over every other gridpoint; that is, over those gridpoints that correspond to splitting the interval into $2^{n-1}$ parts. And the midpoint $\\pi/4$ contributes with $1/\\sin^2(\\pi/4)=2$ to the sum. In short, $$S_n = 4 S_{n-1} + 2.$$ Since $S_1=2$, the solution of this recurrence is $$S_n = \\frac{2(4^n-1)}{3}.$$ (For example like this: the particular (constant) solution $(S_p)_n = -2/3$ plus the general solution to the homogeneous equation $(S_h)_n = A \\cdot 4^n$, with the constant $A$ determined by the initial condition $S_1=(S_p)_1+(S_h)_1=2$.) We now have $$ \\frac{2(4^n-1)}{3} - (2^n-1) \\leq \\frac{4^{n+1}}{\\pi^2} \\sum_{k=1}^{2^n-1} \\frac{1}{k^2} \\leq \\frac{2(4^n-1)}{3}.$$ Multiply by $\\pi^2/4^{n+1}$ and let $n\\to\\infty$. This squeezes the partial sums between two sequences both tending to $\\pi^2/6$. Voilà!", "metadata": {"source": "stackexchange:math", "category": "technical_scientific", "subcategory": "research_papers", "language": "en", "difficulty": "medium", "clarity_score": 0.463, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.463}} |
| {"format": "qa", "instruction": "What's an intuitive way to think about the determinant? In my linear algebra class, we just talked about determinants. So far I’ve been understanding the material okay, but now I’m very confused. I get that when the determinant is zero, the matrix doesn’t have an inverse. I can find the determinant of a $2\\times 2$ matrix by the formula. Our teacher showed us how to compute the determinant of an $n \\times n$ matrix by breaking it up into the determinants of smaller matrices. Apparently there is a way by summing over a bunch of permutations. But the notation is really hard for me and I don’t really know what’s going on with them anymore. Can someone help me figure out what a determinant is, intuitively, and how all those definitions of it are related?inputoutputYour trouble with determinants is pretty common. They’re a hard thing to teach well, too, for two main reasons that I can see: the formulas you learn for computing them are messy and complicated, and there’s no “natural” way to interpret the value of the determinant, the way it’s easy to interpret the derivatives you do in calculus at first as the slope of the tangent line. It’s hard to believe things like the invertibility condition you’ve stated when it’s not even clear what the numbers mean and where they come from. Rather than show that the many usual definitions are all the same by comparing them to each other, I’m going to state some general properties of the determinant that I claim are enough to specify uniquely what number you should get when you put in a given matrix. Then it’s not too bad to check that all of the definitions for determinant that you’ve seen satisfy those properties I’ll state. The first thing to think about if you want an “abstract” definition of the determinant to unify all those others is that it’s not an array of numbers with bars on the side. What we’re really looking for is a function that takes N vectors (the N columns of the matrix) and returns a number. Let’s assume we’re working with real numbers for now. Remember how those operations you mentioned change the value of the determinant? Switching two rows or columns changes the sign. Multiplying one row by a constant multiplies the whole determinant by that constant. The general fact that number two draws from: the determinant is linear in each row . That is, if you think of it as a function $\\det: \\mathbb{R}^{n^2} \\rightarrow \\mathbb{R}$ , then $$ \\det(a \\vec v_1 +b \\vec w_1 , \\vec v_2 ,\\ldots,\\vec v_n ) = a \\det(\\vec v_1,\\vec v_2,\\ldots,\\vec v_n) + b \\det(\\vec w_1, \\vec v_2, \\ldots,\\vec v_n),$$ and the corresponding condition in each other slot. The determinant of the identity matrix $I$ is $1$ . I claim that these facts are enough to define a unique function that takes in N vectors (each of length N) and returns a real number, the determinant of the matrix given by those vectors. I won’t prove that, but I’ll show you how it helps with some other interpretations of the determinant. In particular, there’s a nice geometric way to think of a determinant. Consider the unit cube in N dimensional space: the set of N vectors of length 1 with coordinates 0 or 1 in each spot. The determinant of the linear transformation (matrix) T is the signed volume of the region gotten by applying T to the unit cube . (Don’t worry too much if you don’t know what the “signed” part means, for now). How does that follow from our abstract definition? Well, if you apply the identity to the unit cube, you get back the unit cube. And the volume of the unit cube is 1. If you stretch the cube by a constant factor in one direction only, the new volume is that constant. And if you stack two blocks together aligned on the same direction, their combined volume is the sum of their volumes: this all shows that the signed volume we have is linear in each coordinate when considered as a function of the input vectors. Finally, when you switch two of the vectors that define the unit cube, you flip the orientation. (Again, this is something to come back to later if you don’t know what that means). So there are ways to think about the determinant that aren’t symbol-pushing. If you’ve studied multivariable calculus, you could think about, with this geometric definition of determinant, why determinants (the Jacobian) pop up when we change coordinates doing integration. Hint: a derivative is a linear approximation of the associated function, and consider a “differential volume element” in your starting coordinate system. It’s not too much work to check that the area of the parallelogram formed by vectors $(a,b)$ and $(c,d)$ is $\\Big|{}^{a\\;b}_{c\\;d}\\Big|$ either: you might try that to get a sense for things.metadatasourcestackexchange:mathcategorytechnical_scientificsubcategoryresearch_paperslanguageendifficultyhardclarity_scorelogical_leap_foundsteps_support_conclusioncounterargument_foundjudge_sourceheuristic_fallbackcode_checkedcode_okmath_checkedmath_okverifiedconfidence_weight |
| formatqainstructionDoes $\\pi$ contain all possible number combinations? $\\pi$ Pi Pi is an infinite, nonrepeating $($ sic $)$ decimal - meaning that every possible number combination exists somewhere in pi. Converted into ASCII text, somewhere in that infinite string of digits is the name of every person you will ever love, the date, time and manner of your death, and the answers to all the great questions of the universe. Is this true? Does it make any sense ?inputoutputIt is not true that an infinite, non-repeating decimal must contain ‘every possible number combination’. The decimal $0.011000111100000111111\\dots$ is an easy counterexample. However, if the decimal expansion of $\\pi$ contains every possible finite string of digits, which seems quite likely, then the rest of the statement is indeed correct. Of course, in that case it also contains numerical equivalents of every book that will never be written, among other things.metadatasourcestackexchange:mathcategorytechnical_scientificsubcategoryresearch_paperslanguageendifficultyeasyclarity_scorelogical_leap_foundsteps_support_conclusioncounterargument_foundjudge_sourceheuristic_fallbackcode_checkedcode_okmath_checkedmath_okverifiedconfidence_weight |
| formatqainstructionWhy is $1 - \\frac{1}{1 - \\frac{1}{1 - \\ldots}}$ not real? So we all know that the continued fraction containing all $1$ s... $$ x = 1 + \\frac{1}{1 + \\frac{1}{1 + \\ldots}}. $$ yields the golden ratio $x = \\phi$ , which can easily be proven by rewriting it as $x = 1 + \\dfrac{1}{x}$ , solving the resulting quadratic equation and assuming that a continued fraction that only contains additions will give a positive number. Now, a friend asked me what would happen if we replaced all additions with subtractions: $$ x = 1 - \\frac{1}{1 - \\frac{1}{1 - \\ldots}}. $$ I thought \: \\begin{align} x &= 1 - \\frac{1}{x} \\\\ x^2 - x + 1 &= 0. \\end{align} And voila, I get... $$ x \\in \\{e^{i\\pi/3}, e^{-i\\pi/3} \\} .$$ Ummm... why does a continued fraction containing only $1$ s, subtraction and division result in one of two complex (as opposed to real) numbers? (I have a feeling this is something like the $\\sum_i (-1)^i$ thing, that the infinite continued fraction isn't well-defined unless we can express it as the limit of a converging series, because the truncated fractions $1 - \\frac{1}{1-1}$ etc. aren't well-defined, but I thought I'd ask for a well-founded answer. Even if this is the case, do the two complex numbers have any \"meaning\"?)", "input": "", "output": "You're attempting to take a limit. $$x_{n+1} = 1-\\frac{1}{x_n}$$ This recurrence actually never converges, from any real starting point. Indeed, $$x_2 = 1-\\frac{1}{x_1}; \\\\ x_3 = 1-\\frac{1}{1-1/x_1} = 1-\\frac{x_1}{x_1-1} = \\frac{1}{1-x_1}; \\\\ x_4 = x_1$$ So the sequence is periodic with period 3. Therefore it converges if and only if it is constant; but the only way it could be constant is, as you say, if $x_1$ is one of the two complex numbers you found. Therefore, what you have is actually basically a proof by contradiction that the sequence doesn't converge when you consider it over the reals. However, you have found exactly the two values for which the iteration does converge; that is their significance. Alternatively viewed, the map $$z \\mapsto 1-\\frac{1}{z}$$ is a certain transformation of the complex plane, which has precisely two fixed points. You might find it an interesting exercise to work out what that map does to the complex plane, and examine in particular what it does to points on the real line.", "metadata": {"source": "stackexchange:math", "category": "technical_scientific", "subcategory": "research_papers", "language": "en", "difficulty": "medium", "clarity_score": 0.7, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.7}} |
| {"format": "qa", "instruction": "Examples of patterns that eventually fail Often, when I try to describe mathematics to the layman, I find myself struggling to convince them of the importance and consequence of \"proof\". I receive responses like: \"surely if Collatz is true up to $20×2^{58}$, then it must always be true?\"; and \"the sequence of number of edges on a complete graph starts $0,1,3,6,10$, so the next term must be 15 etc.\" Granted, this second statement is less logically unsound than the first since it's not difficult to see the reason why the sequence must continue as such; nevertheless, the statement was made on a premise that boils down to \. I try to counter this logic by creating a ridiculous argument like \, but this usually fails to be convincing. So, are there any examples of non-trivial patterns that appear to be true for a large number of small cases, but then fail for some larger case? A good answer to this question should: be one which could be explained to the layman without having to subject them to a 24 lecture course of background material, and have as a minimal counterexample a case which cannot (feasibly) be checked without the use of a computer. I believe conditions 1. and 2. make my question specific enough to have in some sense a \ (or at least a \) answer; but I'd be happy to clarify if this is not the case. I suppose I'm expecting an answer to come from number theory, but can see that areas like graph theory, combinatorics more generally and set theory could potentially offer suitable answers.inputoutputI'll translate an entry in the blog <a href=\" (\"Gaussians\") about Polya's conjecture, titled: A BELIEF IS NOT A PROOF. We'll say a number is of even kind if in its prime factorization, an even number of primes appear. For example $6 = 2\\cdot 3$ is a number of even kind. And we'll say a number is of odd kind if the number of primes in its factorization is odd. For example, $18 = 2·3·3$ is of odd kind. ($1$ is considered of even kind). Let $n$ be any natural number. We'll consider the following numbers: $E(n) =$ number of positive integers less or equal to $n$ that are of even kind. $O(n) =$ number of positive integers less or equal to $n$ that are of odd kind. Let's consider $n=7$. In this case $O(7) = 4$ (number 2, 3, 5 and 7 itself) and $E(7) = 3$ ( 1, 4 and 6). So $O(7) >E(7)$. For $n = 6$: $O(6) = 3$ and $E(6) = 3$. Thus $O(6) = E(6)$. In 1919 George Polya proposed the following result, know as Polya's Conjecture: For all $n > 2$, $O(n)$ is greater than or equal to $E(n)$. Polya had checked this for $n < 1500$. In the following years this was tested up to $n=1000000$, which is a reason why the conjecture might be thought to be true. But that is wrong. In 1962, Lehman found an explicit counterexample: for $n = 906180359$, we have $O(n) = E(n) – 1$, so: $$O(906180359) < E(906180359).$$ By an exhaustive search, the smallest counterexample is $n = 906150257$, found by Tanaka in 1980. Thus Polya's Conjecture is false. What do we learn from this? Well, it is simple: unfortunately in mathematics we cannot trust intuition or what happens for a finite number of cases, no matter how large the number is. Until the result is proved for the general case, we have no certainty that it is true.metadatasourcestackexchange:mathcategorytechnical_scientificsubcategoryresearch_paperslanguageendifficultymediumclarity_scorelogical_leap_foundsteps_support_conclusioncounterargument_foundjudge_sourceheuristic_fallbackcode_checkedcode_okmath_checkedmath_okverifiedconfidence_weight |
| formatqainstructionHow can I effectively manage a hobby game project? How can I successfully finish a hobby game project in my free time? How do I motivate myself to keep it up and drive right through to the finish without losing interest or motivation along the way?inputoutputThese tips apply to any hobby software project, and not just games. Keep in mind that some could be contradictory, and that's ok because we're not all motivated by the same things. Planning your project Start by planning You can do that by writing a Game Design Document (GDD), a Technical Design Document (TDD), and a Feature Backlog. Scale yourself back. Whatever your grand vision is, try and figure out what the smallest achievable portion is and do that. Making an RPG? Start with one quest and no NPCs. Making a platformer? Start with one level and no enemies. Start by creating a game that is stupidly simple And get it finished and published online somewhere. Remember that even something seemingly simple like pong could turn out to be quite complex if you're new game development, and starting with a simple game will show you whether you have the patience to take on a bigger project. Set tiny milestones. Having a goal like \"item system works in my RPG game\" is all well and good, but that implies a whole lot of under-specified functionality that you probably didn't even know you needed. What about \? Or, \ Set deadlines for your milestones. Keep them realistic and feel free to adjust them when you notice you over- or underestimated your capabilities. But don't just let them pass. Break that down again \"Implement Leaderboard View\" is not a sufficient task. What does that involve? Break it down - Create background artwork for leaderboard view Create class methods that fetch score data Create class methods that post score data Create a view controller which will display a back button, reload button, and a table view Implement the table view to load in the data from the model Seeing the picture in finer detail will reduce your chances of missing a key element of your implementation and will provide you motivation as you tick off each task. Prototype early. Before you sink a bunch of your hard-earned hobby hours into a game, figure out if it'd be fun first. There's nothing so dispiriting as working your ass off on something for dozens of hours only to find that the basic concept sucks. Develop something iterable. My favorite hobby software projects are the ones where the basic concept allows for later tinkering. Is your game like that? Can you ship something and then revisit it later and add cool stuff? Don't build an engine or a framework. You don't want an engine, you want a game. Don't worry about the framework-y, reusable bits until after your game is shipping. Once you start on the second game, then you can go back to your first and see if there's anything you could bring over. That's not to say that you shouldn't use sound software development praxis, but don't start by writing a Sprite class until you know what you need your sprites to do -- you'd be surprised how little it'll turn out to be. Start with a Hero class, then a Monster class, and then -- oh look! -- there's some common stuff! Organize and track your ideas You can use a physical notepad, a corkboard, whiteboard with sticky notes, a \"To-do\" Application (e.g. Things for Mac and ToDoList (free) for Windows.. Alternatively, you can jump onto sourceforge.net or codeproject.com to grab a to-do application.) You will have a lot of sketches, ideas, design information that really needs to be aggregated into one spot. Having an central location with your feature list will help you stay focused. Let your friends and family know about it You might be starting off your project and you could need a lot of focus for some time, letting people close to you know that you're busy and why might help them not be mad at you if you're not as available as you could. Shipping is a feature. You're never going to finish your game, you're only going to abandon it. What is the minimum amount you can do before you're not completely embarrassed to show your game to someone else? Chances are, you can do less than that and still…metadatasourcestackexchange:gamedevcategorytechnical_scientificsubcategoryengineering_tradeoffslanguageendifficultymediumclarity_scorelogical_leap_foundsteps_support_conclusioncounterargument_foundjudge_sourceheuristic_fallbackcode_checkedcode_okmath_checkedmath_okverifiedconfidence_weight |
| formatqainstructionWhat are good games to \ with? I believe that in order to become a good game developer, you need to make games. From a programmer's perspective , what are some good entry level games to get your hands dirty? What skills and challenges do each of these games teach you?", "input": "", "output": "The best game to \"earn your wings\" with? The one you completed. The list This one is based on some criteria of increasing difficulty (i.e. it is based on opinion, like many things). Some suggest that anything after Pac-Man, it is really up to you because, by then, you know enough and may want to focus on something specific. There is also a series of tips in the section Some words of wisdom that should be of interests. Guess the number\" / Hangman / Mastermind Basic interface, select data from a database. Choose-Your-Adventure Based on choose your adventure books , it is basically a simple text adventure game with an output like this: You are standing in a forest clearing in the middle of the night. You hear some wolves howl in the distance. Should you: a) make camp for the night b) go further north > _ Making such a game should teach you to make a gameloop, basic console input and basic scripting (you can push it and add data structures/make it data-driven instead of hard-coding everything in the program). It is quite simple to implement and easy for a beginner to jump into since you don't need a graphics engine to write the game. Advanced beginners would probably write a scripting engine. Tic-Tac-Toe / Rock-Paper-Scissors Turn-based gameplay, simple opponent AI or second player. Breakout / Arkanoid / Pong Easy game since you don't have much state to worry about (it's an array of brick values -- if you only have one brick color, it's an array of flags), there isn't any AI, and you get to do a little bit of physics to get the ball to bounce correctly. No real needs for sounds. Also: input handling, collisions, stable frame rate, score, levels. Solitaire / Minesweeper The rules are a bit more complex than Breakout and the interface to it is a lot different. It forces you to think about different methods of implementing a game. i.e, what works in one game isn't necessarily what you would use in another. They're event based rather than \. Tetris The art is colored rectangles, which even a total klutz can draw in Microsoft Paint. You don't need sound. The programming is relatively simple, but still requires a few key things: understanding the difference between the internal game state and what's drawn on the screen; being able to draw on the screen, period (probably involving sprites and blitting); being able to accept user input in realtime rather than just using getch() or scanf() where you have to wait for them. Since it is a very common game, lots of open source clones out there to rip apart if you get stuck. Also: Data structures and how they relate to gaming. Asteroids Bullets, space physics, toroid world. 1942 / Space Invaders / Gradius / R-Type / Shoot-em-up You can probably find some freeware tilesets to make this. Here the background is scrolling, you'll be using techniques for drawing stuff outside the boundaries of the visible screen. You also tend to have dynamic enemy and bullet spawns, so you'll need to learn to clean up after yourself (i.e. get rid of enemies and bullets that leave the screen). Simple platformer / pinball game / Super Mario Bros The scrolling is under player control and not automatic. You also have to deal with gravity and all the fun collision stuff that goes along with it (like not falling through the floor just because you were a few pixels above in the last frame and want to move to a few pixels below in the next frame). Also note that gravity is conditional: it affects the player and some enemies, but typically not the platforms or floating coins or whatever, which is a bit different from the real world. For an extra challenge: add irregular sloped terrain and parallax. Bomberman / Pac-Man / Nibbles / Snake This one is nice because you get to work on a little bit of AI. Having the ghosts follow the player (but not too well - you want the player to have a chance) can be quickly implemented, and you will have a fun little game that you can tweak and show off to friends and family…metadatasourcestackexchange:gamedevcategorytechnical_scientificsubcategoryengineering_tradeoffslanguageendifficultymediumclarity_scorelogical_leap_foundsteps_support_conclusioncounterargument_foundjudge_sourceheuristic_fallbackcode_checkedcode_okmath_checkedmath_okverifiedconfidence_weight |
| formatqainstructionWhen should I use a fixed or variable time step? Should a game loop be based on fixed or variable time steps? Is one always superior, or does the right choice vary by game? Variable time step Physics updates are passed a \ argument and are hence framerate-dependent. This may mean doing calculations as position += distancePerSecond * timeElapsed . Pros : smooth, easier to to code Cons : non-deterministic, unpredictable at very small or large steps <a href=\time elapsed\ or <a href=\ example: while( game_is_running ) { while( GetTickCount() > next_game_tick ) { update(); next_game_tick += SKIP_TICKS; } interpolation = float( GetTickCount() + SKIP_TICKS - next_game_tick ) / float( SKIP_TICKS ); render( interpolation ); } Some resources <a href=\ game loop article <a href=\ 3 is frame-locked to 60fps? Flixel requires a variable timestep (I think this is determined by Flash) whereas <a href=\ manual § Simulating the World of Box2D suggests it uses constant time steps.inputoutputThere are two issues related to the question. Should physics step rate be tied to frame rate? Should physics be stepped with constant deltas? In Glen fielder's Fix your time step he says to \"Free the Physics\". That means your physics update rate should not be tied to your frame rate. For example, if the display framerate is 50fps and the simulation is designed to run at 100fps then we need to take two physics steps every display update to keep the physics in sync. In Erin Catto's recommendations for Box2D he advocates this as well. So don't tie the time step to your frame rate (unless you really, really have to). Should Physics step rate be tied to your frame rate? No. Erin's thoughts on fixed step vs variable stepping: Box2D uses a computational algorithm called an integrator. Integrators simulate the physics equations at discrete points of time. ... We also don't like the time step to change much. A variable time step produces variable results, which makes it difficult to debug. Glen's thoughts on fixed vs variable stepping: Fix your timestep or explode ... If you have a series of really stiff spring constraints for shock absorbers in a car simulation then tiny changes in dt can actually make the simulation explode. ... Should physics be stepped with constant deltas? Yes. The way to step the physics with constant deltas and not tie your physics update rate to the frame rate still is to use a time accumulator. In my game I take it a step further. I apply a smoothing function to incoming time. That way large FPS spikes don't cause the physics to jump too far, instead they're simulated more quickly for a frame or two. You mention that with a fixed rate, the physics wouldn't sync up with the display. This is true if the target physics rate is near the target frame rate. It's worse the frame rate is larger than the physics rate. In general it is better to target a physics update rate of twice your target FPS, if you can afford it. If you can't afford a large physics update rate, consider interpolating the graphics' positions between frames to make the drawn graphics appear to move more smoothly than the physics actually moves.metadatasourcestackexchange:gamedevcategorytechnical_scientificsubcategoryengineering_tradeoffslanguageendifficultymediumclarity_scorelogical_leap_foundsteps_support_conclusioncounterargument_foundjudge_sourceheuristic_fallbackcode_checkedcode_okmath_checkedmath_okverifiedconfidence_weight |
| formatqainstructionHow to prevent the \ syndrome? When you give the player a rare but powerful item which can only be used once but is never really required to proceed, most players will not use it at all, because they are waiting for the perfect moment. But even when this moment comes, they will still be reluctant to use it, because there might be an even better moment later. So they keep hoarding it for a moment which will never come. In the end, they will carry the item around until it is outclassed by other, more readily available resources, or even until the very end of the game. That means that such one-shot items don't provide any gameplay-value at all. They are simply <a href=\" awesome to use . What can you do to encourage the player to make use of their one-shot items and not hoard them?", "input": "", "output": "You could try to use arbitrary hacks like level/time limits. This however won't actually make people use them; it just means that they'll throw them away when they hit the level/time cap. It's also terribly arbitrary and artificial. You could try to just tell the player \ But that's horribly inelegant even if you can manage to do it in character and story appropriate dialog (and if you don't forget to check to see if they already used it). You could simply make later encounters so difficult that they effectively can't proceed unless they start burning through their rare one-shots. But then, if they used them all up earlier, they're boned. And that's all your fault as the game designer for not telling them that they weren't supposed to use them yet. The fact is this: people are creatures of habit. Rare, one-shot items, by their very nature, cannot be habitually used. So people will not be in the habit of using them; they will be in the habit of saving them. So you should look at your game design and ask yourself a question: what good does it do to have rare, one-shot items in the game at all? What game design purpose do they serve? Resource management isn't really served by such items, since they are so few in number that people can't really manage their use. Take a typical RPG level, a dungeon of some sort. You buy one-shot items at the store beforehand to stock up. And you hope that you have enough to last you through the level. You have to manage your limited resources, knowing that you can't just easily get more without backtracking. Rare one-shots don't help with that. You can't buy them, so they aren't part of money management. They're too rare to get in the habit of using. And they're rare enough that using one is a major investment. Whatever purpose you intend for rare, one-shot items to have, I imagine that there's a better way to achieve that purpose with a different item. For example, let's say you want the player to have access to some huge effect powers. Area damage, heal-all, whatever. But you don't want them to be able to buy large stocks of it, as it would make the game too easy. Make a rechargeable item. A staff of greater damage dealing or whatever that has only two charges, but you can recharge them in town (for a fee of course). Then, they will be encouraged to actually use them, since they know that they can at least recover the charges later. Thus they get into the habit of using it; it becomes a part of the game for the player. You can even upgrade the item later, with greater charge capacity. It also makes it less likely that they used them all up on unimportant stuff, since they can recharge them at designated locations. Also, if the item is rechargeable and therefore reuseable, the player has the chance to practice with the power. Which means that you can now make the ability something more than the typical boring \"do lots of AoE damage\" or \"heal lots of life on all characters\" or whatever. You can make the way in which the player uses it affect how effective it is. Obviously that depends very much on the nature of your gameplay. But the main point is that, if the player can practice with it, then they can build skill at using it. So you can make it a skillful ability.", "metadata": {"source": "stackexchange:gamedev", "category": "technical_scientific", "subcategory": "engineering_tradeoffs", "language": "en", "difficulty": "medium", "clarity_score": 0.454, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.454}} |
| {"format": "qa", "instruction": "How can I store game metadata in a .png file? Spore allows player-created creatures to be shared by exporting a .png file. That .png is a photo of the creature, but if it's imported into the game, the creature's information (such as textures, size, and shape) also come with it. How can I implement such a feature?", "input": "", "output": "The <a href=\" format has support for more-or-less arbitrary metadata. The <a href=\" standard defines a PNG file, essentially a series of chunks, some of which are required (and contain the image data). Others, however, are optional. For example, there's a chunk for storing gamma information or histogram data. In particular, there is a <a href=\ library ), or you'll need to write one yourself. Then it's just a matter of choosing how to encode the data you want as key/value pairs. I'd suggest the following: choose key names that are prefixed with your project's name or code name as a way of creating a crude \ system and avoid potential conflicts with other application's uses of the data don't try to store actual textures this way, store references to those textures that point within your game's own asset database data such as creature or object size, weight, et cetera -- simple scalars, basically -- can be trivially stored In the interests of making a more complete answer, I'll also point out that there is another approach (previously documented by the @Vaughn and @Alexis's answers): encode the additional data you want directly in your image pixels, distributing your data across the low-order bits of the color channels. This approach doesn't require the use of extra metadata, which means you can implement it entirely without relying on it or worrying about external programs incorrectly handling that metadata. It's also got a very high \"cool\" factor, and because you only use low-order bits the image will still look correct to the human eye. However, it does mean your image size is a primary controlling factor for the amount of data you can store; if you need more storage you'd need to allocate more pixels to the image. As others have pointed out, this process is known as <a href=\, : {: , : , : , : , : , : 0.581, : null, : null, : null, : , : false, : null, : false, : null, : true, : 0.581}} |
| {: , : , : , : free\ game . I'm not spending any money on making my game, I'm only using free software and making my own art. Don't get me wrong, I'm NOT an artist, just a programmer. It's not stopping me though. I just keep chugging away on my game, and I'll worry about making it look really pretty later. Or just make it good enough that the art doesn't matter. For now it's ordained with what I call \. Depending on the type of game you want to make, the art can be really important. But for a lot of games, it's all about the gameplay. Look at <a href=\" Fortress . Not really a lot of \"art\" involved, but the gameplay is great! If anything, you can get your game built with Microsoft Paint textures and sprites, then you'd have something to show off to get an artist interested. You should definitely try your hand at making a game. I love making my game. It's the most fun I've ever had programming. Every aspect is a new interesting thing to learn. Not everyone can do it all, so we just have to make do with the skills we have. Our skill is programming, so that's what we do. I think it's been proven more often than not, that it's the gameplay (programming) that makes or breaks games, not the art.", "metadata": {"source": "stackexchange:gamedev", "category": "technical_scientific", "subcategory": "engineering_tradeoffs", "language": "en", "difficulty": "medium", "clarity_score": 0.436, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.436}} |
| {"format": "qa", "instruction": "How do you prevent inflation in a virtual economy? With your typical MMORPG, players can usually farm the world for raw materials essentially forever. Monsters/mineral veins/etc are usually on some sort of respawn timer, so other than time there really isn't a good way to limit the amount of new currency entering the system. That really only leaves money sinks to try to take money out of the system. What are some strategies to prevent inflation of the in-game currency?inputoutputMoney sinks are I guess the only real answer. Which means items or currency getting lost forever. Eve Online blatantly has this through the mass destruction of items and ships through pvp (only partially replaced by insurance). Eve also has many other money sinks such as office rent, station fuels, ammunition etc. Other games have similar consumables, either necessities like ammo or items that provide buffs etc. (food, potions, pet food, poisons etc.) Many games (such as World of Warcraft) feature Bind on Pickup and Bind on Equip items. They are actually money sinks. You can enchant and add gems to your items but at some point you will upgrade it. So upgrading actually destroys the old item along with any value added to it via enchanting etc. Or in some games you can 'recycle' it for less that the original value. This is a nice sink because it doesn't negatively impact players. They only really notice it at the same time as they are cheering about their brand new shiny loot. Also, even if the item is never lost and just remains in a character's backpack it can be considered out of the economy because it will never pass to another player. Which brings us to other utility money sinks like increased bank and inventory space. Aesthetic upgrades are also a good way to introduce sinks without affecting the gameplay balance of your game. Things like clothing dye or vanity mounts and pets.metadatasourcestackexchange:gamedevcategorytechnical_scientificsubcategoryengineering_tradeoffslanguageendifficultymediumclarity_scorelogical_leap_foundsteps_support_conclusioncounterargument_foundjudge_sourceheuristic_fallbackcode_checkedcode_okmath_checkedmath_okverifiedconfidence_weight |
| formatqainstructionWhat is the role of \ in a component-based entity architecture? I've been reading a lot about entity components and systems and have thought that the idea of an entity just being an ID is quite interesting. However I don't know how this completely works with the components aspect or the systems aspect. A component is just a data object managed by some relevant system. A collision system uses some BoundsComponent together with a spatial data structure to determine if collisions have happened. All good so far, but what if multiple systems need access to the same component? Where should the data live? An input system could modify an entities BoundsComponent, but the physics system(s) need access to the same component as does some rendering system. Also, how are entities constructed? One of the advantages I've read so much about is flexibility in entity construction. Are systems intrinsically tied to a component? If I want to introduce some new component, do I also have to introduce a new system or modify an existing one? Another thing that I've read often is that the 'type' of an entity is inferred by what components it has. If my entity is just an id how can I know that my robot entity needs to be moved or rendered and thus modified by some system? Sorry for the long post (or at least it seems so from my phone screen)!inputoutputThere are a multitude of ways to represent and implement entity component systems, but here is an explanation of one way. Keep in mind there is no concrete definition of entity/component/system architectures, so this is just one implementation. I'm going to introduce an analogy for entity/component/system architectures that might help. Let's think of an entity like a key. The Entity Keys also have teeth (dark blue). The teeth of our entity key is the components that make it up. You can tell entities apart by their ID, even if they have the same teeth. So what do keys fit into? Locks. Locks are our systems. For example, a movement system. The System The lock only works if our key has teeth for both position and velocity. This system only processes entities that have a position and a velocity. There are multiple ways to set up how these systems recognize which entities to process, but one way is to use a long . Each bit is reserved for a component type. For our example lets assume a 4 bit type instead of a 64 bit long. Our example entity would have all available components. So it's key would be 1111 . Then, the system is looking for any entity that has a 11-- . (The - represent don't care, because movement doesn't care if there's a sprite or health). It can check an entity with a simple AND operation. So our entity matches if ((1111 & 1100) == 1100) . If I lost you there check out some more about <a href=\, : {: , : , : , : , : , : 0.466, : null, : null, : null, : , : false, : null, : false, : null, : true, : 0.466}} |
| {: , : , : , : , : {: , : , : , : , : , : 0.35, : null, : null, : null, : , : false, : null, : false, : null, : true, : 0.35}} |
| {: , : , : , : is right ; this effect is caused by both the foreground and the background objects being out of focus , and occurs in areas where the foreground object (your finger) partially occludes the background, so that only some of the light rays reaching your eye from the background are blocked by the foreground obstacle. To see why this happens, take a look at this diagram: The black dot is a distant object, and the dashed lines depict light rays emerging from it and hitting the lens, which refocuses them to form an image on a receptor surface (the retina in your eye, or the sensor in your camera). However, since the lens is slightly out of focus, the light rays don't converge exactly on the receptor plane, and so the image appears blurred. What's important to realize is that each part of the blurred image is formed by a separate light ray passing through a different part of the lens (and of the intervening space). If we insert an obstacle between the object and the lens that blocks only some of those rays, those parts of the image disappear! This has two effects: first, the image of the background object appears sharper, because the obstacle effectively reduces the aperture of the lens. However, it also shifts the center of the aperture, and thus of the resulting image, to one side. The direction in which the blurred image shifts depends on whether the lens is focused a little bit too close or a little bit too far. If the focus is too close, as in the diagrams above, the image will appear shifted away from the obstacle. (Remember that the lens inverts the image, so the image of the obstacle itself would appear above the image of the dot in the diagram!) Conversely, if the focus is too far, the background object will appear to shift closer to the obstacle. Once you know the cause, it's not hard to recreate this effect in any 3D rendering program that supports realistic focal blur. I used POV-Ray , because I happen to be familiar with it: Above, you can see two renderings of a classic computer graphics scene: a yellow sphere in front of a grid plane. The first image is rendered with a narrow aperture, showing both the grid and the sphere in sharp detail, while the second one is rendered with a wide aperture, but with the grid still perfectly in focus. In neither case does the effect occur, since the background is in focus. Things change, however, once the focus is moved slightly. In the first image below, the camera is focused slightly in front of the background plane, while in the second image, it is focused slightly behind the plane: You can clearly see that, with the focus between the grid and the sphere, the grid lines close to the sphere appear shifted away from it, while with the focus behind the grid plane, the grid lines shift towards the sphere. Moving the camera focus further away from the background plane makes the effect even stronger: You can also clearly see the lines getting sharper near the sphere, as well as bending, because part of the blurred image is blocked by the sphere. I can even re-create the broken line effect in your photos by replacing the sphere with a narrow cylinder: To recap: This effect is caused by the background being (slightly) out of focus, and by the foreground object effectively occluding part of the camera/eye aperture, causing the effective aperture (and thus the resulting image) to be shifted. It is not caused by: Diffraction: As shown by the computer renderings above (which are created using ray tracing , and therefore do not model any diffraction effects), this effect is fully explained by classical ray optics. In any case, diffraction cannot explain the background images shifting towards the obstacle when the focus is behind the background plane. Reflection: Again, no reflection of the background from the obstacle surface is required to explain this effect. In fact, in the computer renderings above, the yellow sphere/cylinder does not reflect the background grid…", "metadata": {"source": "stackexchange:physics", "category": "technical_scientific", "subcategory": "physics", "language": "en", "difficulty": "medium", "clarity_score": 0.499, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.499}} |
| {"format": "qa", "instruction": "How does gravity escape a black hole? My understanding is that light can not escape from within a black hole (within the event horizon). I've also heard that information cannot propagate faster than the speed of light. I assume that the gravitational attraction caused by a black hole carries information about the amount of mass within the black hole. So, how does this information escape? Looking at it from a particle point of view: do the gravitons (should they exist) travel faster than the photons?inputoutputThere are some good answers here already but I hope this is a nice short summary: Electromagnetic radiation cannot escape a black hole, because it travels at the speed of light. Similarly, <a href=\, : {: , : , : , : , : , : 0.7, : null, : null, : null, : , : false, : null, : false, : null, : true, : 0.7}} |
| {: , : , : , : , : {: , : , : , : , : , : 0.469, : null, : null, : null, : , : false, : null, : false, : null, : true, : 0.469}} |
| {: , : , : , : normal\, : {: , : , : , : , : , : 0.35, : null, : null, : null, : , : false, : null, : false, : null, : true, : 0.35}} |
| {: , : if it was not..\, : , : wrong\law of the universe\wrong\correct\ rapidity \, : {: , : , : , : , : , : 0.35, : null, : null, : null, : , : false, : null, : false, : null, : true, : 0.35}} |
| {: , : says: [...] the kinetic energy of a non-rotating object of mass $m$ traveling at a speed $v$ is $\\frac{1}{2}mv^2$. Why does this not increase linearly with speed? Why does it take so much more energy to go from $1\\ \\mathrm{m/s}$ to $2\\ \\mathrm{m/s}$ than it does to go from $0\\ \\mathrm{m/s}$ to $1\\ \\mathrm{m/s}$? My intuition is wrong here, please help it out!inputoutputThe previous answers all restate the problem as \. But this is not really satisfying, because you could then ask \ and the mystery is the same. The only way to answer questions like this is to rely on symmetry principles, since these are more fundamental than the laws of motion. Using Galilean invariance, the symmetry that says that the laws of physics look the same to you on a moving train, you can explain why energy must be proportional to the mass times the velocity squared. First, you need to define kinetic energy. I will define it as follows: the kinetic energy $E(m,v)$ of a ball of clay of mass $m$ moving with velocity $v$ is the amount of calories of heat that it makes when it smacks into a wall. This definition does not make reference to any mechanical quantity, and it can be determined using thermometers. I will show that, assuming Galilean invariance, $E(v)$ must be the square of the velocity. $E(m,v)$, if it is invariant, must be proportional to the mass, because you can smack two clay balls side by side and get twice the heating, so $$ E(m,v) = m E(v)$$ Further, if you smack two identical clay balls of mass $m$ moving with velocity $v$ head-on into each other, both balls stop, by symmetry. The result is that each acts as a wall for the other, and you must get an amount of heating equal to $2m E(v)$. But now look at this in a train which is moving along with one of the balls before the collision. In this frame of reference, the first ball starts out stopped, the second ball hits it at $2v$, and the two-ball stuck system ends up moving with velocity $v$. The kinetic energy of the second ball is $mE(2v)$ at the start, and after the collision, you have $2mE(v)$ kinetic energy stored in the combined ball. But the heating generated by the collision is the same as in the earlier case. So there are now two $2mE(v)$ terms to consider: one representing the heat generated by the collision, which we saw earlier was $2mE(v)$, and the other representing the energy stored in the moving, double-mass ball, which is also $2mE(v)$. Due to conservation of energy, those two terms need to add up to the kinetic energy of the second ball before the collision: $$ mE(2v) = 2mE(v) + 2mE(v)$$ $$ E(2v) = 4 E(v)$$ which implies that $E$ is quadratic. Non-circular force-times-distance Here is the non-circular version of the force-times-distance argument that everyone seems to love so much, but is never done correctly. In order to argue that energy is quadratic in velocity, it is enough to establish two things: Potential energy on the Earth's surface is linear in height Objects falling on the Earth's surface have constant acceleration The result then follows. That the energy in a constant gravitational field is proportional to the height is established by statics. If you believe the law of the lever, an object will be in equilibrium with another object on a lever when the distances are inversely proportional to the masses (there are simple geometric demonstrations of this that require nothing more than the fact that equal mass objects balance at equal center-of-mass distances). Then if you tilt the lever a little bit, the mass-times-height gained by 1 is equal to the mass-times-height gained by the other. This allows you to lift objects and lower them with very little effort, so long as the mass-times-height added over all the objects is constant before and after.This is Archimedes' principle. Another way of saying the same thing uses an elevator, consisting of two platforms connected by a chain through a pulley, so that when one goes up, the other goes down. You can lift an object up, if you lower an equal amount of mass down the same amount. You can lift two objects a certain distance in two steps, if you drop an object twice as far. This establishes that for all reversible motions of the elevator, the ones that do not require you to do any work (in both the colloquial sense and…", "metadata": {"source": "stackexchange:physics", "category": "technical_scientific", "subcategory": "physics", "language": "en", "difficulty": "medium", "clarity_score": 0.433, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.433}} |
| {"format": "qa", "instruction": "What experiment would disprove string theory? I know that there's big controversy between two groups of physicists: those who support string theory (most of them, I think) and those who oppose it. One of the arguments of the second group is that there's no way to disprove the correctness of the string theory. So my question is if there's any defined experiment that would disprove string theory?inputoutputOne can disprove string theory by many observations that will almost certainly not occur, for example: By detecting Lorentz violation at high energies: string theory predicts that the Lorentz symmetry is exact at any energy scale; recent experiments by the Fermi satellite and others have shown that the Lorentz symmetry works even at the Planck scale with a precision much better than 100% and the accuracy may improve in the near future; for example, if an experiment ever claimed that a particle is moving faster than light, string theory predicts that an error will be found in that experiment By detecting a violation of the equivalence principle ; it's been tested with the relative accuracy of $10^{-16}$ and it's unlikely that a violation will occur; string theory predicts that the law is exact By detecting a mathematical inconsistency in our world, for example that $2+2$ can be equal both to $4$ as well as $5$ ; such an observation would make the existing alternatives of string theory conceivable alternatives because all of them are mathematically inconsistent as theories of gravity; clearly, nothing of the sort will occur; also, one could find out a previously unknown mathematical inconsistency of string theory - even this seems extremely unlikely after the neverending successful tests By experimentally proving that the information is lost in the black holes, or anything else that contradicts general properties of quantum gravity as predicted by string theory, e.g. that the high center-of-mass-energy regime is dominated by black hole production and/or that the black holes have the right entropy ; string theory implies that the information is preserved in any processes in the asymptotical Minkowski space, including the Hawking radiation, and confirms the Hawking-Bekenstein claims as the right semiclassical approximation; obviously, you also disprove string theory by proving that gravitons don't exist ; if you could prove that gravity is an entropic force, it would therefore rule out string theory as well By experimentally proving that the world doesn't contain gravity, fermions, or isn't described by quantum field theories at low energies; or that the general postulates of quantum mechanics don't work ; string theory predicts that these approximations work and the postulates of quantum mechanics are exactly valid while the alternatives of string theory predict that nothing like the Standard Model etc. is possible By experimentally showing that the real world contradicts some of the general features predicted by all string vacua which are not satisfied by the \ QFTs as explained by Cumrun Vafa; if we lived in the swampland, our world couldn't be described by anything inside the landscape of string theory; the generic predictions of string theory probably include the fact that gravity is the weakest force, moduli spaces have a finite volume and similar predictions that seem to be satisfied so far By mapping the whole landscape , calculating the accurate predictions of each vacuum for the particle physics (masses, couplings, mixings), and showing that none of them is compatible with the experimentally measured parameters of particle physics within the known error margins; this route to disprove string theory is hard but possible in principle, too (although the full mathematical machinery to calculate the properties of any vacuum at any accuracy isn't quite available today, even in principle) By analyzing physics experimentally up to the Planck scale and showing that our world contains neither supersymmetry nor extra dimensions at any scale. If you check that there is no SUSY up to a certain higher scale, you will increase the probability that string theory is not relevant for our Universe but it won't be a full proof A convincing observation of varying fundamental constants such as the fine-structure constant would disprove string theory unless some other unlikely predictions of some string models that allow such…", "metadata": {"source": "stackexchange:physics", "category": "technical_scientific", "subcategory": "physics", "language": "en", "difficulty": "hard", "clarity_score": 0.437, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.437}} |
| {"format": "sequential_text", "title": "DS-Lighting: Making Agent Harnesses Explicit for Data-Science Automation", "text": "Computer Science > Artificial Intelligence [Submitted on 1 Jun 2026] Title:DS-Lighting: Making Agent Harnesses Explicit for Data-Science Automation View PDF HTML (experimental)Abstract:Large Language Model (LLM) agents have shown promise for automating data-science workflows, yet their end-to-end performance depends critically on the agent harness that represents tasks, manages execution state, constrains output artifacts, and provides evaluation feedback. Existing data-science agents often leave this harness implicit, making results difficult to reproduce, compare, and attribute across heterogeneous tasks. We introduce DS-Lighting, a unified harness toolkit that makes harness design explicit for data-science automation. DS-Lighting decomposes the harness into four reusable layers: data, workflow, execution, and evaluation, and represents diverse agents as executable operator programs that support both predefined pipelines and adaptive search. We further integrate multiple open-source data-science benchmarks into an MLE-Bench-style task format, enabling controlled comparison under a shared task interface, sandboxed runtime, and metric protocol. Experiments across agents, harnesses, models, and ablations show that explicit harness design improves reproducibility, comparability, and reliability, while reducing avoidable system-level failures in end-to-end data-science workflows. Our code is available at this https URL References & Citations Loading... Bibliographic and Citation Tools Bibliographic Explorer (What is the Explorer?) Connected Papers (What is Connected Papers?) Litmaps (What is Litmaps?) scite Smart Citations (What are Smart Citations?) Code, Data and Media Associated with this Article alphaXiv (What is alphaXiv?) CatalyzeX Code Finder for Papers (What is CatalyzeX?) DagsHub (What is DagsHub?) Gotit.pub (What is GotitPub?) Hugging Face (What is Huggingface?) ScienceCast (What is ScienceCast?) Demos Recommenders and Search Tools Influence Flower (What are Influence Flowers?) CORE Recommender (What is CORE?) arXivLabs: experimental projects with community collaborators arXivLabs is a framework that allows collaborators to develop and share new arXiv features directly on our website. Both individuals and organizations that work with arXivLabs have embraced and accepted our values of openness, community, excellence, and user data privacy. arXiv is committed to these values and only works with partners that adhere to them. Have an idea for a project that will add value for arXiv's community? Learn more about arXivLabs.metadatasourcehttp://export.arxiv.org/rss/cs.AIcategorytechnical_scientificsubcategoryresearch_paperslanguageendifficultymediumclarity_scorelogical_leap_foundsteps_support_conclusioncounterargument_foundjudge_sourceheuristic_fallbackcode_checkedcode_okmath_checkedmath_okverifiedconfidence_weight |
| formatsequential_texttitleExpert-validated STEM QAtextComputer Science > Artificial Intelligence [Submitted on 6 Jun 2026] Title:Expert-validated STEM QA View PDF HTML (experimental)Abstract:Recent advancements in AI are helping scientists achieve breakthroughs in fields such as mathematics, medicine, and materials sciences. New evaluation datasets for AI models contribute to such advancement in AI. In the STEM domain, frontier models have consumed most of the available online data, creating the need for human-created datasets that codify the knowledge of leading experts in the domain. There are several STEM datasets available for the research community in this field. However, there are some gaps in these datasets, leaving room for improvement. Examples of gaps include (1) saturation in model performance on these datasets, leaving no head-room for meaningful evaluations, (2) skewed taxonomy distributions, (3) multiple choice question format that is misaligned with how scientists use AI in the real world, and (4) inaccurate answers and rationales partially led by a contest-based data collection and a time-bound review process. In this study, we present 'Expert-validated STEM QA', a high-quality, expert-validated STEM dataset (N=398) in Physics, Chemistry, Biology, and Mathematics, created by 241 domain experts. We (1) carefully designed a taxonomy with balanced distribution, (2) vetted question contributors with quality-driven incentive, (3) conducted multiple rounds of reviews with revisions validated by domain experts based on consensus, and (4) created the dataset in verifiable question and answer format. Our study demonstrated low performance ($<25\\%$) of frontier AI models on the dataset as a benchmark. Post-training on a separate, private version of the dataset (N=2,000) increased performance of the open source model by $15\\%$ relative to the baseline model (p=0.045) on the STEM subset of HLE-verified dataset, indicating potential utility of the dataset for model training. We have open-sourced a portion of our dataset for the AI research community. References & Citations Loading... Bibliographic and Citation Tools Bibliographic Explorer (What is the Explorer?) Connected Papers (What is Connected Papers?) Litmaps (What is Litmaps?) scite Smart Citations (What are Smart Citations?) Code, Data and Media Associated with this Article alphaXiv (What is alphaXiv?) CatalyzeX Code Finder for Papers (What is CatalyzeX?) DagsHub (What is DagsHub?) Gotit.pub (What is GotitPub?) Hugging Face (What is Huggingface?) ScienceCast (What is ScienceCast?) Demos Recommenders and Search Tools Influence Flower (What are Influence Flowers?) CORE Recommender (What is CORE?) arXivLabs: experimental projects with community collaborators arXivLabs is a framework that allows collaborators to develop and share new arXiv features directly on our website. Both individuals and organizations that work with arXivLabs have embraced and accepted our values of openness, community, excellence, and user data privacy. arXiv is committed to these values and only works with partners that adhere to them. Have an idea for a project that will add value for arXiv's community? Learn more about arXivLabs.", "metadata": {"source": "http://export.arxiv.org/rss/cs.AI", "category": "technical_scientific", "subcategory": "research_papers", "language": "en", "difficulty": "hard", "clarity_score": 0.396, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.396}} |
| {"format": "sequential_text", "title": "A collective capability boundary in frontier large language…", "text": "Computer Science > Artificial Intelligence [Submitted on 8 Jun 2026] Title:A collective capability boundary in frontier large language models on guideline-conformant and case-specific oncology decision-making View PDF HTML (experimental)Abstract:Large language models (LLMs) achieve high scores on medical knowledge examinations, yet real-world oncology is not a knowledge test--it is a sequence of guideline-pathway choices, escalation judgments, and commitments under uncertainty. Existing benchmarks largely measure factual recall, leaving open whether frontier LLMs share decision-path blind spots that combining models cannot fix. We built the Oncology Decision Boundary Benchmark (ODBB)--2,005 oncology decision points across NCCN guidelines and colorectal cancer cases--and evaluated nine frontier LLMs (four closed-source, five open-weight families) released between June 2025 and April 2026. A fully deterministic scorer (zero LLM inference) classified outputs into 14 failure types, independently validated by two oncologists (Cohen's weighted $\\kappa$ = 0.939 and 0.790) on a 225-item stratified sample. Treating the nine as a pooled super-model, 42.1% (Wilson 95% CI 40.0--44.3%) of all items--35.7% of the 1,586 NCCN items and 66.4% of the 419 colorectal-cancer cases--were answered correctly by none, with failures concentrated in choosing between guideline pathways before reasoning within any: a consistent blind spot in clinical meta-judgment that likely requires architectural intervention rather than more training data. Two models tuned for decisiveness (GPT-5.5, Gemini 3.1 Pro Preview) made unsafe commitments three to five times more often than the seven cautious models without scoring higher. In 3--9% of items, models stated the correct next clinical step yet did not commit to it--failures of decision, not knowledge. Model quality is no longer the primary bottleneck for clinical LLM deployment; the binding constraint is the assumption that any single model can be the sole basis for a clinical decision. Progress requires architectures that detect when a model reaches its competence boundary and route the decision to a clinician. References & Citations Loading... Bibliographic and Citation Tools Bibliographic Explorer (What is the Explorer?) Connected Papers (What is Connected Papers?) Litmaps (What is Litmaps?) scite Smart Citations (What are Smart Citations?) Code, Data and Media Associated with this Article alphaXiv (What is alphaXiv?) CatalyzeX Code Finder for Papers (What is CatalyzeX?) DagsHub (What is DagsHub?) Gotit.pub (What is GotitPub?) Hugging Face (What is Huggingface?) ScienceCast (What is ScienceCast?) Demos Recommenders and Search Tools Influence Flower (What are Influence Flowers?) CORE Recommender (What is CORE?) arXivLabs: experimental projects with community collaborators arXivLabs is a framework that allows collaborators to develop and share new arXiv features directly on our website. Both individuals and organizations that work with arXivLabs have embraced and accepted our values of openness, community, excellence, and user data privacy. arXiv is committed to these values and only works with partners that adhere to them. Have an idea for a project that will add value for arXiv's community? Learn more about arXivLabs.", "metadata": {"source": "http://export.arxiv.org/rss/cs.AI", "category": "technical_scientific", "subcategory": "research_papers", "language": "en", "difficulty": "hard", "clarity_score": 0.35, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.35}} |
| {"format": "sequential_text", "title": "Statutory AI: Aligning Large Language Models With Legal…", "text": "Computer Science > Artificial Intelligence [Submitted on 13 Jun 2026] Title:Statutory AI: Aligning Large Language Models With Legal Norms View PDF HTML (experimental)Abstract:With the increasing development of AI regulatory frameworks, ensuring that artificial intelligence systems, particularly generative models, operate in accordance with legal and ethical standards has become a critical priority. Existing proposals for AI alignment and value-guided behavior, however, face some limitations. Approaches such as Constitutional AI depend on human supervision, while broad normative frameworks like the Good-for-Humanity (GfH) principle may be overly general and ambiguous to provide actionable governance guidance. To overcome these limitations, we propose a hybrid approach called Statutory AI that employs pre-existing human-authored principles drawn from specific themes within a legal corpus. Specifically, Statutory AI uses legal texts as a constitutional framework, enabling AI systems to autonomously critique and revise their outputs according to established norms. It operates in two stages, both using Chain-of-Thought prompting. The first stage classifies the user prompt into one of the identified themes, while the second stage analyzes it in conjunction with relevant articles selected from the legal corpus of that theme. To illustrate the potential of our approach, we conducted an experiment involving 1,000 red-teaming prompts and five penal themes: discrimination, disclosure of confidential information, violence, fraud, and abuse of vulnerable persons. Statutory AI reduced harmful content by 52 to 59 percentage points across tested models, approximately 10 percentage points higher than standard Constitutional AI, while cutting computation time by over 50%. References & Citations Loading... Bibliographic and Citation Tools Bibliographic Explorer (What is the Explorer?) Connected Papers (What is Connected Papers?) Litmaps (What is Litmaps?) scite Smart Citations (What are Smart Citations?) Code, Data and Media Associated with this Article alphaXiv (What is alphaXiv?) CatalyzeX Code Finder for Papers (What is CatalyzeX?) DagsHub (What is DagsHub?) Gotit.pub (What is GotitPub?) Hugging Face (What is Huggingface?) ScienceCast (What is ScienceCast?) Demos Recommenders and Search Tools Influence Flower (What are Influence Flowers?) CORE Recommender (What is CORE?) arXivLabs: experimental projects with community collaborators arXivLabs is a framework that allows collaborators to develop and share new arXiv features directly on our website. Both individuals and organizations that work with arXivLabs have embraced and accepted our values of openness, community, excellence, and user data privacy. arXiv is committed to these values and only works with partners that adhere to them. Have an idea for a project that will add value for arXiv's community? Learn more about arXivLabs.metadatasourcehttp://export.arxiv.org/rss/cs.AIcategorytechnical_scientificsubcategoryresearch_paperslanguageendifficultyhardclarity_scorelogical_leap_foundsteps_support_conclusioncounterargument_foundjudge_sourceheuristic_fallbackcode_checkedcode_okmath_checkedmath_okverifiedconfidence_weight |
| formatsequential_texttitleFrom Question-First to Analyst-First: Domain-Expert Skills and Verified…textComputer Science > Artificial Intelligence [Submitted on 15 Jun 2026] Title:From Question-First to Analyst-First: Domain-Expert Skills and Verified Knowledge Compilation for Proactive Enterprise Analytics View PDF HTML (experimental)Abstract:Conversational analytics systems assume the user already has a well-formed question, leaving a non-expert facing a blank query box on an unfamiliar enterprise schema. Commercial 'proactive' tools narrow this gap only by detecting statistical anomalies over analyst-curated metric layers, and academic next-question recommenders depend on query logs that a fresh dataset lacks. We describe a production analytics system that inverts the interaction model from question-first to analyst-first through two coupled architectural ideas. First, a pluggable domain-expert 'skill' abstraction: a folder-based, database-free subject-matter pack (a manifest, per-stage prompt facets, keyword-routed references, report templates, and optional compute) auto-selected per (client, dataset) by deterministic schema matching and spliced as a cross-cutting concern into every stage of an agentic pipeline, the schema explorer, and the report engines, degrading to a strict no-op when absent. Because a skill is a self-contained folder resolved deterministically, the catalogue is open-ended: an extensible marketplace of domain experts. Second, an offline knowledge-compilation loop: an agent probes the dataset's parquet via DuckDB (zero load on production), runs critic-gated per-table convergence with self-healing retries, and data-validates joins by value overlap, producing durable schema knowledge that drives standing expert reports whose every published metric is re-verified by re-executing its evidence SQL, plus suggested questions that mirror the report agenda. These close a proactive loop: reports surface numbers, the numbers seed questions, and a click launches a verified deep dive, all before the query box is used. We give a formal model and report illustrative single-tenant evidence. We make no user-study or benchmark claims; the contribution is the architecture and its defensibility. References & Citations Loading... Bibliographic and Citation Tools Bibliographic Explorer (What is the Explorer?) Connected Papers (What is Connected Papers?) Litmaps (What is Litmaps?) scite Smart Citations (What are Smart Citations?) Code, Data and Media Associated with this Article alphaXiv (What is alphaXiv?) CatalyzeX Code Finder for Papers (What is CatalyzeX?) DagsHub (What is DagsHub?) Gotit.pub (What is GotitPub?) Hugging Face (What is Huggingface?) ScienceCast (What is ScienceCast?) Demos Recommenders and Search Tools Influence Flower (What are Influence Flowers?) CORE Recommender (What is CORE?) arXivLabs: experimental projects with community collaborators arXivLabs is a framework that allows collaborators to develop and share new arXiv features directly on our website. Both individuals and organizations that work with arXivLabs have embraced and accepted our values of openness, community, excellence, and user data privacy. arXiv is committed to these values and only works with partners that adhere to them. Have an idea for a project that will add value for arXiv's community? Learn more about arXivLabs.metadatasourcehttp://export.arxiv.org/rss/cs.AIcategorytechnical_scientificsubcategoryresearch_paperslanguageendifficultyhardclarity_scorelogical_leap_foundsteps_support_conclusioncounterargument_foundjudge_sourceheuristic_fallbackcode_checkedcode_okmath_checkedmath_okverifiedconfidence_weight |
| formatsequential_texttitleThe Signal in the Noise: An Auditable Reliability…textComputer Science > Artificial Intelligence [Submitted on 16 Jun 2026] Title:The Signal in the Noise: An Auditable Reliability Layer for Biomedical Text Classification View PDFAbstract:Biomedical NLP pipelines routinely presuppose clean input text, yet large-scale corpora assembled through automated PDF parsing harbour pervasive OCR-like artifacts, token splits and merges, hyphenation remnants, and character-level corruption, that systematically erode lexical evidence and degrade downstream classifiers. We introduce a conservative, fully auditable spell-correction reliability layer conceived as a safety-oriented preprocessing module rather than a maximal-accuracy corrector: under conditions of uncertainty, the system abstains from editing, in accordance with a medical do-no-harm philosophy. The deterministic architecture couples bounded edit-distance candidate generation with corpus-derived n-gram scoring and a suite of biomedical safety gates that protect domain-critical terminology. We evaluate the layer both intrinsically, on a manually curated benchmark of 2,104 token-level cases, and extrinsically, on a tri-class CORD-19 topic classifier (Prevention, Treatment, Epidemiology) spanning 10,000 examples under a principled four-run protocol (Clean, Noisy, Restored, Safety). Intrinsically, the layer attains 94.61% error-fix recall on synthetic errors with zero harmful edits on negative controls. Downstream, it recovers approximately 80.45% of the noise-induced macro-F1 degradation, elevating macro-F1 from 0.7654 (Noisy) to 0.7717 (Restored) while preserving near-clean performance (Safety: 0.7721). A supplementary case study on 103 real-world OCR-extracted abstracts classified with BioBERT confirms that transformer encoders appeared relatively robust to mild noise, motivating a future grey-box architecture that integrates bounded neural signals and UMLS lexicons without compromising auditability. The system is fully deterministic, artifact-driven, and designed with deployment and auditability in mind. Submission history From: Moustafa Yehia Hassan [view email][v1] Tue, 16 Jun 2026 23:14:36 UTC (741 KB) Current browse context: cs.AI References & Citations Loading... Bibliographic and Citation Tools Bibliographic Explorer (What is the Explorer?) Connected Papers (What is Connected Papers?) Litmaps (What is Litmaps?) scite Smart Citations (What are Smart Citations?) Code, Data and Media Associated with this Article alphaXiv (What is alphaXiv?) CatalyzeX Code Finder for Papers (What is CatalyzeX?) DagsHub (What is DagsHub?) Gotit.pub (What is GotitPub?) Hugging Face (What is Huggingface?) ScienceCast (What is ScienceCast?) Demos Recommenders and Search Tools Influence Flower (What are Influence Flowers?) CORE Recommender (What is CORE?) arXivLabs: experimental projects with community collaborators arXivLabs is a framework that allows collaborators to develop and share new arXiv features directly on our website. Both individuals and organizations that work with arXivLabs have embraced and accepted our values of openness, community, excellence, and user data privacy. arXiv is committed to these values and only works with partners that adhere to them. Have an idea for a project that will add value for arXiv's community? Learn more about arXivLabs.", "metadata": {"source": "http://export.arxiv.org/rss/cs.AI", "category": "technical_scientific", "subcategory": "research_papers", "language": "en", "difficulty": "hard", "clarity_score": 0.35, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.35}} |
| {"format": "sequential_text", "title": "Paper Pilot: A Human-in-the-Loop Expert System for Evidence-Traceable…", "text": "Computer Science > Artificial Intelligence [Submitted on 17 Jun 2026] Title:Paper Pilot: A Human-in-the-Loop Expert System for Evidence-Traceable Scientific Manuscript Generation in Applied Sciences View PDF HTML (experimental)Abstract:Large language model (LLM) agents are increasingly embedded in scientific workflows for literature analysis, drafting, and review. Existing systems advance autonomous discovery and manuscript generation, but do not resolve the governance problem that arises when ideas, methods, results, and claims propagate through AI-assisted workflows without mandatory human approval or artifact-level traceability. This paper proposes Paper Pilot, a human-in-the-loop expert system for evidence-traceable scientific manuscript generation in applied sciences. It adapts the Collaborative Agent Reasoning Engineering (CARE) methodology to manuscript development through manuscript-owner approval gates, explicit no-pass criteria, claim classification, audit logging, advisory LLM review, and evidence-locked revision control. The framework defines eight approval gates across the idea-to-claim pipeline and distinguishes literature-grounded from artifact-grounded claims, requiring reported numbers and interpretations to remain traceable to approved evidence; its system prompt is openly released for deployment in ChatGPT, Gemini, Claude, or institutional LLM environments. As a first empirical validation, we evaluate the citation-grounding layer with a controlled, mechanically scored benchmark (two commercial LLMs, real arXiv papers, no LLM judge): under coverage pressure ungated drafters fabricated up to 25% of their citations and never flagged an evidence gap, whereas the same models under Paper Pilot's evidence-locked rules produced zero fabricated citations and surfaced the planted gaps as explicit placeholders. Preliminary results for result grounding, revision, and adversarial robustness point the same way; full evaluation is left to future work. Paper Pilot positions LLM-assisted writing as a controlled human-AI decision-support process rather than a fully autonomous authorship pipeline. Submission history From: Ajinkya Kulkarni [view email][v1] Wed, 17 Jun 2026 21:41:22 UTC (1,321 KB) References & Citations Loading... Bibliographic and Citation Tools Bibliographic Explorer (What is the Explorer?) Connected Papers (What is Connected Papers?) Litmaps (What is Litmaps?) scite Smart Citations (What are Smart Citations?) Code, Data and Media Associated with this Article alphaXiv (What is alphaXiv?) CatalyzeX Code Finder for Papers (What is CatalyzeX?) DagsHub (What is DagsHub?) Gotit.pub (What is GotitPub?) Hugging Face (What is Huggingface?) ScienceCast (What is ScienceCast?) Demos Recommenders and Search Tools Influence Flower (What are Influence Flowers?) CORE Recommender (What is CORE?) arXivLabs: experimental projects with community collaborators arXivLabs is a framework that allows collaborators to develop and share new arXiv features directly on our website. Both individuals and organizations that work with arXivLabs have embraced and accepted our values of openness, community, excellence, and user data privacy. arXiv is committed to these values and only works with partners that adhere to them. Have an idea for a project that will add value for arXiv's community? Learn more about arXivLabs.", "metadata": {"source": "http://export.arxiv.org/rss/cs.AI", "category": "technical_scientific", "subcategory": "research_papers", "language": "en", "difficulty": "hard", "clarity_score": 0.35, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.35}} |
| {"format": "sequential_text", "title": "The Race between Agentic AI Capabilities and Data…", "text": "Computer Science > Artificial Intelligence [Submitted on 21 Jun 2026] Title:The Race between Agentic AI Capabilities and Data Quality Control in Online Surveys View PDF HTML (experimental)Abstract:Online surveys are a foundational data collection instrument in a variety of fields, with attention checks serving as critical guardians of response quality. However, the rapid emergence of agentic AI (goal directed systems powered by a large language model (LLM) brain and/or a multimodal processing unit with tool-augmented capabilities) raises new questions about the robustness of these safeguards. We investigate how well agentic AI architectures can complete web-based surveys and pass standard attention checks. We evaluate a single-agent architecture capable of multimodal input processing and tool-based web interaction on a controlled survey sandbox. We analyze the problem from two perspectives. From an attack perspective, we demonstrate how structural vulnerabilities such as exposed DOM metadata and predictable option encoding allow agents to resolve attention checks through structured parsing only. From a defense perspective, we implement a mitigation strategy of DOM metadata obfuscation to remove semantic cues in text-based questions. We evaluate multiple open-source language and multimodal models to study capability and orchestration effectiveness. Based on our evaluations, we offer perspectives on how to simultaneously meet the needs of empiricists and agentic AI researchers. References & Citations Loading... Bibliographic and Citation Tools Bibliographic Explorer (What is the Explorer?) Connected Papers (What is Connected Papers?) Litmaps (What is Litmaps?) scite Smart Citations (What are Smart Citations?) Code, Data and Media Associated with this Article alphaXiv (What is alphaXiv?) CatalyzeX Code Finder for Papers (What is CatalyzeX?) DagsHub (What is DagsHub?) Gotit.pub (What is GotitPub?) Hugging Face (What is Huggingface?) ScienceCast (What is ScienceCast?) Demos Recommenders and Search Tools Influence Flower (What are Influence Flowers?) CORE Recommender (What is CORE?) arXivLabs: experimental projects with community collaborators arXivLabs is a framework that allows collaborators to develop and share new arXiv features directly on our website. Both individuals and organizations that work with arXivLabs have embraced and accepted our values of openness, community, excellence, and user data privacy. arXiv is committed to these values and only works with partners that adhere to them. Have an idea for a project that will add value for arXiv's community? Learn more about arXivLabs.metadatasourcehttp://export.arxiv.org/rss/cs.AIcategorytechnical_scientificsubcategoryresearch_paperslanguageendifficultymediumclarity_scorelogical_leap_foundsteps_support_conclusioncounterargument_foundjudge_sourceheuristic_fallbackcode_checkedcode_okmath_checkedmath_okverifiedconfidence_weight |
| |
