Okay, might as well see if the discussion can get off the ground.
Let's make a few ground rules for the forum...
The purpose of this forum is to discussion rogue mechanics in-depth with an eye on how one might model such.

Examples of discussions that probably fit here:
1) Skill modeling (such as Deadly Poison) and how to accurately determine uptimes and/or proc rates at various intervals.
2) Proc mechanics. We can probably include discussions and determinations of these here. Of course some topics might branch off to their own topics. Executioner vs. Mongoose clearly deserves a topic of its own for example.

Examples of discussions that probably don't:
1) Discussion of which item is better. Here's the answer consult the spreadsheets...
2) Which build is better? Consult the spreadsheets...

In general I see this as a focused discussion topic for micro issues. Essentially discussions that one can arrive at a definable answer (well at least maybe) for a single problem. I don't really want to discuss the comparative benefits of this build vs. that build. A few spreadsheets have been built to try to do that. 2 are currently public, use them, love them.

What you seem to be theorizing here is: if I use Envenom as a finisher, how fast will the stack rebuild?

The D0D1 stuff is not incorrect, but it is a bit mathematically naive. The way the OP formulates it shows a classic example of a convergent geometric series, but then you don't use the geometric mean.

There's also some standard probability notation and binomial distribution shortcuts that would help.

Let P = the chance of success, and Q = the chance of failure.

If we reformulate the above...

D0 = PQ
D1 = P^2*Q
D2 = P^3*Q
D3 = P^4*Q
D4 = P^5*Q
D5 = P^6*Q

And add them up Sum(D) = PQ+P^2Q+P^3Q+P^4Q+P^5Q+P^6Q
Recognize that P is a positive number less than 1 (say, 20 to 30% depending on talents), and this series converges. It's not infinite, of course, because you can't have more than 5 stacks. However, we can probably fudge it slightly since P^7 and up terms will be very very small, and because otherwise there's no way to solve this without some fancy math software that I don't have (or know how to use).

So we can approximate SUM(D) as (1/(1-P)) * Q, which, of course, equals 1.... why are we doing it this way? Lemme dig up an old spreadsheet, I had a decent way of modelling it....

NB: I assume we're talking about a mutilate build here with some slow daggers. I also assume we don't really care about the initial build-up of the DP stack, because we're trying to analyze envenom as a finisher. Finally, assume S&D and whatever appropriate haste.

1) First #: Average # of poison applications per second

[top] # hits per second * chance to poison
# hits per second

specials per second + white hits per second
specials per second are easy, for mutilate you get 2 hits every 6 seconds, thus 1/3
white hits per second are trickier, say you're using 2 1.8 daggers, with S&D up, and a 10% missrate (don't forget dodges)

[top] 1 / (weapon speed / haste mod / hit rate)

1 / (1.8 / 1.3 / 90%) * 2 (two weapons)
# hits per second is about 1.62, using these #s
chance to poison is 30%, so .49 poison apps per second

2) Second #: Time to envenom
What's your cycle here? Are we using rupture as a priority finisher? Figure it out. I came up with the # of about 21 seconds (but this was a long time ago).

3) Average stacks of DP7 = poison apps per second * time to envenom (in seconds)... I came up with about 3.2. For some reason I thought I should add 1 to the average stacks, I'm not sure why...

Anyways, that's one geek's perspective on the problem you seem to be working with. Cheers

I can't contribute in any logical way to the mathematics of the model, unfortunately, since my background in statistics is well below the level you all are operating at here.

However, what I can do is try to create a simple numerical simulator to test any model we come up with. I've already got a spreadsheet which will do this for a PPM effect, and it closely agrees with what DMM and Aldriana came up with as a PPM uptime estimate equation. I think I can extend this to deadly poison modeling without much effort.

