This repository provides an intutive rule engine to determine eligibility for vacating default judgments in California unlawful detainer cases. It encodes statutory rules and case-law exceptions into a uniform logical framework that programmatically identifies available grounds for vacating default judgments.

This tool is designed specifically for attorneys handling unlawful detainer cases in California - it is a Decision Support System for legal professionals. It streamlines the analysis of whether a default judgment can be vacated under applicable California statutes and case law, saving valuable time while ensuring comprehensive review of all potential grounds.

The engine encodes California's statutory and case law regarding unlawful detainer default judgment vacatur. Each ground for relief is represented as a logical rule with explicit citations to controlling authority.

rule(<ID>, [<Condition1>,…], <Conclusion>, [<Citation1>,…]).

• ID: Unique rule identifier (e.g., relief_excusable_neglect).
• Conditions: List of atomic predicates or negations (not pred(...)).
• Conclusion: Predicate that holds if all conditions are met.
• Citations: Array of statute or case references.

1. service_personal – CCP §415.10 (personal delivery)

   • Evaluates whether personal service was properly effectuated

2. service_substituted – CCP §415.20(b) (substituted service)

   • Checks compliance with substituted service requirements, including reasonable diligence

3. default_entry_clerk – CCP §585(a) (entry of default)

   • Verifies timing requirements for clerk-entered defaults

4. relief_excusable_neglect – CCP §473(b) (excusable neglect)

   • Applies the "mistake, inadvertence, surprise, or excusable neglect" standard
   • Enforces six-month time limitation from entry of judgment

5. relief_no_actual_notice – CCP §473.5(a) (lack of notice)

   • Evaluates claims of no actual notice despite formally valid service
   • Applies appropriate timing limitations

6. relief_void – CCP §473(d) (void judgment)

   • Handles jurisdictional defects rendering judgment void

7. relief_void_improper_service – Case law (improper service)

   • Applies case law exceptions for service defects

The system includes built-in predicates that handle critical time calculations for unlawful detainer practice:

• days_since_service_at_least(P,N) – verifies minimum days after service (important for default timing).
• within_six_months_judgment(P) – checks if motion falls within CCP §473(b)'s six-month limit.
• within_two_years_entry(P) – verifies compliance with two-year outer limit for certain motions.
• within_limit_473_5(P) – calculates the timing requirements specific to CCP §473.5 motions.

holds(C) :- rule(_, Conds, C, _), all_true(Conds).
all_true([]).
all_true([H|T]) :- cond_true(H), all_true(T).
cond_true(not A) :- not holds(A).
cond_true(A)     :- holds(A).

Attorneys can represent their case facts as simple statements in the ud_vacate.asp file. The format is intuitive and resembles how you would describe case events to a colleague. For example:

personal_delivery(summons, complaint, defendant).
days_since_service(defendant, 32).
default_judgment_taken(defendant).
days_since_entry(defendant, 100).

These facts correspond to real-world case events:

• How service was attempted or accomplished
• When key documents were served
• Whether default was entered and when
• Whether judgment was entered and when
• Any procedural defects or special circumstances

Running the solver generates attorney-ready conclusions about available vacatur grounds:

holds(vacate_default_judgment(defendant))
holds(relief_excusable_neglect(defendant))
holds(within_six_months_judgment(defendant))

These outputs indicate:

1. The defendant has grounds to move to vacate the default judgment
2. The specific statutory basis available (here, CCP §473(b) for excusable neglect)
3. That time requirements are satisfied (within six months of judgment)

Each conclusion directly maps to a legal argument you can include in your motion papers, with the underlying rule providing the statutory or case citation.

The repository includes sample scenarios that demonstrate how the engine evaluates common vacatur situations. For example, the included test case demonstrates a successful CCP §473(b) excusable neglect scenario.

To run the included test scenario:

clingo ud_vacate.asp

Expected output: holds(vacate_default_judgment(defendant)), confirming relief is available.

These tests serve as both examples for how to structure your own case facts and validation that the legal rules are functioning correctly.

This is an open-source legal tool that welcomes contributions from both attorneys and technical collaborators:

• Adding Legal Rules: Attorneys can contribute new statutory interpretations or case law by inserting rule(...) facts with appropriate citations.
• Test Cases: Contribute real-world scenarios (anonymized) to build a comprehensive test suite that validates coverage of edge cases.
• Legislative Updates: Help maintain the tool's currency with changes to California law by opening issues when statutes are amended.
• Technical Improvements: Developers can enhance the engine's efficiency, user interface, or documentation.

To contribute, submit pull requests or open issues describing the legal basis and proposed implementation.

1. Case Facts Input: Attorney provides key and relavent facts of a Tenant as simple statements—e.g., dates of service, whether a response was filed, timing of motions, and any defects in service.
2. Rule Evaluation: Each statutory ground (e.g., CCP §473(b), §473.5(a), §585(a), §415.20(b)) and relevant case‑law exception is encoded as an "IF … THEN …" rule. The engine checks whether each set of conditions is satisfied.
3. Results: The system outputs clear conclusions (holds(vacate_default_judgment(defendant))) identifying which vacatur grounds apply. Each conclusion references its controlling statute or case law.

• Comprehensive Coverage: Encodes every judgement vacating ground—mistake, lack of notice, improper service, void judgments—so attorneys can't miss a deadline or exception - reduce cognitive burden in calculation of dates and rules.
• Consistency & Speed: Automates checklisting across multiple cases with uniform logic.
• Auditability: Every inference is traceable back to a rule ID and statutory citation, providing a built‑in audit trail.
• Accurate and thorough Legal Narrative: Aids attorney build a clients legal narrative without missing any legally relevant component.

1. Edit the ud_vacate.asp file to include your case's base facts.
2. Run the engine (e.g., clingo ud_vacate.asp).
3. Review printed holds(...) facts to see which vacatur motions are available.

For detailed legal citations and code structure, see ud_vacate.asp.