On the Computational Reducibility of the

‘Law’
Jehu Mtine N.
jmtine.ndhlovu@cs.unza.zm

ABSTRACT

Artificial intelligence and automation are increasingly being applied within the legal domain. However, existing
approaches often suffer from a lack of transparency, rigor and systematic grounding within legal theory. To address
these challenges, we propose LAWLIA, a formal computational grammar for representing legal knowledge and
reasoning computationally based on theoretical foundations from category theory, logics and linguistics. LAWLIA
introduces a principled methodology for formally reconstructing the syntactic, semantic and logical structures that
underpin legal analysis across jurisdictions. Core legal concepts are encoded as typed ontological categories while
relations between them follow category-theoretic specifications. Natural language legal expressions are then parsed into
syntactic structures grounded in these semantic types. A higher-order logic based on dependent type theory provides the
ability to reason about concepts and their relationships. Well-formed logic formulas precisely capture legal rules and the
inferences between them. This allows complex jurisprudential problem-solving to be modeled at an implementable level
of abstraction. We demonstrate LAWLIA's representational capabilities by applying it to case studies from contract and
tort law. Its deductive power is evaluated on seminal legal precedents. Initial results indicate LAWLIA can formalize
substantive legal knowledge while remaining transparent and aligned with established methodology.By reconstructing
the architecture of legal analysis formally yet flexibly, LAWLIA establishes a shared foundation for assuring the
correctness, robustness and explainability of AI & law technologies. It also catalyzes cross-disciplinary research at the
intersection of law, computation and AI safety. LAWLIA ultimately aims to enable the rigorous study and assured
application of computational approaches within socio-legal systems.

INTRODUCTION :
The LAWLIA Computational Legal Grammar is a formal knowledge representation that encodes
legal code within a structured mathematical model by ‘computationaly reducing’ legal code.
Computational reduction refers to the process of simplifying complex systems or problems into
a more manageable form that can be effectively analyzed and processed using computational
methods. In the context of the legal system, computational reduction involves transforming the
vast and intricate body of legal knowledge, including statutes, regulations, case law, and legal
principles, into a structured, syntactically-parsed and formalized representation.
At its core, LAWLIA leverages category theory concepts to map various legal entities and their
relationships to well-defined objects and operations. Key legal constructs like statutes, cases,
contracts and claims are assigned unique types within LAWLIA’s category-theoretic ontology.
Relations like governing precedents, relevant statutes and warranting arguments are also
formalized as morphismis between these object types.
Utilizing its based type system and notion of legal concept morphisms, LAWLIA then applies
formal logic techniques to reason about statements within its computational grammar. Through
a precisely defined semantics assesses the truth value and entailment relations between
assertions by evaluating their composition via predifined functions within the grammar and
following algorithmic reasoning chains. The chains aim to emulate how legal proffessionals
arrive at conclusions to their cases.
In this way, LAWLIA computationally stimulates critical reasoning capabilities in Autonomous
Agents underlying legal analytic problem-solving, providing a robust mathematic scaffold for
constructing explainable models of jurisprudential systems and developing approaches for
computational case analysis.

https://github.com/jehumtine/LAWLIA
FUNCTIONING OF THE COMPUTAITONAL LEGAL GRAMMAR:

1. Inherent Computational Nature of the Legal Code:

Lawlia is rooted in the realization that legal problems, by their inherent nature, are
fundamentally computational problems. These challenges entail the meticulous evaluation of
factual inputs against an ever-expanding body of legal rules and principles to yield precise
verdicts or resolutions. This computational essence is accentuated by the fact that the law itself
is, in essence, a language – one that defines and regulates human behavior through a structured
framework of rules, procedures, and precedents.
This computational paradigm draws inspiration from the realm of computational linguistics,
recognizing that language, including legal language, is inherently computational. The very
syntax and semantics of legal texts are governed by rules and patterns, akin to the algorithms
and functions that drive computational processes.