I think a code-based simulator would be more effective than a spreadsheet, however, since a spreadsheet has the disadvantage of "smaller" sample sizes. (By small here I mean that I'm running 10k attacks at a shot, then iterating multiple items to see what the average is. A code-based simulator could easily do 100k or even a million attacks and then average the results.) If there's interest in building a simulator like this to test the model, let me know and I'll put some work into expanding what I already have for PPM.

This is a good start, but there's one thing I think warrants some consideration: Relentless Strikes and the common sense of a good Mutilate player.

Mutilate is all about timing your finishers, and a good rogue will know to Envenom with nearly full energy so that a Relentless Strikes proc and a natural energy tick will allow him to Mutilate twice almost immediately.

This does a great job of showing the average poison applications over time, but it doesn't really model reality according to the way I understand Mutilate should be played.

Is there a way we can analyze those few seconds after a finisher? I think those are the most critical as the biggest concern with Envenom is losing the DP stack, and getting it back up as quikcly as possible is priority #1.

I used to do this when I played mutilate: let my energy tick up prior to a finisher so that I could get the most of out Find Weakness. However, I don't recommend this strategy when using envenom. The reason is that since Envenom will wipe your DP stack, you want to wait a second or two for white hits to restart poison on the mob before hitting your next mutilate. Otherwise, your Mutilate will lose it's +50% damage bonus.

Sure, mutilating will put the stacks up there more quickly, but in my opinion the DPS loss from an un-poisoned mutilate is more than the loss you are getting from not having DP stack up quickly.

However, discussing Mutilate timing isn't really the point of this thread. What we're looking at, first and foremost, is an accurate model for DP on offhand white hits only; we can move on to more complicated crap from there.

I've actually already written a simple modeling program for PPM effects, that I used to assess the models we found in the Roguecraft 101 thread; it takes about 10 seconds on my computer at work to simulate 10 million hits:

It should be reasonably easy to adapt to the simplified model of poison where it's just as 12 second buff; updating it to quantize poison to 3 second ticks would be a little harder but presumably also doable.

Uh, that is a good point...

I guess I was coming from the perspective of using Mutilate in 10-mans (the only place I've ever used it), in which case I was the only one poisoning the boss.

Re Aldriana: Yeah, that code version looks a lot nicer. I'll see what I can do with it; probably won't be today.

Well, as long as we have a thread for it: time to put forward my previously alluded-to model of Deadly Poison uptime, which is impossible to compute symbolically and not the most practical thing numerically, but as it *does* work (as far as I can tell, anyway) it's probably worth discussing a bit. The fundamental approach is as follows:

Figuring out the amount of time between when one stack of DP ticks off and the next one starts is easy; hence, what we need to calculate is the average duration (and stack height) of an uptime period.

The way to do that - or at least, the brute-force way of doing that - is to define your initial state as a vector, and then write out the transition table. Now, we have two different pieces of state that we need to keep track of: the number of stacks currently applied (1-5) and the number of ticks remaining (1-4), plus an additional state of "no poison up". However, we don't quite need all those states; outside the initial state, we can never have more than 3 ticks remaining. So we really have the following 17 states:
(0,0)
(1,1)
(1,2)
(1,3)
(1,4)
(2,1)
(2,2)
(2,3)
(3,1)
(3,2)
(3,3)
(4,1)
(4,2)
(4,3)
(5,1)
(5,2)
(5,3)


So our state is defined as a 17-entry vector, with an initial state of "1 stack of poison up, 4 ticks remaining" (given that we have assumed that poison was just applied for the first time).

Now, how do we define the transitions? Well, pretty simple, actually. Let n be the number of attacks that occur in an average 3 second window, p be the probability that a given attack procs poison (hit rate * proc rate * proc resist rate), and q = 1-p. Then we have the following cases:

If no procs occur, the number of procs remaining goes down by 1; if there was only one proc remaining, we enter the "no poison" state. The probability of this happening is q^n.

If one proc occurs, "stacks" increases by one (to a maximum of 5), and "ticks remaining" resets to 3. The probability of this happening is npq^{n-1}

If two procs occur, stacks increases by two (to a maximum of 5), and "ticks remaining" resets to 3. The probability of this happening is .5*n(n-1)p^2q^{n-2}

And so on. So, for each state, theres at most half a dozen other places it can go; for instance, our initial state (1,4) can go to (1,3), (2,3), (3,3), (4,3) and, depending on attack rate, possibly (5,3), but it can never go to, for instance, (3,1) or (0,0). Similarly, (2,1) can go to (0,0), (3,3), (4,3), or (5,3) and nowhere else.

In reality, you could make these transitions slightly more precise by looking at the probability distribution of number of attacks and carrying those probabilities through this step, but I suspect that's overkill; this approach should work pretty well.

Anyway: now we have our transition matrix T. The next step is to diagonalize T (which is equivalent to computing the eigenvalues/vectors) and write it as PDP^{-1}, such that T^n = PD^nP^{-1}. This allows us to write a closed-form expression for the probability that the system is in any given state after n ticks as a linear combination of the eigenvalues of T, taken to the nth power (i.e., a sum of the form w_1 * e_1^n + w_2 * e_2^n * ... * w_17 * e_17^n

At that point, once can compute the probability that the stack wears off after exact N ticks for any N, and from there compute the expected duration. Also, since you have full state information for every tick from 1 to N-1, you can compute the average number of stacks as well. And since average downtime is easily (1/pt), that's enough information to get you across the finish line.

Well, I applaud your use of matrix decomposition, but I'm not sure that it gets us closer to the answer. Incidentally, my training is in economics so my perspective is a bit more applied than yours. I would hazard to guess that your training was in electrical engineering or physics.

I'm unsure to what degree eigendecomposition of a 17 by 17 matrix is computationally tractable. (We only used Cholesky decomp in econ/stats). Mightn't all the zeroes in the transition matrix you propose make it un-decomposable/un-invertable?

Ultimately, any number for "average" damage we come up with is going to have a variance anyways. Good luck computing the second order behavior of your symbolic solution =). Or partial derivatives with respect to parameters (weapon speed, hit rate, haste, talents, etc). And then collecting enough data to validate or invalidate the model....

Well, on second thought, if you have matlab and are skilled with it, you could probably do it (except probably the data part, but that's not that important unless you plan on publishing this in a peer-reviewed publication a number that jives with a few WWS parses would probably be sufficient). You'd just need numbers for N and P, which is the easy part. What's stopping you?

I know what's stopping me -- I'm not good enough at math and am unfamiliar with the technique you describe.

So, being an economist and not a physicist, I prefer to make simplifying assumptions, namely:

1) The poison doesn't fall off until you wipe it off with an envenom -- reasonable if you're DW DP w/ mutilate
2) The base-case scenario you're simply leaving it to tick with 5 stacks the entire fight.
3) You can estimate an average CP usage cycle despite relentless strikes and seal fate

So the question as I see it would simply be, how often do you envenom, and how long does it take to build the stack back up?

Here's a quick and dirty Java simulation of deadly poison stacks. I did it on lunch break. It has some flaws - namely that it's not accounting for ticks but rather is treating poisons like a stacking debuff with uniform damage distribution. It also uses the attack interval as the basic unit of time. However, it should still give enough of a simulation to run a sanity check on any theoretical solution posed in the thread.

EDIT #2: I now believe that this program, while useful for a ballpark, is not quite accurate enough (even in the continuous case) to use as a benchmark for evaluating DP models. I found an issue with it that is causing it to overestimate DP uptime. See my post here for more info.

Aldriana's coding in Python, so it's a lot prettier than my crap up there. I'll probably be using Python after this, once I figure out how to work with it. Java is way too much of a pain.

EDIT: One thing I did notice was that for the defaults I entered, Improved Poisons is about dead even with Master Poisoner in terms on increased average stacks. However, both exhibit diminishing returns per point, so 1 point in MP plus 1 point in Imp Poisons increased poison damage more than both points in either of the talents. Interesting...