How to calculate Damages Allocation in Arizona

Quick takeaways

• Arizona’s damages allocation “default” time window is set by A.R.S. §§ 12-2505 and 12-2506. In this guide, DocketMath uses those general statutory allocation frameworks to help you split damages among parties based on comparative fault concepts.
• A.R.S. §§ 12-2505 and 12-2506 are the controlling general statutes for Arizona’s comparative fault and allocation scheme used in this workflow. No claim-type-specific sub-rule was found for this guide, so treat this as the baseline/default method.
• To get the most reliable results, you’ll typically need: (1) each party’s fault %, (2) the total recoverable damages you’re allocating, and (3) any settlement/credit constraints you want the tool to reflect.

Inputs you need

To calculate damages allocation in Arizona with DocketMath, gather inputs that align with the comparative fault structure reflected in A.R.S. §§ 12-2505 and 12-2506.

Core inputs (typically required)

• Total damages (T): The dollar amount the trier of fact (jury/court) finds recoverable before allocation.
• Fault percentages by party:

  • Party A fault %
  • Party B fault %
  • (Optional) Other parties fault %
• Fault total check: Your fault percentages should sum to 100%. If your verdict form uses a framework that doesn’t naturally normalize to 100%, decide how you want DocketMath to handle “unallocated” fault before you run the tool.

Common allocation modifiers (often required)

These inputs are frequently what make the “numbers on the page” match the “numbers in the docket”:

• Settlement amounts (if applicable): If the case includes settlements and you are allocating remaining damages among non-settling parties, you’ll need settlement figures so the calculation reflects the statutory approach you’re aiming to reproduce under Arizona’s comparative/fault allocation scheme.
• Judgment reduction / credits (if applicable): Enter any amounts the court already reduced (or requires to reduce) the judgment by statute, setoff, or order—so you don’t inadvertently mismatch “gross” damages versus “net payable” outcomes.
• Party role mapping: Clearly identify who is a plaintiff and who is a defendant (and who is in the allocation pool). This helps the calculator assign allocated shares correctly.

Practical checklist (data-validation step)

Use this checklist before you click DocketMath → /tools/damages-allocation:

• Total damages (T) is confirmed from the verdict/judgment.
• Fault % values come from the final verdict (not opening statements or counsel arguments).
• Fault % totals sum to 100%, or you’ve explicitly normalized them (or documented why you didn’t).
• Any settlements/credits are recorded with correct dates/amounts (as applicable).
• Parties are mapped correctly (plaintiff vs. defendant) for the output you want (who receives vs. who pays).

How the calculation works

DocketMath’s damages-allocation calculator is designed to model Arizona’s general allocation approach reflected in:

• A.R.S. § 12-2505 (comparative fault framework and general method for apportioning responsibility in covered civil actions)
• A.R.S. § 12-2506 (general rule governing allocation among parties—how fault translates into recoverable responsibility)

Because the brief notes no claim-type-specific sub-rule was found, this guide uses the general/default method represented by those statutes.

1) Confirm the fault allocation basis (comparative fault)

Start from:

• Total damages (T)
• Fault % per party (e.g., 40% / 60%)

With comparative fault, the proportional logic is:

In a simple two-party example:

• T = $250,000
• Party A: 40% → A = 250,000 × 0.40 = $100,000
• Party B: 60% → B = 250,000 × 0.60 = $150,000

2) Apply statutory constraints/corrections (when you have them)

Real cases often include adjustments that mean you should not treat allocation as “pure math” only. Depending on case posture, you may need to incorporate:

• Settlement-related adjustments
• Judgment reductions/credits
• How the “allocation pool” is represented for parties actually addressed in the final judgment

DocketMath relies on the inputs you provide to produce outputs that align with the statutory allocation framework you’re using (here, A.R.S. §§ 12-2505 and 12-2506) rather than assuming settlements are irrelevant.

3) Produce outputs you can use (allocated shares and reconciliation)

After you run DocketMath → /tools/damages-allocation, you should expect:

• Allocated damages by party
• Net payable amounts (reflecting any reductions/credits you entered)
• A reconciliation check (or at least a clear basis for verifying) so you can confirm allocations tie back to the damages figure you used

A good workflow is always to reconcile:

• Allocated total (pre-modifiers) vs. T
• Net total (post-modifiers) vs. the court’s net/payable basis you’re trying to match

Worked calculation template (proportional allocation)

Use this as a quick “sanity check” for what the calculator should be doing in the baseline case:

• T = $250,000
• Fault split:

  • Party A: 40%
  • Party B: 60%
• Allocations:

  • A = 250,000 × 0.40 = $100,000
  • B = 250,000 × 0.60 = $150,000

Then, re-run with settlement/credit inputs (if applicable) to see how net shares shift under the same comparative fault framework.

Validation step you should always do

After running DocketMath:

• Confirm the allocated damages sum to your working total (T) or to your post-modifier total.
• Confirm fault % values match the verdict form (i.e., the numeric percentages the jury/court assigned).

Common pitfalls

1) Using narrative fault instead of verdict fault percentages

Arizona allocation at the calculator step depends on numeric fault percentages. If your record only describes fault qualitatively, you’ll need to extract or convert to percentages from the actual verdict/judgment materials.

2) Fault totals not summing to 100%

If fault percentages don’t sum to 100%, DocketMath may not know whether you intended to normalize, whether there is “other” fault outside your input list, or whether the verdict framework is being represented differently. Normalize (only if it matches the verdict method) or explicitly document your approach before running the tool.

• Verify the verdict’s fault % values
• Normalize only if consistent with the verdict/judgment framework

3) Double-counting settlement effects

Settlements can change what remains for allocation among non-settling parties. Enter settlement/credit inputs once and make sure they correspond to the same judgment basis as T.

4) Confusing party roles (who pays vs. who receives)

If you mis-map plaintiff/defendant roles or allocate to the wrong party set, you can get outputs that don’t correspond to the real payment direction. Ensure your tool inputs reflect:

• who’s in the allocation pool as a liable party, and
• which parties are receiving the allocated damages.

Sources and references

• Arizona Revised Statutes (A.R.S.) §§ 12-2505 and 12-2506 — General statutes governing comparative fault and allocation framework.
  Source: https://www.azleg.gov/ars/12/02505.htm

Next steps

1. Collect the verdict/judgment numbers

   • Total recoverable damages (T)
   • Each party’s fault %
2. Run DocketMath → /tools/damages-allocation

   • Enter fault percentages per party
   • Add settlement/credit inputs if you want the tool to reflect those constraints in the outputs
3. Reconcile the totals

   • Allocations should add up to T (or to the post-adjustment basis you’re using)
4. Document your calculation basis

   • Keep the fault % source (verdict form section)
   • Keep the damages total source (judgment entry or verdict amount)
   • Note whether you normalized fault to 100% and why

Related reading

• How to calculate Damages Allocation in Philippines — Full how-to guide with jurisdiction-specific rules
• Worked example: Damages Allocation in Philippines — Worked example with real statute citations
• [Inputs