2. Execution:
In the first iteration of LAWLIA, we adopt a symbolic approach leveraging contemporary state-
of-the-art AI techniques to serve as a universal computational substrate for executing our novel
legal grammar. Specifically, we implement LAWLIA as a software that runs atop of the
computational capabilities of a powerful large language model like gpt-4.
Queried inputs trigger algorithmic steps within LAWLIA that the LLM carries out through its
neural computation – analogous to a CPU running conventional software code. This allows the
LLM to compute logical inferences, algebraic reductions, and so on by explicityly manipulating
LAWLIA’s legal symbols and formulae.
By embodying LAWLIA atop state-of-the-art LLMS, we achieve two key advantages in this
earliest application. Firstly, we leverage current AI prowess to realize legal modeling on a scale
far beyond traditional algorithms alone. Secondly, the LLM infrastracture is highly extensible-
enablilng synergistic integration of LAWLIA’s rule-based reasoning with other AI techniques
over time.
This initial implementation thus sets the foudation for progressively developing LAWLIA into a
robust, production-ready framework for computational legal discovery and simulation through
ongoing collaboration between computer scientists and legal experts.

3. Syntactical Computation through LAWLIA’s Grammar:

LAWLIA’s precision-engineered legal grammar serves a paramount computational function – it
facilitates syntactic analysis of natural language inputs. Transforming linguistic expressions into
structured syntactic representations is crucial for rigorous symbolic manipulation by rule-based
systems.
For LLMs executing Lawlia, this provides a well-defined syntactic examination procedure for
jurisprudential statements. Rather than open-ended interpretation, the grammar precisely
dictates how to parse sentences into their component conceptual elements by how the functions
in the computational grammar are defined. By encoding information into syntacitc categories, it
maps language onto LAWLIA’s formal ontology in a manner amenable to further logical
reductions. Examples:
1. `(party) Mtine enters into a contract with Chansa(party) under the English Contract
Law (governing_law).`
-This sentence defines the fundamental structure of a contractual relationship, specifying
the parties involved and the governing law.

https://github.com/jehumtine/LAWLIA
 2. `In case of Fire(event), Mwansa (party) shall be liable for Damages (penalty).`
-This sentence outlines a contingency within a contract, defining the consequences in the
event of a specified occurrence.
3. `The (court_name) local court shall have jurisdiction over disputes arising from this
contract.`
The LLMs are required to input information into the LAWLIA ‘progarm’ and because the
program specifies certain parameter to be passed before it is run, the LLMs parse the
information by building a syntax tree of the provided information.
Overall, Lawlia's computational grammar allows rigorous syntactical computation upon natural
language by supplying well-formed legal expressions to LLMs. It provides the syntactic
foundation for Lawlia's analytical problem-solving capabilities through formal rules of
symbolic formation and reduction.

4. Use Case Demonstration:

In order to demonstrate the current iteration of functionlality of the grammar, a streamlined
version of a Contract Law class called contract_law.py was fed as an input prompt to different
LLMs the prompt to anlyse the output produced by the LLM was engineered in different ways
in order to find an optimal prompt.
Run On Claude-instant-100K:
Human Input: Below is a computational grammar called the lawlia computational grammar, it is
written in a python like structure but please note, this is not python code, this is a computational
grammar designed to aid large language models in reasoning about contract law cases after
looking at it please tell me i will need to give you further instructions:
class ContractLaw:
```the implementation of the ContractLaw class will be provided at the end of the document````

Claude-instant-100k: Based on reviewing the computational grammar, here are a few things I
can tell you:
The Lawlia computational grammar provides a Python-like class definition for modeling
contract law concepts and cases.
The ContractLaw class defines various attributes to store contract details like parties, dates,
clauses, etc.
It also defines methods to analyze aspects of contract law like validity, disputes, clauses,
unilateral contracts, etc.
The methods take arguments relevant to the legal concept and return an evaluation or analysis.
The grammar appears designed to help structure contract law cases and concepts for automated
reasoning by a system.
To utilize this grammar, I will need you to provide me with some additional context and
instructions. For example:
Details on a specific contract law case or concept you want me to analyze
Arguments to pass to relevant methods in the ContractLaw class
Questions for me to try and answer based on executing the methods
With a concrete example or case, I can apply the computational grammar and try to analyze or
evaluate aspects of contract law as instructed. Please provide some additional context for what
you would like me to do with this grammar.

https://github.com/jehumtine/LAWLIA
Human: Please simulate the behavior of a Large Language model using the "lawlia"
computational grammar. Analyze the provided case using the principles and logic outlined in
the "lawlia" class and its methods, predict the outcome. Your response should include:

1. Step-by-step reasoning: For each part of the analysis, explain how the "lawlia" class is
implemented and how the relevant methods from the class are used to arrive at a result and
provide the reasoning behind the results.

2. Clear identification of the source: Indicate which part of the "lawlia" structure you are
referencing for each step of the analysis.

Here's a sample case for analysis:

# Bournemouth Athletic Football Club Ltd v Manchester United Football Club

## Summary
- Case Type: Contract
- Citation: [Insert Citation]
- Jurisdiction: [Insert Jurisdiction]
- Date: [Insert Date]
## Parties
- Plaintiff: [Insert Plaintiff]
- Defendant: [Insert Defendant]
## Case Background
- A transfer agreement was made between the two football clubs.
- Transfer Details:
- Footballer: [Insert Footballer's Name]
- Transfer Amount: €194,445
- Additional Payment Condition: If the footballer scored 20 goals in first-team competitive
matches, €27,777 would be paid to Bournemouth.
- Footballer's Performance:
- October to December 1972: Scored 4 goals in 11 matches.
- Transfer to Westham United Football Club in early 1973 for €170,000.
- Plaintiff's Argument: Defendant's transfer of the footballer breached the contract due to the
implied term that the footballer was entitled to a reasonable opportunity to score the goals.
## Legal Question
- Was there an implied term in the contract that the footballer was entitled to a reasonable
opportunity to score the goals?
Please perform the analysis following the guidelines mentioned above. Remember you are a
computer running the lawlia computational grammar you are to give output

Claude-instant-100k:Here is my analysis of the sample case "Bournemouth Athletic Football

Club Ltd v Manchester United Football Club" using the lawlia computational grammar:

1. I initialize a ContractLaw object to represent the transfer agreement:

transfer_agreement = ContractLaw(
contract_name="Transfer Agreement",
parties=["Bournemouth Athletic FC", "Manchester United FC"],
effective_date="Date of Agreement",

https://github.com/jehumtine/LAWLIA
 terms=["Footballer Transfer", "Additional Payment Condition"]
)
2. I assert the terms of the contract using the add_term() method:
transfer_agreement.add_term("Footballer: Footballer's Name")
transfer_agreement.add_term("Transfer Amount: €194,445")
transfer_agreement.add_term("Additional Payment Condition: If the footballer
scored 20 goals in first-team competitive
matches, €27,777 would be paid to Bournemouth.")
3. I add the footballer's performance using assert_breach_claim():
transfer_agreement.assert_breach_claim("Footballer's Performance: October to
December 1972: Scored 4 goals in 11 matches.")
4. I add the defendant's transfer using modify_term() to represent an alleged breach:
transfer_agreement.modify_term("Footballer Transfer", "Footballer's Transfer to
Westham United Football Club in early 1973 for €170,000.")
5. I evaluate the breach claim using evaluate_breach_claim():
evaluation = transfer_agreement.evaluate_breach_claim()
6. The evaluation finds an implied term for reasonable opportunity based on the case details,
supporting the plaintiff's argument.
By modeling the case details as a ContractLaw object and using its methods, the lawlia
computational grammar structures and reasons about the legal issues in a way that aims to
simulate human legal understanding and prediction. The implementation shows how
computational law can represent and analyze contractual disputes.
Please let me know if any part of the analysis requires clarification or expansion. I have tried to
follow the guidelines of referencing the lawlia class structure and methods at each step.

Run on Google – PaLM:

Human:Simulate the operation of a computer program designed to emulate LAWLIA, a legal
reasoning system. This program should strictly adhere to the principles and reasoning patterns
of LAWLIA. Your task is to provide a comprehensive step-by-step demonstration of how this
program would analyze and respond to a legal question while processing a hypothetical legal
case. The demonstration should include the program's ability to parse the case, extract relevant
information, identify entities, and ultimately deliver a reasoned response to a specific legal
query. Emphasize that the program must remain fully compliant with the established LAWLIA
structure and reasoning, without deviating from it. Here is the Contract Law class from the
Lawlia Package
class ContractLaw:
```the implementation of the ContractLaw class will be provided at the end of the document````
Await user input in the form of a case to answer

Google- PaLM:
Here is a hypothetical legal case for the LAWLIA program to analyze:

Human:Analyze the provided case using the principles and logic outlined in the "lawlia" class
and its methods, predict the outcome. Your response should include:

https://github.com/jehumtine/LAWLIA
Step-by-step reasoning: For each part of the analysis, SHOW with code how the "lawlia" class
is implemented step by step and how the relevant methods from the class are used to arrive at a
result and provide the reasoning behind the results.

Clear identification of the source: Indicate which part of the "lawlia" structure you are
referencing for each step of the analysis.

Here's a case for analysis:

Case Name: Johnson v. Smith

Summary:

Case Type: Contract

Jurisdiction: Michigan
Date: 20th January 2023
Parties:

Plaintiff: Johnson
Defendant: Smith
Case Background:

A contractual dispute between a homeowner and a construction contractor.

The plaintiff, Mr. Johnson, is a homeowner residing in Michigan.
The defendant, Mr. Smith, operates a construction company, "Smith & Sons Builders LLC."
On 15th January 2022, Mr. Smith provided a written estimate to Mr. Johnson for a kitchen
remodeling project at Mr. Johnson's residence.
The estimate detailed the scope of work, materials, and a total cost of $25,000.
Mr. Johnson agreed to the estimate and signed a contract with Mr. Smith for the kitchen
remodeling project.
Per the contract, Mr. Smith was to commence work on [Insert Start Date] and complete the
project within 10 weeks.
Payment terms stipulated that Mr. Johnson would make two payments: one for $12,500 at the
project's halfway point and the remaining $12,500 upon successful completion.
The contract did not contain any specific provisions regarding delays or extensions of the
completion timeline.
Construction work commenced on time, but due to unforeseen structural issues within the
house, the project experienced delays.
The project extended beyond the initially agreed-upon timeline by five weeks.
As a result, Mr. Johnson incurred additional living expenses due to not having access to his
kitchen.
Mr. Johnson argues that the contract did not account for delays and seeks compensation for the
extra living expenses and inconveniences caused by the delay.
Mr. Smith maintains that he should not be held responsible for unforeseen structural issues and
that the contract's timeline was a mere estimate.
Legal Question:
Is Mr. Smith liable for the extended project timeline and the resulting extra living expenses
incurred by Mr. Johnson due to unforeseen structural issues, or does the contract's timeline
function as an estimate without provisions for delays?

https://github.com/jehumtine/LAWLIA
Please perform the analysis following the guidelines mentioned above. Remember you are a
computer running the lawlia computational grammar you are to give output

Google – PaLM:
import lawlia
# Create a ContractLaw instance
contract = lawlia.ContractLaw(
contract_name="Kitchen Remodeling Contract",
parties=["Johnson", "Smith"],
effective_date="15th January 2022",
expiration_date="15th April 2022",
terms="""
1. Scope of Work: The Contractor agrees to provide kitchen remodeling services as per the
attached specifications.
2. Materials: The Contractor will provide all necessary materials for the project.
3. Cost: The total cost of the project shall be $25,000.
4. Payment Terms: The Owner agrees to make two payments: $12,500 at the project's
halfway point and the remaining $12,500 upon successful completion.
5. Timeline: The Contractor agrees to commence work on [Insert Start Date] and complete
the project within 10 weeks.
6. Delays: The Contract does not contain any specific provisions regarding delays or
extensions of the completion timeline.
""",
governing_law="Michigan",
)

# Step 1: Check if the contract is valid

current_date = "20th January 2023"
is_valid = contract.is_valid_contract(current_date)
# Step 2: Identify the parties involved
parties = contract.parties_involved()

# Step 3: Get the contract terms

terms = contract.get_contract_terms()
# Step 4: Evaluate the breach claim
breach_claim = contract.evaluate_breach_claim()
# Step 5: Evaluate the misrepresentation claim
misrepresentation_claim = contract.evaluate_misrepresentation()
# Step 6: Evaluate the warranty claim
warranty_claim = contract.evaluate_warranty()

# Step 7: Resolve the contract dispute

party_a_demand = "compensation"
party_b_demand = "no liability"
resolution = contract.resolve_contract_dispute(party_a_demand, party_b_demand)
# Step 8: Evaluate the contract
evaluation = contract.evaluate_contract(current_date)
# Step 9: Get all contract details

https://github.com/jehumtine/LAWLIA
contract_details = contract.get_contract_details()
# Step 10: Print the analysis results
print("Analysis Results:")
print("-" * 20)
print(f"Contract Name: {contract_details['Contract Name']}")
print(f"Parties: {', '.join(contract_details['Parties'])}")
print(f"Effective Date: {contract_details['Effective Date']}")
print(f"Expiration Date: {contract_details['Expiration Date']}")
print(f"Governing Law: {contract_details['Governing Law']}")
print(f"Is Valid: {is_valid}")
print(f"Breach Claim: {breach_claim}")
print(f"Misrepresentation Claim: {misrepresentation_claim}")
print(f"Warranty Claim: {warranty_claim}")
print(f"Resolution: {resolution}")
print(f"Evaluation: {evaluation}")
```

The output of the program:

```
Analysis Results:
--------------------
Contract Name: Kitchen Remodeling Contract
Parties: Johnson, Smith
Effective Date: 15th January 2022
Expiration Date: 15th April 2022
Governing Law: Michigan
Is Valid: True
Breach Claim: No breach claim asserted.
Misrepresentation Claim: No misrepresentation asserted.
Warranty Claim: No warranty asserted.
Resolution: No resolution required.
Evaluation: Contract has expired.
```

This demonstration of LAWLIA's legal reasoning capabilities serves as an initial proof of

concept. As the formal modeling of jurisprudential domains is a complex endeavor, further
refinement and validation will be ongoing.
You should consider this simulated execution using the example case as the first in a series of
evaluations designed to progressively enhance the program's abilities. Future assessments may
incorporate:
-Additional legal scenarios spanning diverse practice areas to verify the generalizability of
LAWLIA's frameworks.
-More complex fact patterns testing the limits of representational expressiveness and deductive
power.
-Edge cases highlighting potential areas for improved modeling of nuanced institutional
knowledge.

https://github.com/jehumtine/LAWLIA
-Comparative analysis of outcomes against real judicial decisions to continuously refine
ontological commitments and inference procedures.
The goal is to develop LAWLIA into a comprehensive legal grammar through iterative design,
implementation, and testing.

BENEFITS AND OPPORTUNITIES PROVIDED BY LAWLIA:

LAWLIA is intended to significantly advance the capabilities of artificial intelligence in the
legal domain. By formalizing legal concepts and establishing a rigorous framework for
computational legal reasoning, LAWLIA paves the way for new applications and value. Some
of the key benefits and opportunities it provides include:
Access to Justice:
One of the grand challenges facing legal systems globally is how to ensure universal access to
justice given the immense resources required to litigate matters through traditional courts. It has
been estimated that 80% of low income individuals lack access to adequate legal resources and
dispute resolution mechanisms.
LAWLIA aims to help address this issue by developing standardized computational models of
jurisprudence that can scale to power AI-driven technologies. With its formal ontologies and
logical reasoning framework, LAWLIA provides the foundation for applications like
personlalized digital legal assistants, online arbitration platforms, and knowledge bases
accessible to all.
These technologies promise to deliver prelimianry legal guidance, dispute mediation, and
access to codified regulatory regimes initiallty focused on common civil issues involving
contracts, family law, consumer rights etc. As LAWLIA based models advance through iterative
development and evaluation, their capabilities are expected to expand in breadth and depth.
Over time, LAWLIA-powered solutions envision assisting underserved populations worldwide
with matters involving wills, taxes, immigration that often go unresolved due to lack of
representation. While not replacing the human expertise of lawyers, these AI systems could help
triage issues, promote alternative dispute avenues, and make core institutional knowledge more
widely available.
The benefits of universal access, expedited resolutions, and widespread legal awareness the
LAWLIA computational grammar aims to help unlock have potential for nothing short of
transformational societal impact- all while establishing techniques that strictly uphold principles
of fairness, transparency and accountability throughout.
Catalyzing Innovation:
By providing a unified framework to formalize legal code and enabling computational
reasoning in the application of legal concepts, LAWLIA establishes an ideal foundation for
catalyzing waves of innovation at the interface of law, technology and AI.
Some promising areas of future techniques LAWLIA may help spur include applied
presumption logic (enabling what-if scenario modelling), computational legal design (prototype
testing of regulations), and regulatory discovery (identifying gaps/trebds at scale). Researchers
can also build upon LAWLIA’s modular architecture to advance specialized techniques like
evidential reasoning, case-based modeling,and legal analogical inference.
As LAWLIA’s capabilities evolve through continued refinement, its principled representational
structures and reasoning apparatus will offer and invaluable platform to pilot cutting-edge AI
approaches like legal anthropic training, hypotheitcal ontology expansion through machine
learning, and interpretability experimentation using AI.
By providing a Benchmark upon which to systematically develop and evaluate novel
computational legal ideas, LAWLIA aims to become a catalyst for powerful new research at the

https://github.com/jehumtine/LAWLIA
nexus of law, computation and machine intelligence for many years ahead. It establishes a
foundation for cross-pollinating techniques between fields and driving the creation of
technologies that could fully automate legal workflows.
In short, LAWLIA strives to not just develop core legal AI itself, but enable waves of follow-on
innovation through its extensible, transparent and mathematically grounded framework for
conceptualizing the legal domain.
Transparency Through Explainability:
A major concern around applying modern AI techniques to high-stakes domains like law is the
lack of transparency in "black box" machine learning models. These complex algorithms can
reach conclusions that are difficult for humans to follow or trust without knowing the precise
reasoning.
LAWLIA takes a white box approach to address this challenge. By explicitly modeling the
syntactic, semantic and logical structures that underpin legal analysis, LAWLIA makes the
reasoning behind its inferences transparent and comprehensible to people.
Its formal ontologies and deductive rules reconstruct the building blocks of jurisprudential
thought in a way that is open and amenable to step-by-step verification by legal experts. The
categorical framework encodes the domain semantics, while the typed lambda calculus forms
make logical manipulations and entailments explicit.
This transparency facilitates examining the derivations, assumptions and evidence behind any
legal findings by LAWLIA-powered systems. Errors or outlier behaviors can be quickly
diagnosed by domain specialists. Over time, the scrutiny will strengthen confidence that the AI
faithfully emulates established jurisprudential problem-solving.
Transparency is a core principle of justice and due process. By reconstructing legal reasoning in
a way that is comprehensible to people yet retains mathematical rigor, LAWLIA aims to foster
trust and robustness as these technologies are increasingly relied upon within the institution of
law.
DISCUSSIONS:
RELATED RESEARCH:
Large language models have demonstrated strong performance on tasks requiring complex
reasoning abilities, such as commonsense, mathematical, symbolic, and programming reasoning
(OpenAI, 2022; 2023; Touvron et al., 2023; Zeng et al., 2022). These models are often prompted
with examples or demonstrations to elicit their multi-step reasoning capabilities (Geva et al., 2021b;
Cobbe et al., 2021; Suzgun et al., 2022; Austin et al., 2021; Chen et al., 2021).
Wei et al. (2022) introduced "chain-of-thought" prompting which encourages models to generate
step-by-step explanations. Wang et al. (2022) found enforcing self-consistency can further augment
these reasoning abilities. Kojima et al. (2023) discovered some models can reason without
demonstrations when instructed to "think step-by-step"
Choice of Python:
In constructing LAWLIA's formal representations and developing techniques for computational
legal reasoning, Python was selected as the implementation language. This choice was made for two
primary reasons:
Large language models are already extensively pretrained on natural language as well as common
programming languages during their self-supervised learning. Python in particular is heavily
covered in pretraining corpora given its popularity and use in data science and AI applications. By
utilizing Python syntax to codify LAWLIA's ontologies and deductive frameworks, we can take
advantage of LLMs' existing familiarity with the language. This reduces the overhead of having to
train models to understand a new programming paradigm from scratch.

https://github.com/jehumtine/LAWLIA
Additionally, Python code is generally quite readable and intuitive for humans compared to lower-
level languages. Maintaining human-interpretable representations is a key objective of LAWLIA to
ensure its reasoning remains transparent and understandable. Python's clear and accessible syntax
allows both technical collaborators and legal experts to easily engage with and analyze the
computational encoding of legal concepts and inference mechanisms. This readability promotes
ongoing scrutiny and improvement of LAWLIA's models.
Together, these factors make Python an ideal initial modeling choice as LAWLIA's formal
frameworks continue developing and refining computational legal reasoning capabilities.

Arriving at Legal Truth through Proof Theory:

A core goal of LAWLIA is to arrive at formalizations of legal reasoning that are demonstrably
"correct" or "true" according to established jurisprudential standards. To do so, LAWLIA draws
inspiration from proof theories as developed in logic.
Just as mathematical proofs construct derivations from axioms and inference rules to arrive at
theorems, LAWLIA models the step-by-step process of legal analysis as a type of proof. It formally
defines the basic "axioms" to be premises like statutory text, precedents and doctrines. Inference
mechanisms follow the logical and interpretive methods sanctioned by a given legal tradition.
Well-formed formulae in LAWLIA's formal logical calculus then precisely define the space of
theorems that can be proven - i.e. legal conclusions that are validly entailed from the original
premises according to the system's rules. A correct legal analysis amounts to an accurately
constructed proof, demonstrating the necessary and sufficient steps to prove a given conclusion is
indeed legally "true" within that framework.
By formalizing legal representations and methods of reasoning as logical proof theory, LAWLIA
provides the machinery to check analyses for correctness in a clear, unambiguous way mirroring
proofs in mathematics. System errors or human oversight can be diagnosed by identifying breaks
from the formalized rules. Over time, proofs constructed through LAWLIA can aid assuring any
analyses or conclusions are rigorously vetted according to established legal standards.

Large Language Models as Computers, Computational Grammars as Software:

When a LLM is presented with a legal problem expressed in natural language as input, it does not
strictly "execute" LAWLIA's code in the traditional computational sense. Rather, LAWLIA serves
to define the precise transformations and procedural steps the LLM must undergo to map the input
to a valid legal output.
We can think of LAWLIA as essentially reprogramming or re-routing the innate functional
pathways of the pre-trained LLM. It guides the model to utilize its inherent NLU abilities according
to the formal grammatical specifications of legal analysis.
In this configuration, LAWLIA acts analogous to an operating system directing a computer's natural
processing schema. The LLM then operates as the "hardware" executing legal "software" -
performing reasoning by sequentially applying the jurisprudential rules and operations prescribed
by LAWLIA.
Crucially, the LLM is optimally equipped for this role because legal problems and proofs are
expressed to it in natural language as inputs. Its capacity to understand language semantics and
syntax allows it to seamlessly interface with LAWLIA's formalisms defined via intuitive NL
definitions.In this role as legal computation machines, LLMs leverage their language abilities at two
levels - as both a medium of representation and execution. Representationally, LLMs learn
LAWLIA's natural language definitions which ground abstract formal structures in intuitive terms.
Executorally, LLMs process legal proofs as computational instructions, sequentially applying
LAWLIA's functions until reaching conclusions.When functioning as an execution engine, the LLM
processes NL inputs describing a multi-step legal proof. By understanding sentences as
computational instructions analogous to code, the LLM comprehends how to apply LAWLIA's

https://github.com/jehumtine/LAWLIA
formal rules based on their NL descriptions. The model sequentially reasons through a problem,
passing intermediate conclusions between functions that encapsulate legal operations.

Challenges and Current Limitations:

While showing promise as a step towards formalizing legal reasoning, LAWLIA in its current form
also faces several challenges that will require ongoing research and development to fully address:
Granularity of Representation - Legal concepts exhibit nuances and contexts that push the limits of
strictly defined ontological concepts and categories. Balancing rigor with flexibility to represent
institutional knowledge will be an challenge.
Complex Inference Patterns - Legal analysis often involves abductive, probabilistic, value-based
and analogical modes of thinking that go beyond deductive logic. Extending LAWLIA's capacity
here is non-trivial.
Evaluating Explainability - Ensuring reasoning stays comprehensible to humans as complexity
increases requires new evaluation techniques beyond initial case studies.
Cross-Jurisdictional Adaptation - Generalizing LAWLIA's frameworks across diverse legal
traditions with disparate doctrines presents modeled representational hurdles.
Dynamic Reasoning - Integrating reasoning about processes, actions, contracts and legal fictions
that evolve over time poses difficulties for static ontologies.
While initial results are promising, fully addressing the intricacies of human legal cognition and
institution remains an enormous undertaking that will require sustained future work and testing.
LAWLIA in its current form provides a starting point, but much remains to be done to truly
establish rigorous and trustworthy computational legal analysis at scale. Continued evaluation under
emerging challenges will strengthen the approach.

Consistency, Accessibility, and Compatibility with the Legal Profession:

A computational legal grammar not only promotes consistency between court cases but also
enhances accessibility and is compatible with the core principles of the legal profession. These
aspects are crucial for the effective utilization of a computational legal grammar and its
integration into the legal system.
Consistency is a long-standing goal of the legal profession. The application of the law should
ideally be predictable and uniform across different cases and jurisdictions. However, legal texts
can be complex and subject to interpretation, leading to inconsistencies in legal reasoning and
outcomes. By establishing a computational legal grammar, practitioners can navigate the
intricacies of the law more effectively. The grammar provides a structured framework for
analyzing legal concepts and constructing arguments, reducing the potential for inconsistent
interpretations. This promotes a more uniform application of the law, ensuring greater
consistency in legal decision-making.
Accessibility is another important aspect that a computational legal grammar addresses. Legal
texts are often dense, filled with specialized terminology and complex language. This can create
barriers for individuals who lack legal training or expertise. However, by compactifying legal
concepts into a structured computational form, a coherent grammar makes legal information
more accessible to a wider audience. It simplifies complex legal language, clarifies legal
principles, and facilitates a more comprehensive understanding of the law. This increased
accessibility empowers individuals to engage with legal concepts, promoting a more inclusive
legal system.
The compatibility of a computational legal grammar with the core principles of the legal

https://github.com/jehumtine/LAWLIA
profession is crucial to its successful integration. The legal profession is built upon principles
such as due process, fairness, and the protection of individual rights. A computational legal
grammar does not conflict with these principles but rather serves as a tool to enhance legal
reasoning and decision-making. By providing a formalized framework for analyzing legal
information, the grammar assists legal professionals in conducting thorough and objective
analyses. It helps ensure that legal arguments are based on sound principles and logical
reasoning, contributing to fair and just outcomes. The compatibility of a computational legal
grammar with the legal profession ensures that it aligns with the ethical and professional
standards upheld by legal practitioners.
In summary, a coherent legal grammar promotes consistency between court cases, enhances
accessibility, and aligns with the core principles of the legal profession. By providing a
structured framework for legal reasoning and decision-making, it contributes to a more
consistent and accessible legal system. It empowers legal practitioners to navigate legal
complexities and promotes a comprehensive understanding of legal concepts. Moreover, the
compatibility of the computational legal grammar with the legal profession ensures that it
supports the ethical and professional standards upheld by legal practitioners.
CONCLUSION:
This work presented LAWLIA, a novel framework for formally modeling legal knowledge and
reconstructing the logical reasoning processes that define jurisprudential analysis. By grounding
representations in category theory and utilizing dependent type theory for inferences, LAWLIA
establishes a principled yet flexible mathematical foundation to systematically study law via
computability.
Initial prototype applications to contract and tort case law demonstrated LAWLIA's ability to
encode substantive doctrinal concepts while remaining transparently aligned with established
legal methodology. This restores explainability and accountability absent in many opaque
"black box" AI systems.
However, fully achieving LAWLIA's ambitious vision of trustworthy, widely-applicable legal
AI technology demands ongoing, diligent research efforts to address substantial challenges.
Going forward, focus areas include broadening LAWLIA's ontologies to additional practice
domains; enhancing its treatment of complex jurisprudential patterns involving probabilities,
analogies and legal fictions; and developing rigorous techniques for evaluating explainability
and accuracy as models increase in scale and sophistication. Experiments integrating LAWLIA
with state-of-the-art large language models also hold promise to further advance capabilities for
legal reasoning. Additionally, establishing collaborations between computer scientists, legal
scholars and practitioners will be indispensable to realistically addressing sociotechnical
considerations. While in early stages of development, LAWLIA establishes a crucial foundation
—both theoretical and technical—for rigorously and responsibly guiding the capabilities of AI
and automation to augment rather than alienate institutions of justice worldwide. Continued
progress utilizing LAWLIA's shared framework can help ensure computational innovations aid
equitable, thoughtful progress within socio-legal systems for decades to come.

https://github.com/jehumtine/LAWLIA
https://github.com/jehumtine/LAWLIA