<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Jason Morris on Medium]]></title>
        <description><![CDATA[Stories by Jason Morris on Medium]]></description>
        <link>https://medium.com/@roundtablelaw?source=rss-a0ffc78977a0------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*rEDd7hTNOVDktDS1OEarGg.jpeg</url>
            <title>Stories by Jason Morris on Medium</title>
            <link>https://medium.com/@roundtablelaw?source=rss-a0ffc78977a0------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 02:15:50 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@roundtablelaw/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Rules as Code Diary is Moving]]></title>
            <link>https://medium.com/computational-law-diary/rules-as-code-diary-is-moving-a234bc5d9572?source=rss-a0ffc78977a0------2</link>
            <guid isPermaLink="false">https://medium.com/p/a234bc5d9572</guid>
            <category><![CDATA[rules-as-code]]></category>
            <dc:creator><![CDATA[Jason Morris]]></dc:creator>
            <pubDate>Mon, 10 Jan 2022 20:32:19 GMT</pubDate>
            <atom:updated>2022-01-10T20:32:19.775Z</atom:updated>
            <content:encoded><![CDATA[<p>I’ve decided to move the Rules as Code diary away from Medium. For the time being, it is being hosted at <a href="https://jasonmorrissc.github.io/">https://jasonmorrissc.github.io</a>.</p><h4>Why Move Away from Medium?</h4><p>Honestly, the primary reason is that I’m sick of writing blog posts about code in a tool that doesn’t have syntax highlighting, and uses unreasonably short line lengths.</p><p>Medium’s writing interface still has a lot to be said for it. But the downside in complexity of using something more sophisticated has gone down as I have become more familiar with the tools of the software development trade. So my new blogging tech stack is VS Code, Markdown, Hugo, and GitHub Pages.</p><p>As an added benefit, no one is forcing me to uncheck a check-box that says “can we please charge people to read this,” which I find grating.</p><p>All of the posts from Medium (except this one) have been migrated to the new site. There are also three new blogs that are going live for the first time today.</p><h4>How Will I Know When You Post?</h4><p>Thank you for asking, friend! You can follow me on <a href="https://twitter.com/RoundTableLaw">Twitter, at @RoundTableLaw</a> and I will try to announce things there.</p><p>And, you can join talk.RulesAsCode.com, which is free, and will notify you of new posts however you like. I will send digests of the blog there regularly, and you can follow my account.</p><p>Thanks for reading!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a234bc5d9572" width="1" height="1" alt=""><hr><p><a href="https://medium.com/computational-law-diary/rules-as-code-diary-is-moving-a234bc5d9572">Rules as Code Diary is Moving</a> was originally published in <a href="https://medium.com/computational-law-diary">Rules as Code Diary</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Rules as Code Diary 2020–2021 in Review]]></title>
            <link>https://medium.com/computational-law-diary/computational-law-diary-2020-2021-in-review-51b66f3253b4?source=rss-a0ffc78977a0------2</link>
            <guid isPermaLink="false">https://medium.com/p/51b66f3253b4</guid>
            <category><![CDATA[rules-as-code]]></category>
            <category><![CDATA[computational-law]]></category>
            <category><![CDATA[legaltech]]></category>
            <dc:creator><![CDATA[Jason Morris]]></dc:creator>
            <pubDate>Mon, 20 Dec 2021 21:56:29 GMT</pubDate>
            <atom:updated>2021-12-20T21:57:50.848Z</atom:updated>
            <content:encoded><![CDATA[<p>It’s traditional at the end of the year to look back and see where you started, and how far you have come. I’m going to extend the look back to 2020, because I started Computational Law Diary half way through 2020.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*kFH3QTivoKDtihgGFXX8FA.png" /><figcaption>“2021 in Review” by <a href="https://is.gd/artmachine">AI Art Machine</a> in the style of <a href="https://en.wikipedia.org/wiki/Emily_Carr">Emily Carr</a></figcaption></figure><h3>A Little Personal Background</h3><p>I started my full-time career in computational law about the same time that I started the Computational Law Diary in July of 2020. I spent one year with the <a href="https://cclaw.smu.edu.sg/">Singapore Management University Centre for Computational Law</a>, as the Principal Research Engineer in Symbolic Artificial Intelligence. I travelled to Singapore in January of 2021, and finished my one-year term with the Centre in June of 2021. I then returned home to Canada, and started a position in September as Director of Rules as Code inside the Benefits Delivery Modernization Program inside Service Canada, which is responsible for <a href="https://alpha.servicecanada.gc.ca/">alpha.servicecanada.gc.ca</a>.</p><p>Looking back, while my work responsibilities have changed between the two positions, the things that get me excited enough to write about haven’t changed much. From my perspective, at least, it feels like I have been learning about and implementing things in much the same way. It’s just that my work at SMU was focused on building better tools, and my work at Service Canada is focused on writing working code with the best tools we have.</p><h3>Highlights from 2020 and 2021</h3><p>Here are some of the big things that happened over the first year and a half of the Computational Law Diary:</p><h4>2020: <a href="https://medium.com/computational-law-diary/computational-law-diary-responding-to-mas-writing-in-sign-7f6972cd977c">Blawx Paper in MIT Computational Law Report</a></h4><p>I had the honour of publishing a paper in the MIT Computational Law Report demonstrating the use of my software Blawx to encode Covid-19 rules, and build a user-facing app on the basis of that encoding.</p><h4>2020: <a href="https://medium.com/computational-law-diary/computational-law-diary-drooling-over-rules-as-code-52aa0470b792">Presentation at Legislative Drafting Conference</a></h4><p>I got to speak at a conference of legislative drafters about the future that I saw for Rules as Code, and why it might be important to get legislative drafters involved and excited.</p><h4>2020: <a href="https://medium.com/computational-law-diary/computational-law-diary-blawx-runner-up-at-atla-and-visual-interfaces-rock-904809dfbd26">ALTA Awards</a></h4><p>Blawx was awarded runner-up in the 2020 (inaugural) American Legal Technology Awards in the startup category.</p><h4>2020: <a href="https://www.oecd-ilibrary.org/governance/cracking-the-code_3afe6ba5-en">OECD Report</a></h4><p>The OECD Observatory for Public Sector Innovation published “Cracking the Code”, a comprehensive introduction to the state of the Rules as Code movement at the time. The paper cited by LLM thesis, and listed Blawx as an example of rules as code-specific technologies that might be deployed in the future.</p><h4>2021: <a href="https://medium.com/computational-law-diary/blawx-dev-notes-ca2bdf03cf3b">Updates to Blawx</a></h4><p>Early in 2021 I released a significant increase in the features of Blawx. Later in the year, that version was deployed live on the blawx.com website.</p><h4>2021: <a href="https://medium.com/computational-law-diary/s-casp-as-a-rules-as-code-tool-97ec3435975c">s(CASP)</a></h4><p>I first <a href="https://medium.com/computational-law-diary/computational-law-diary-explainable-legal-ai-in-s-casp-19da0a5d956">learned about s(CASP) in 2020</a>, and thought it was an interesting way to generate explanations from logical code. But it was in 2021 that I started working with it in earnest, including in the L4-Docassemble project, the ICAIL paper.</p><p>At a workshop on s(CASP) held at the International Conference on Logic Programming I did a presentation on my work in the legal realm with s(CASP). Later in the year I learned that <a href="https://medium.com/computational-law-diary/s-casp-swi-prolog-ccf8e53c951a">it was being re-implemented inside SWI-Prolog</a>. s(CASP) inside SWI-Prolog is now at the root of the best rules as code tech stack I can imagine.</p><p>s(CASP) is not merely marginally better than the other tools I have used. Access to the techniques of answer set programming has completely changed my expectations as to what a reasoning tool for computational law could and should do.</p><h4>2021: <a href="https://medium.com/computational-law-diary/introducing-l4-docassemble-69ce4b1fb1e7">L4-Docassemble</a></h4><p>L4-Docassemble was a project I built while with the SMU Centre for Computational law, that demonstrated the ability to automatically generate a prototypical web-based expert system on the basis of an s(CASP) encoding of the relevant legislation, and a LExSIS file that set out the relevant data structure and how to express questions in English.</p><p>As far as I’m aware, it remains the only open source solution for generating legal expert systems with natural language explanations, and the only legal expert system tool anywhere with the ability to encode exceptions the way they were written in the original law.</p><h4>2021: <a href="https://medium.com/computational-law-diary/rules-as-code-extended-abstract-to-appear-in-icail-21-proceedings-7fc5dedbf8b8">Debugging Legislation in ICAIL</a></h4><p>I published an extended abstract in the 2021 ICAIL proceedings talking about an experiment at SMU Centre for Computational Law where we were able to use s(CASP) in order to find and correct an error in our model draft legislation. As far as I am aware, this is the first time that answer set programming has been used to model legislative rules in the published literature.</p><h4>2021: <a href="https://talk.rulesascode.com/">talk.RulesAsCode.com</a> released</h4><p>My company Lexpedite Legal Technology teamed up with Jameson Dempsey of Legal Hackers and Stanford CodeX fame, to create an online community for discussing Rules as Code, at talk.RulesAsCode.com. It has made my life better as a person doing Rules as Code. If you are working in the space, please join!</p><h4>2021: <a href="https://medium.com/computational-law-diary/explainable-openfisca-4c718d0fdc58">OpenFisca for Expert Systems</a></h4><p>As part of my work inside Service Canada, I needed to build a proof of concept showing that OpenFisca, which is a rules as code tool aimed at microsimulation, could be used to power a user-facing application built on the same encoding of legislation.</p><p>The resulting prototype demonstrates that OpenFisca can be used to generate explanations for its conclusions, can be used to determine what additional questions might be relevant, and can be used to determine when questions will remain only contingently answered.</p><h3>Take-Aways</h3><p>It seems like a productive 18 months. What I’m most pleased with is that we now have open source, free, public demonstrations of a number of things that did not exist 18 months ago:</p><ul><li>A user-friendly interface to declarative logic programming for Rules as Code, with code that can be run over Web API.</li><li>Communications targeted at legislative drafters explaining what Rules as Code is, and why they should care.</li><li>In-depth research available to public servants on the state of Rules as Code as of 2020.</li><li>Open Source, explainable declarative logic languages with strong ecosystems, capable of everything that the best commercial tools in this space can do, and more.</li><li>Demonstrations of how those tools can be used to simplify user-facing application development.</li><li>Peer-reviewed publication showing how those tools can be used to improve legislative drafting.</li><li>A place for the international Rules as Code community to have conversations that persist, and to share resources, that can be used to get new members of the community up to speed faster.</li><li>A demonstration of how the world’s most popular rules as code tool can be used to facilitate both microsimulation and prototyping user-facing applications.</li></ul><h3>What I’m Looking Forward To In 2022</h3><p>There are a lot of assumptions that we are still operating under in the Rules as Code space, and I’m looking forward to having the opportunity to throw some real world evidence at those assumptions and see what sticks. Is declarative code easier to write and read and update than procedural code? Can declarative code do causal reasoning, temporal logic, math, defeasibility, scoping, and explanations all at the same time? We should be able to find out.</p><p>I’m also looking forward to the first ever Programming Languages and the Law workshop in January, the Computational Legal Studies Conference in March, deploying Canada’s first public facing rules as code powered tool in the spring, and finally getting the opportunity to experiment with the Catala programming language. In a perfect scenario, I would also have some time to spend writing and releasing a massively revised version of Blawx.</p><p>Perhaps most of all, I’m looking forward to all of the things I’m going to learn from having the experience of encoding legislation for people who have specific and varied things they need to do with that code. There is just no way to theorize your way through that kind of learning, and it has been extremely valuable.</p><h3>Thanks</h3><p>Thanks to the people at SMU Centre for Computational Law, and the people at Digital Experience and Client Data who have been so supportive of not only my work, but my desire to write, present, and make videos about it, for the last 18 months.</p><p>And thank you for your interest, for reading, for your feedback, and for sharing my musings, here. Here’s to more of the same in 2022, but with less epidemic.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=51b66f3253b4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/computational-law-diary/computational-law-diary-2020-2021-in-review-51b66f3253b4">Rules as Code Diary 2020–2021 in Review</a> was originally published in <a href="https://medium.com/computational-law-diary">Rules as Code Diary</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Explainable OpenFisca]]></title>
            <link>https://medium.com/computational-law-diary/explainable-openfisca-4c718d0fdc58?source=rss-a0ffc78977a0------2</link>
            <guid isPermaLink="false">https://medium.com/p/4c718d0fdc58</guid>
            <category><![CDATA[openfisca]]></category>
            <category><![CDATA[legaltech]]></category>
            <category><![CDATA[rules-as-code]]></category>
            <dc:creator><![CDATA[Jason Morris]]></dc:creator>
            <pubDate>Thu, 16 Dec 2021 09:35:02 GMT</pubDate>
            <atom:updated>2021-12-16T22:13:58.141Z</atom:updated>
            <content:encoded><![CDATA[<p>Following up on <a href="https://medium.com/computational-law-diary/using-openfisca-as-an-expert-system-engine-e291ddc50815">the plan</a> I wrote about a few days ago… By exposing all of the intermediate conclusions, and by adding separate variables that represent whether the primary variables are “known,” I’ve managed to create an encoding in OpenFisca that is capable of doing some cool stuff over the Web API.</p><p>You can see the source code in <a href="https://github.com/JasonMorrisSC/openfisca-canada/tree/stub_version">this GitHub repository</a>, and the demos/explanations.py file demonstrates the use of the OpenFisca Web API with my rules as code encoding in Python.</p><p>You can also try it in <a href="https://colab.research.google.com/drive/1ievnP8CAgfWBqKQI2XXRz2ZqeWTWu7VL?usp=sharing">this Google Colab notebook</a>.</p><h4>Explanations</h4><p>First, you can hit the /trace endpoint of the Web API, and query both the answer, and whether the answer is known, in one go. By combining the regular and “known” variables and their dependencies into a single dependency tree, we can generate a textual explanation for how OpenFisca reached its conclusions.</p><p>For one of the two example scenarios, the output looks like this:</p><pre>oas_eligible as of 2021-12-01 is unknown, because<br>  oas_eligible_income_requirement_satisfied as of 2021-12-01 is unknown, because<br>    oas_eligible__income_not_above_limit as of 2021-12-01 is unknown, because<br>      income as of 2021 is unknown, and<br>  oas_eligible_age_requirement_satisfied as of 2021-12-01 is True, because<br>    oas_eligible__age_above_eligibility as of 2021-12-01 is True, because<br>      age as of 2021-12-01 is 65, and<br>  oas_eligible_legal_status_satisfied as of 2021-12-01 is unknown, because<br>    oas_eligible_legal_status__qualifies as of 2021-12-01 is unknown, because<br>      legal_status as of 2021-12-01 is unknown, and<br>  oas_eligible_required_residency_duration_satisfied as of 2021-12-01 is unknown, because<br>    years_in_canada_since_18 as of 2021-12-01 is unknown, and<br>    oas_eligible_required_residency_duration_amount as of 2021-12-01 is unknown, because<br>      place_of_residence as of 2021-12-01 is unknown, and<br>  oas_eligible_residency_requirement_satisfied as of 2021-12-01 is unknown, because<br>    oas_eligible_canadian_residency_requirement_satisfied as of 2021-12-01 is unknown, because<br>      place_of_residence as of 2021-12-01 is unknown, and<br>    oas_eligible_foreign_residency_requirement_satisfied as of 2021-12-01 is unknown, because<br>      resides_in_agreement_country as of 2021-12-01 is unknown, because<br>        place_of_residence as of 2021-12-01 is unknown, and<br>      eligible_under_social_agreement as of 2021-12-01 is unknown</pre><p>That’s not as readable as you would want to make it before you displayed it to a user, but the point is that all the relevant information is there, and your interface can do with it as you please.</p><h4>Relevance</h4><p>By looking for leaf nodes in the justification tree that have only “unknown” parents, we are able to come up with the list of relevant questions to ask the user. For the same example, the demonstration generates the following output for relevance:</p><pre>The remaining relevant inputs are [&#39;place_of_residence&lt;2021-12-01&gt;&#39;, &#39;legal_status&lt;2021-12-01&gt;&#39;, &#39;eligible_under_social_agreement&lt;2021-12-01&gt;&#39;, &#39;years_in_canada_since_18&lt;2021-12-01&gt;&#39;, &#39;income&lt;2021&gt;&#39;]</pre><p>That information can be used to avoid asking the user questions that can no longer possibly impact the question you are trying to answer, which makes the application smarter, with less work for the developers, and in particular without the developers needing to know the logic of the legislation in order to predict when things will matter.</p><h4>Contingent Conclusions</h4><p>Sometimes, the answer depends on things that you aren’t going to ask the user, because the interface would be too complicated, or it’s not reasonable to expect the user to know. If you know the list of questions that can’t be posed to the user, but are considered in the code, and the list of relevant questions is entirely in that category, you can advise the user that the answer is “it depends”, and describe what it depends on, and advise the user what to do next. For another example, the demonstration output looks like this:</p><pre>The remaining relevant inputs are [&#39;eligible_under_social_agreement&lt;2021-12-01&gt;&#39;]<br>There are no askable relevant variables, so this goal is contingently known.</pre><h4>Why it Matters</h4><p>We now have proof that it is possible to generate explainable expert systems on the basis of encodings of legislation done in OpenFisca, and accessed over the standard OpenFisca Web API.</p><p>We also have a much better idea of how difficult it is.</p><p>Next we will satisfy our front-end developers that the OpenFisca Web API is friendly to them. Then work begins on a version of the encoding that is based more directly on the relevant legislation, as opposed to someone’s short-hand interpretation of it.</p><p>That will teach us another important lesson, which is how much more difficult, if at all, is it to do an encoding in OpenFisca that has higher fidelity with the source legislation? By comparing the difficulty of the two approaches, and taking a look at the nature of some of the amendments that have been made to the legislation over time, and examining how those amendments would be made to the code in both versions, we should get some idea of whether the increased effort in encoding is worth it in terms of maintenance and the ability to tie explanations to the source legal material.</p><p>We are also already starting to explore techniques to keep the encoding in sync with legislative changes. The possibility of generating OpenFisca parameter files, <a href="https://github.com/JasonMorrisSC/openfisca-canada/blob/stub_version/openfisca_canada/parameters/benefits/social_agreement_countries.yaml">like this one</a>, by scraping government web pages <a href="https://www.canada.ca/en/revenue-agency/services/tax/businesses/topics/payroll/payroll-deductions-contributions/canada-pension-plan-cpp/foreign-employees-employers/canada-s-social-agreements-other-countries.html">like this one</a>, is on the agenda. As is the possibility of tracking changes to legislation through tools like <a href="https://sso.lexum.com/auth/realms/lexum/protocol/openid-connect/auth?response_type=code&amp;client_id=lexbox-web&amp;redirect_uri=https%3A%2F%2Fapp.mylexbox.com%2Fapi%2Fsso%2Flogin?realm%3Dlexum&amp;state=93e6e22f-adcf-4228-96f7-8c431eae80d3&amp;login=true&amp;scope=openid">LexBox</a>. Perhaps when the law changes, we can create a GitHub issue with a link to the legislative changes on CanLII.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4c718d0fdc58" width="1" height="1" alt=""><hr><p><a href="https://medium.com/computational-law-diary/explainable-openfisca-4c718d0fdc58">Explainable OpenFisca</a> was originally published in <a href="https://medium.com/computational-law-diary">Rules as Code Diary</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Using OpenFisca as an Expert System Engine]]></title>
            <link>https://medium.com/computational-law-diary/using-openfisca-as-an-expert-system-engine-e291ddc50815?source=rss-a0ffc78977a0------2</link>
            <guid isPermaLink="false">https://medium.com/p/e291ddc50815</guid>
            <category><![CDATA[rules-as-code]]></category>
            <category><![CDATA[legaltech]]></category>
            <category><![CDATA[openfisca]]></category>
            <dc:creator><![CDATA[Jason Morris]]></dc:creator>
            <pubDate>Wed, 08 Dec 2021 19:29:44 GMT</pubDate>
            <atom:updated>2021-12-08T19:29:44.580Z</atom:updated>
            <content:encoded><![CDATA[<p>At Service Canada we are working on a new tool to help Canadians to plan for retirement. And we are experimenting with implementing that system using a Rules as Code approach. Specifically, we are looking at implementing the rules in <a href="https://openfisca.org/">OpenFisca</a>.</p><figure><img alt="An abstract image of overlapping, intersecting, branching, diverging, and reconnecting lines." src="https://cdn-images-1.medium.com/max/400/1*n3YitL82H5Wbz1cXJi0ypg.png" /><figcaption>“Uncertainty in Legal Outcomes”, by <a href="https://is.gd/artmachine">AI Art Machine</a>, in the style of <a href="https://www.alexjanvier.com/artist/">Alex Janvier</a></figcaption></figure><p>OpenFisca is a leading Rules as Code solution, but it is primarily aimed at microsimulation. Microsimulation is where you create a data model that represents small elements of a population, like people and households, and then encode the effects of different tax and benefit regimes. You can then load data that is representative of your actual population, and look at the effects on those individuals or groups in aggregate. Or, you can load a smaller number of specific examples and see how those particular fact scenarios are affected by the rules.</p><p>In either case, the expected workflow is that the information is provided at the beginning, and OpenFisca does a calculation, and returns the result.</p><p>An expert system, if you are using the term as it was used in the 80s and 90s, is a system that has a thing that is it trying to figure out, and can figure out what questions to ask based on the rules and the information that has already been provided. That process operates differently. It anticipates that the data will be given to the reasoner one piece at a time, and after each piece of data is given, the reasoner will advise whether it knows the answer to the question, and if not, what other questions are relevance.</p><h3>The Plan</h3><p>In order to give OpenFisca something like that capability, my plan is to give OpenFisca the concept of uncertainty. By default, OpenFisca treats variables that it hasn’t been given as “false-ish”. Booleans will be false, integers will be zero, and strings will be blank, for example. That means that OpenFisca can’t really tell the difference between having been told that an input variable’s true value is zero, and not having been given a value.</p><p>In order to give OpenFisca the concept of uncertainty, I’m going to take the existing list of variables, and duplicate them, creating a separate boolean variable for whether or not the first variable is “known.” For input variables, the user will specify that the variable is known in the data submitted to OpenFisca.</p><p>Then, the user will be able to ask for the result they are interested in, and they will also be able to ask whether that result is known. If they use the /trace endpoint for the OpenFisca server, they will receive data that can be turned into a dependency tree, showing how each part of the calculation depended on other parts.</p><p>Then, if we break out the conclusions of all the logical operations into their own variables, so the conclusion of each “and”, “or”, or comparison becomes its own variable that may or may not be known, the dependency tree for whether or not the conclusion is “known” should have all the information we need to understand what questions are relevant.</p><p>If OpenFisca says that the root of that tree is “known”, then the question has been answered, and there are no more questions that need to be asked. Otherwise, all of the unknown leaf nodes that have only unknown nodes above them in the tree are still potentially relevant.</p><p>The resulting dependency trees will also be sufficient information from which to generate sophisticated user-facing explanations for the conclusions that are reached. I have a suspicion that they will actually contain considerably more information than a typical logical trace will provide, because it should be possible to determine if a conclusion might have been reached in more than one way based on the information provided.</p><h3>Some Caveats</h3><h4>Structural Isomorpshim</h4><p>I’m a big fan of what I call “structural isomorphism.” The smallest possible parts of your encoding should have as close as possible to a one-to-one relationship with the smallest possible parts of the law.</p><p>For this experiment, I’m ignoring structural isomorphism, at least to the extent that the sections of code should be small. This approach requires a lot of code. I don’t think it breaks the one-to-one relationship, but I’ll find that out later and let you know. It certainly breaks the requirement that the pieces of code be as small as possible.</p><h4>Multiple Queries</h4><p>An acknowledged downside of this approach is that in order to get the information about whether the conclusion is known, or not, the user needs to send two queries to the OpenFisca API. One for the answer, and one for whether or not the answer is known. That’s less than elegant. There’s probably a way to solve that problem by having OpenFisca query itself, and then include the results in the response.</p><p>But we’re not there, yet.</p><h4>Post-Processing</h4><p>Another acknowledged downside of this approach is that it requires the client accessing the OpenFisca Web API to do post-processing on the results that it receives from the two queries. It does not simply output a list of variable names that are still relevant. It provides data on which you can run an algorithm, which will reveal that list.</p><h4>Style Dependent</h4><p>Another acknowledged downside of this approach is that it does not work on all OpenFisca code. The code needs to have been written in this particular way for that algorithm to work, and the application developer needs to know that the code has been written that way. That breaks the separation of concerns. The application developer ought not need to know how the code was implemented in order to be able to access the useful information. But that’s a natural result of the fact that uncertainty and explanations are not features of OpenFisca. We’re just trying to use OpenFisca in such a way as to achieve a similar effect.</p><h3>An Example</h3><p>I’ll try to do this up as a Colab Notebook, so you can play along if you’re interested.</p><p>Let’s say we want to encode the rules for eligibility for the Guaranteed Income Supplement in OpenFisca. We might write a variable like this:</p><pre>class gis_eligible(Variable):<br>  value_type = bool<br>  entity = Person<br>  definition_period = DAY<br>  label = &quot;Whether Person is eligible for Guaranteed Income Supplement&quot;</pre><pre>def formula(person, period, parameters):<br>    married = person(&#39;marital_status&#39;,period) == marital_status_options.MARRIED<br>    common_law = person(&#39;marital_status&#39;,period) == marital_status_options.COMMONLAW<br>    partnered = married + common_law<br>    max_single = parameters(period).benefits.old_age_security.guaranteed_income_supplement.maximum_income_single<br>    max_partner = parameters(period).benefits.old_age_security.guaranteed_income_supplement.maximum_income_partnered<br>    max_both = parameters(period).benefits.old_age_security.guaranteed_income_supplement.maximum_income_two_recipients</pre><pre>max_income = where(partnered,max_partner,max_single)<br>    max_income = where(person(&quot;partner_receiving_oas&quot;,period),max_both,max_income)<br>    income_requirement = person(&quot;income&quot;,period.this_year) &lt; max_income<br>    age_requirement = person(&quot;age&quot;,period) &gt;= parameters(period).benefits.old_age_security.eligibility_age</pre><pre>return person(&#39;oas_eligible&#39;,period) * income_requirement * age_requirement</pre><p>In pseudo code, the formula function reads “a person is partnered if they are married or common law. The person’s maximum income depends on if they are sincle, and if their partner is receiving oas. If they are eligible for OAS, and they have less than the maximum income, and are at least as old as required, they are eligible for GIS.”</p><p>If we were to run a trace on how this variable is calculated, we would see a tree that looks like this:</p><pre>gis_eligible:<br>  - marital_status<br>  - partner_receiving_oas<br>  - income<br>  - age<br>  - oas_eligible</pre><p>That would be accurate, but it does not allow us to know whether age is still relevant when oas_eligible is false. That’s the kind of information we want to add to the output.</p><p>So what we are going to do is we are going to break this variable down into sub-variables, so as to get a tree that looks more like this:</p><pre>gis_eligible:<br>  - income_is_eligible:<br>    - income<br>    - gis_eligible_income_max:<br>      - marital_status<br>      - partner_receiving_oas<br>  - age_eligible:<br>    - age<br>  - oas_eligible</pre><p>Now, if eligibility for GIS is not known, but we know that the income is eligible, we also know that we don’t have to ask about any of marital status, partner OAS, or income that have not already been collected. We also have the information required to be able to explain to the user why their maximum income was set at the level it was.</p><p>So where we had just gis_eligible, we now have four variables, encoded like this:</p><pre>class gis_eligible(Variable):<br>  value_type = bool<br>  entity = Person<br>  definition_period = DAY<br>  label = &quot;Whether Person is eligible for Guaranteed Income Supplement&quot;</pre><pre>def formula(person, period, parameters):<br>    return person(&#39;oas_eligible&#39;,period) * person(&#39;gis_eligible_income&#39;,period) * person(&#39;gis_eligible_age&#39;, period)</pre><pre>class gis_eligible_age(Variable):<br>  value_type = bool<br>  entity = Person<br>  definition_period = DAY<br>  label = &quot;Whether the person&#39;s age meets the requirements for Guaranteed Income Supplement&quot;</pre><pre>def formula(person, period, parameters):<br>    return person(&quot;age&quot;,period) &gt;= parameters(period).benefits.old_age_security.eligibility_age</pre><pre>class gis_eligible_income(Variable):<br>  value_type = bool<br>  entity = Person<br>  definition_period = DAY<br>  label = &quot;Whether the person&#39;s income meets the requirements for Guaranteed Income Supplement&quot;</pre><pre>def formula(person, period, parameters):<br>    income_requirement = person(&quot;income&quot;,period.this_year) &lt; person(&quot;gis_eligible_income_max&quot;, period)<br>    return</pre><pre>class gis_eligible_income_max(Variable):<br>  value_type = int<br>  entity = Person<br>  definition_period = DAY<br>  label = &quot;The person&#39;s maximum income for GIS eligibility&quot;</pre><pre>def formula(person, period, parameters):<br>    married = person(&#39;marital_status&#39;,period) == marital_status_options.MARRIED<br>    common_law = person(&#39;marital_status&#39;,period) == marital_status_options.COMMONLAW<br>    partnered = married + common_law<br>    max_single = parameters(period).benefits.old_age_security.guaranteed_income_supplement.maximum_income_single<br>    max_partner = parameters(period).benefits.old_age_security.guaranteed_income_supplement.maximum_income_partnered<br>    max_both = parameters(period).benefits.old_age_security.guaranteed_income_supplement.maximum_income_two_recipients</pre><pre>max_income = where(partnered,max_partner,max_single)<br>    max_income = where(person(&quot;partner_receiving_oas&quot;,period),max_both,max_income)<br>    return max_income</pre><p>That’s a lot more code to generate the exact same answer. But it still isn’t capable of dealing with whether or not the conclusions are known. So now we’re going to create four new variables, with the name {original_variable_name}_known , so that we will be able to relate them to each other. And the formula for each will set out the circumstances in which the value of the variable is certain.</p><p>For example, whether or not the person qualifies for GIS is now a conjunction of three things: they are eligible for oas, they meet the age requirement, and they meet the income requirement. A conjunction is known, whether true or false, if all of its parts are known. But a conjunction is also known to be false if any of its parts are known to be false. So we encode gis_eligible_known as follows:</p><pre>class gis_eligible_known(Variable):<br>  value_type = bool<br>  entity = Person<br>  definition_period = DAY<br>  label = &quot;Whether it is known if the Person is eligible for Guaranteed Income Supplement&quot;</pre><pre>def formula(person, period, parameters):<br>    all_known = person(&#39;oas_eligible_known&#39;,period) * person(&#39;gis_eligible_income_known&#39;, period) * person(&#39;gis_eligible_age_known&#39;, period)<br>    oas_false = person(&#39;oas_eligible_known&#39;,period) * not_(person(&#39;oas_eligible&#39;,period))<br>    income_false = person(&#39;gis_eligible_income_known&#39;, period) * not_(person(&#39;gis_eligible_income&#39;, period))<br>    age_false = person(&#39;gis_eligible_age_known&#39;, period) * person(&#39;gis_eligible_age&#39;, period)<br>    any_false = oas_false + income_false + age_false</pre><p>Now OpenFisca has a way of determining whether or not it knows the answer to GIS eligibility with certainty, and can explain why. But to make it work, we need to create the “known” variables for all of the other intermediate conclusions, and “known” variables for all of the inputs like age and income, too.</p><p>So in this example, the code goes from one variable to eight variables, not counting the increases for the input variables, and all of the math that goes into determining whether or not the person is eligible for OAS.</p><h3>Output</h3><p>If I run the code with an input where I provide only the person’s age, ask about GIS eligibility, and ask whether GIS eligibility is known, here is what the output looks like:</p><pre>  gis_eligible&lt;2021-12-08&gt; &gt;&gt; [ True]<br>    oas_eligible&lt;2021-12-08&gt; &gt;&gt; [ True]<br>    gis_eligible_income&lt;2021-12-08&gt; &gt;&gt; [ True]<br>      income&lt;2021&gt; &gt;&gt; [0]<br>      gis_eligible_income_max&lt;2021-12-08&gt; &gt;&gt; [18216]<br>        gis_eligible_income_max_partnered&lt;2021-12-08&gt; &gt;&gt; [False]<br>          marital_status&lt;2021-12-08&gt; &gt;&gt; [&#39;SINGLE&#39;]<br>          marital_status&lt;2021-12-08&gt; &gt;&gt; [&#39;SINGLE&#39;]<br>        partner_receiving_oas&lt;2021-12-08&gt; &gt;&gt; [False]<br>    gis_eligible_age&lt;2021-12-08&gt; &gt;&gt; [ True]<br>      age&lt;2021-12-08&gt; &gt;&gt; [75]</pre><pre>  gis_eligible_known&lt;2021-12-08&gt; &gt;&gt; [False]<br>    oas_eligible_known&lt;2021-12-08&gt; &gt;&gt; [False]<br>    gis_eligible_income_known&lt;2021-12-08&gt; &gt;&gt; [False]<br>      income_known&lt;2021&gt; &gt;&gt; [False]<br>      gis_eligible_income_max_known&lt;2021-12-08&gt; &gt;&gt; [ True]<br>        gis_eligible_income_max_partnered&lt;2021-12-08&gt; &gt;&gt; [False]<br>        gis_eligible_income_max_partnered_known&lt;2021-12-08&gt; &gt;&gt; [ True]<br>          marital_status_known&lt;2021-12-08&gt; &gt;&gt; [ True]<br>        marital_status_known&lt;2021-12-08&gt; &gt;&gt; [ True]<br>        partner_receiving_oas_known&lt;2021-12-08&gt; &gt;&gt; [False]<br>    gis_eligible_age_known&lt;2021-12-08&gt; &gt;&gt; [ True]<br>      age_known&lt;2021-12-08&gt; &gt;&gt; [ True]<br>    oas_eligible_known&lt;2021-12-08&gt; &gt;&gt; [False]<br>    oas_eligible&lt;2021-12-08&gt; &gt;&gt; [ True]<br>    gis_eligible_income_known&lt;2021-12-08&gt; &gt;&gt; [False]<br>    gis_eligible_income&lt;2021-12-08&gt; &gt;&gt; [ True]<br>    gis_eligible_age_known&lt;2021-12-08&gt; &gt;&gt; [ True]<br>    gis_eligible_age&lt;2021-12-08&gt; &gt;&gt; [ True]</pre><p>As a small aside, the output above is taken from the Python API, not the Web API. You would need to regenerate these trees from the data returned by the /trace endpoint when using the Web API.</p><p>The first tree shows how GIS eligibility was calculated. It shows that it determined that the person qualifies by virtue of being 75 years of age. Because a person’s income is presumed to be zero if not provided, they also qualify under the income requirement. Their maximum income was set to $18,216.</p><p>The second tree shows us the corresponding true/false values for whether or not the conclusions in the top tree are known. So we can check to see if “income_max”, which was set to $18,216, is actually known, and we can see that it is.</p><p>From the top tree we can see that it depends on whether the person is partnered, and whether the person’s partner is receiving OAS. From the bottom tree we can see that we know the person is not partnered, and that we do not know whether their partner is receiving OAS. But because whether their partner is receiving OAS is a dependency only of values in the top tree that are already known, we know it isn’t relevant for asking the question at the bottom of that tree.</p><p>The relevant questions to ask are the ones that are unknown, and are descendent only of unknown things above them in the dependency tree.</p><h3>Take Aways</h3><p>This approach is deeply suboptimal, just because OpenFisca isn’t designed for powering expert systems. That’s not a critique of OpenFisca. A wrench makes a lousy hammer, and that’s not a critique of the design of wrenches.</p><p>But the approach shows that at least some of what you need can be achieved in OpenFisca. But the increase in the amount of boilerplate code you need to write is really high, and I think it’s reasonable to assume that it increases the risk of errors. It is also deeply non-standard, so tools that rely on understanding the implications of OpenFisca’s definition of a parameter and a variable may not be able to use this approach.</p><p>One benefit is that if you don’t need the “known” variables, you can run your calculations without them. So at that point the only thing slowing things down is having divided single variables into multiple variables.</p><p>OpenFisca could be made to support this sort of approach more easily. We could add features for uncertainty of variables, or syntactic sugar for making it easier to build complicated variable trees. You could also add endpoints to the Web API when what you need is the answer and the certainty, and the justification tree all at once, for example. We could also move some of what is currently post-processing into a different end point, and have OpenFisca return the lists of relevant variables, if it integrated this approach more fully.</p><p>I’m not sure any of that is actually worth it, though. It depends on how much effort it would take to get equivalent capabilities out of other approaches, and whether those other approaches might also be able to output something that could be turned into OpenFisca code, or code for some other microsimulation tool.</p><p>Getting microsimulation to work off of encodings of laws is an important objective. It remains to be seen whether that means OpenFisca code should be a starting place, or a destination.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e291ddc50815" width="1" height="1" alt=""><hr><p><a href="https://medium.com/computational-law-diary/using-openfisca-as-an-expert-system-engine-e291ddc50815">Using OpenFisca as an Expert System Engine</a> was originally published in <a href="https://medium.com/computational-law-diary">Rules as Code Diary</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[“Rules as Code” Doesn’t Need Factions]]></title>
            <link>https://medium.com/computational-law-diary/rules-as-code-doesnt-need-factions-20424241c7a0?source=rss-a0ffc78977a0------2</link>
            <guid isPermaLink="false">https://medium.com/p/20424241c7a0</guid>
            <category><![CDATA[rules-as-code]]></category>
            <category><![CDATA[logic-programming]]></category>
            <category><![CDATA[catala]]></category>
            <category><![CDATA[legaltech]]></category>
            <dc:creator><![CDATA[Jason Morris]]></dc:creator>
            <pubDate>Tue, 07 Dec 2021 20:41:46 GMT</pubDate>
            <atom:updated>2021-12-07T22:54:30.565Z</atom:updated>
            <content:encoded><![CDATA[<h4>Responding to Catala Paper’s Criticisms of Logic Programming</h4><p>Last December, Denis Merigoux and Liane Huttner presented a paper at the Algorithmic Law Symposium hosted at HEC Paris, on “<a href="https://hal.archives-ouvertes.fr/hal-02936606/">Catala: Moving Towards the Future of Legal Expert Systems</a>”. I’ve been meaning to take a look for some time, and finally managed it today.</p><p>[Edit: Denis Merigoux notes in the replies that the version of the paper I viewed was a pre-print before the authors had received the reviewer’s comments, which were only recently received, and some of which are echoed here. Revisions are anticipated shortly. This post should be read in the context that it critiques a work in progress.]</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*Ce1g4hVewq0l--IkOaFXXg.png" /><figcaption>Catala vs Prolog, by <a href="https://is.gd/artmachine">AI Art Machine</a></figcaption></figure><p>In the main the article is good. It sets out some real problems with how taxes and benefits are automated in government systems elsewhere, and suggests how <a href="http://catala-lang.org/">Catala</a>, combined with literate- and pair-programming might serve to ameliorate those problems.</p><p>But the paper seems to take the position that Catala needs to be framed as “better than declarative logic programming.” And then the efforts to do that are all frustratingly flawed.</p><h4>So-called “Rules Engines”</h4><p>The paper distinguishes Catala from “so-called ‘rules engine’”, citing Flora-2 and Prolog as examples. The paper asserts that these rules engines are based on logic programming, interpreted, slow, and therefore ineffectual for calculating large numbers of taxes or benefits in a real-world application.</p><p>Catala, on the other hand, can be compiled to any other language, allowing Catala code to be implemented inside other legacy systems, and for it to be implemented in ways that are computationally efficient.</p><p>So the first problem here is that there is a difference between a “rules engine”, and a declarative logic programming language. Flora-2 and other members of the Prolog family of languages are examples of the latter. “Rules engine” is any piece of software that allows you to specify rules, and process data in accordance with them, and that typically exists outside of the rest of your application. So that includes applications like Oracle Intelligent Advisor, and production rule systems like Drools, which are categorically different things. You could use Flora-2 as a rules engine, and that would <a href="https://blawx.com/">not be a bad idea</a>. But the features of “rules engines” are not the features of declarative logic programming languages. You could write your entire application in declarative logic programming.</p><p>The second problem here is that it is not true that logic programming languages are interpreted. Prolog can be interpreted or compiled, and can be very efficient. And modern software approaches to speed generally involve crossing boundaries between languages anyway. People use numpy in Python to do large mathematical calculations, but in the background numpy is implemented in code that was written in a more efficient language like C. You can do the same thing in declarative logic programming, and people do.</p><p>The third problem is that Catala has no exclusive claim to being capable of compiling to multiple other languages. If you wanted to take a knowledge representation written in a declarative logic programming language, and use that encoding to generate FORTRAN or COBOL, you could.</p><p>The fourth problem is that the paper claims that Catala provides explainability because of the one-to-one relationship between code and law. Based on my understanding of default logic, which Catala implements, and the other forms of defeasibility I have dealt with in declarative logic programming languages, like “logic programming with defaults and argumentation theories”, I think declarative logic approaches have a stronger claim to 1-to-1 correspondence than Catala. I suspect that is not a strength compared to logic programming, but a weakness.</p><p>And explainability is easier to get from declarative logic approaches, because while functions are unidirectional (from inputs to outputs), implications are bidirectional. So in declarative logic programming the same code can explain why something is true, and why it isn’t. Catala, as a functional language, can only explain the answers it found, not the answers it didn’t. And because it’s explanations are a trace, it can only provide an explanation that reflects the method that it used to reach that conclusion, as opposed to all the other ways the same conclusion might have been reached under the rules.</p><h4>We Are All on the Same Side</h4><p>Catala brings a combination of two things that haven’t existed together before. First, it is a domain-specific language for encoding quantitative statutes. That’s important, because it makes it easier for the programmer to encode those sorts of laws, than if they tried to do it in OCaml, for example. Easier is better.</p><p>Second, the programming language has features to prevent you from making certain kinds of mistakes (typing errors), and has the capacity to allow you to detect other kinds of consistency errors. So if what you want to do is write software for calculating taxes and benefits, and know that the calculations are not wrong in certain ways, Catala brings strengths to the table that aren’t available elsewhere.</p><p>That’s a good thing.</p><p>But all of the available approaches have strengths and weaknesses. Raw Python has the advantage of a huge pool of expertise to draw from. OpenFisca has the advantage of being designed specifically to process large number of queries simultaneously, while allowing you to write code in Python. Flora-2 has higher order logic programming, advanced defeasibility, meta-programming, all of which let you do interesting things. SWI-Prolog and s(CASP) give you access to constraints over infinite domains like time, goal-directed answer sets, natural language explanations, and the ability to answer questions that every other approach would loop infinitely on.</p><p>If we pit them against each other for no reason — and there is no reason — we risk leaving the Rules as Code community impoverished as a result.</p><p>I’m hoping that the <a href="https://popl22.sigplan.org/home/prolala-2022">ProLaLa conference in January</a> can help us build a community of advocates for and practitioners of and researchers in computational law that sees no need for factionalism.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=20424241c7a0" width="1" height="1" alt=""><hr><p><a href="https://medium.com/computational-law-diary/rules-as-code-doesnt-need-factions-20424241c7a0">“Rules as Code” Doesn’t Need Factions</a> was originally published in <a href="https://medium.com/computational-law-diary">Rules as Code Diary</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Isolating the Legal Logic]]></title>
            <link>https://medium.com/computational-law-diary/isolating-the-legal-logic-dd3f2fa05b8?source=rss-a0ffc78977a0------2</link>
            <guid isPermaLink="false">https://medium.com/p/dd3f2fa05b8</guid>
            <category><![CDATA[civictech]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[legaltech]]></category>
            <category><![CDATA[rules-as-code]]></category>
            <dc:creator><![CDATA[Jason Morris]]></dc:creator>
            <pubDate>Wed, 01 Dec 2021 18:56:07 GMT</pubDate>
            <atom:updated>2021-12-01T18:56:07.801Z</atom:updated>
            <content:encoded><![CDATA[<p>Just had a great conversation with a colleague that helped me understand a challenges involved in implementing Rules as Code that hadn’t occured to me before.</p><p>The objective in Rules as Code is to write an encoding of the legislation that is as re-usable as possible. That means avoiding the temptation to put things into the encoding of the rules that only make sense to include in the context of a particular application.</p><p>What I didn’t realize, until I chatted with my colleague today, is that only gets you reusability, not maintainability. In order to get the benefit of maintainability, you <em>also</em> need to avoid the temptation of implementing legal logic in the application.</p><p>The example today was something to the effect of “I already know what the answer to that query is going to be, so I’ll just skip it to run faster.”</p><p>That might be justifiable in certain scenarios where performance is critical, and the legislation is very unlikely to change in any meaningful way. But generally speaking, it’s a “Rules as Code Smell.”</p><p>You shouldn’t have to know anything about the law in order to write an app. If you do know something about the law, you might be able to make your app faster using that knowledge, but you probably shouldn’t. Because you also shouldn’t have to know anything about the law in order to maintain an app that was written 30 years ago. The likelihood that the next developer to maintain the app knows that you encoded your legal knowledge, has the same knowledge, and/or understands whether your knowledge is still true now that the law has changed, has got to be approaching zero.</p><p>If you want re-usability, don’t put application stuff into the encoding of the law. If you want maintainability, don’t put law stuff into the encoding of the application. Both sides need to play nice to get all the benefits.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dd3f2fa05b8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/computational-law-diary/isolating-the-legal-logic-dd3f2fa05b8">Isolating the Legal Logic</a> was originally published in <a href="https://medium.com/computational-law-diary">Rules as Code Diary</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[OpenFisca in Google Colab]]></title>
            <link>https://medium.com/computational-law-diary/openfisca-in-google-colab-de92e2621d88?source=rss-a0ffc78977a0------2</link>
            <guid isPermaLink="false">https://medium.com/p/de92e2621d88</guid>
            <category><![CDATA[rules-as-code]]></category>
            <category><![CDATA[openfisca]]></category>
            <category><![CDATA[google-colab]]></category>
            <category><![CDATA[legaltech]]></category>
            <dc:creator><![CDATA[Jason Morris]]></dc:creator>
            <pubDate>Tue, 30 Nov 2021 17:43:04 GMT</pubDate>
            <atom:updated>2021-11-30T17:43:04.402Z</atom:updated>
            <content:encoded><![CDATA[<p>I blogged recently about the opportunity to <a href="https://medium.com/computational-law-diary/s-casp-swi-prolog-ccf8e53c951a">use s(CASP) inside SWISH</a>, the web-based development environment for SWI-Prolog.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8aKzhnDy6oE0omexcsIeMw.png" /><figcaption>Screenshot of a Google Colab notebook implementing OpenFisca code to calculate eligibility for a benefit</figcaption></figure><p>Today it is another web-based development environment for Rules as Code, <a href="https://openfisca.org/en/">OpenFisca</a> inside <a href="https://colab.research.google.com/">Google Colab</a>.</p><h4>What is OpenFisca?</h4><p><a href="https://openfisca.org/en/">OpenFisca</a> is probably the world’s most popular open source tool for Rules as Code. It is used extensively in France, and is spreading around the world.</p><h4>What is Google Colab(oratory)?</h4><p><a href="https://colab.research.google.com/">Google Colab</a> is a web-based implementation of Jupyter notebooks — a “literate programming” tool for the Python programming language — and Google’s cloud services. A Python development environment as a (free) service.</p><h4>Less Memo, More Memo</h4><p>I could explain how it works, here, but nah.</p><p>Just <a href="https://colab.research.google.com/drive/1A-L2GwDPHJkH8H4wZUwedD7-hcKXm5WZ?usp=sharing">go try it yourself</a>.</p><p>Trust me, you won’t regret the click.</p><h4>Upshot</h4><p>I <em>really</em> like the result, because it provides a good literate programming environment to do encoding beside the text of legislation, in any approach that is implemented in Python.</p><p>It also democratizes access to OpenFisca, eliminating the need to know how to set up a development environment, or even the need for a computer on which Python can be installed. Interestingly, that makes it realistic for a wider variety of public servants to be able to explore, which in turn will make the technology more trustworthy, and more trusted.</p><p>OpenFisca is not my favourite approach for Rules as Code. Imperative programming is fundamentally limited for encoding rules, and OpenFisca’s design is focused on the quality of the outputs — high speed, high accuracy micro-simulations of the effects of legislation — not on the qualities of the inputs. But those concerns are academic, like preferring emacs to Word. OpenFisca is popular, open source, and feasible to deploy in places many of my preferred approaches are not. It also has a growing ecosystem of tools and extensions, as demonstrated at <a href="https://policyengine.org/">PolicyEngine.org</a>.</p><p>Democratizing access to OpenFisca can only help the Rules as Code movement, and I am 100% here for that.</p><p>Adding Colab to the mix, in addition to democratizing access, gives OpenFisca a lot of great interface features. And with very little overhead for the developer. That means the distance between being able to encode a Law, and being able to demonstrate the usefulness of that encoding, has been reduced to nearly zero. And zero is where it should ideally be.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=de92e2621d88" width="1" height="1" alt=""><hr><p><a href="https://medium.com/computational-law-diary/openfisca-in-google-colab-de92e2621d88">OpenFisca in Google Colab</a> was originally published in <a href="https://medium.com/computational-law-diary">Rules as Code Diary</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[talk.RulesAsCode.com — A Community Forum]]></title>
            <link>https://medium.com/computational-law-diary/talk-rulesascode-com-a-community-forum-a16fe2140a51?source=rss-a0ffc78977a0------2</link>
            <guid isPermaLink="false">https://medium.com/p/a16fe2140a51</guid>
            <category><![CDATA[legaltech]]></category>
            <category><![CDATA[rules-as-code]]></category>
            <category><![CDATA[computational-law]]></category>
            <dc:creator><![CDATA[Jason Morris]]></dc:creator>
            <pubDate>Fri, 19 Nov 2021 17:49:48 GMT</pubDate>
            <atom:updated>2021-11-19T17:49:48.292Z</atom:updated>
            <content:encoded><![CDATA[<h3>talk.RulesAsCode.com — A Community Forum</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a6PYI7IbPCWQcqFu-cSVqg.png" /><figcaption>A screen capture of the front page of talk.RulesAsCode.com as of November 19, 2021</figcaption></figure><p>Rules as Code is a movement in public administration that suggests that the digitization of legislation, regulation, and other rules should happen as early in their life cycle as possible, so as to improve policy design, improve legislative drafting, and massively simplify service automation and building software systems compliant with those rules.</p><p>It is an international movement, and it is an interdisciplinary movement. It impacts on people inside government, legislatures, regulatory bodies, regulated entities, academia, as well as technologists, lawyers, and more.</p><p>That is a big category of people who don’t frequently bump into each other in hallways. <a href="https://www.twitter.com/jamesondempsey">Jameson Dempsey of Legal Hackers</a> recognized a need for a global meeting place for people who are learning about, teaching about, or working in the Rules as Code space. So Jameson and I have worked over the last couple of months to set up <a href="https://talk.rulesascode.com/">talk.RulesAsCode.com</a>, a community forum for Rules as Code.</p><p>As of yesterday, we launched it to the public.</p><p>It currently features a “Forum” for general discussion, a “News and Events” category for things that become less useful as time passes, as well as a “Knowledge Base” for things that don’t, with categories for software, examples, and publications.</p><p>If you are interested in improving the world by digitizing its rules, please head over to <a href="https://talk.rulesascode.com/">talk.RulesAsCode.com</a> and click “Sign Up” in the top right to create an account. That will allow you to set up an email digest, sent as frequently or infrequently as you like, with details on the recent conversations and additions to the Knowledge Base.</p><p>Please share this post with people in your network who may be interested, and thank you in advance for your contributions.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a16fe2140a51" width="1" height="1" alt=""><hr><p><a href="https://medium.com/computational-law-diary/talk-rulesascode-com-a-community-forum-a16fe2140a51">talk.RulesAsCode.com — A Community Forum</a> was originally published in <a href="https://medium.com/computational-law-diary">Rules as Code Diary</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Scoping for Defeasibility in Flora-2]]></title>
            <link>https://medium.com/computational-law-diary/scoping-for-defeasibility-in-flora-2-36b046e30463?source=rss-a0ffc78977a0------2</link>
            <guid isPermaLink="false">https://medium.com/p/36b046e30463</guid>
            <category><![CDATA[rules-as-code]]></category>
            <category><![CDATA[legaltech]]></category>
            <dc:creator><![CDATA[Jason Morris]]></dc:creator>
            <pubDate>Thu, 18 Nov 2021 22:15:42 GMT</pubDate>
            <atom:updated>2021-11-18T22:15:42.066Z</atom:updated>
            <content:encoded><![CDATA[<p>In <a href="https://roundtablelaw.medium.com/what-one-section-of-law-tells-us-about-what-rules-as-code-needs-a69a77784311">yesterday’s post</a>, I talked a little about how it would be nice if there was a way to use legislative scope to refer to sections of law, particularly to implement, in a structurally-isomorphic way, defeasibility statements like “subject to this act and the regulations.”</p><p>Today I’m going to share a small experiment I did in Flora-2 to see if I can demonstrate a working approach. I’d be interested in your thoughts.</p><p>Remember that the objective of structural isomorphism is to have the smallest possible sections of code that correspond to the smallest possible sections of law, in a one-to-one relationship. Scoping is possible, defeasibility is possible. I’m specifically trying to find a way of doing scoping for defeasibility without damaging structural isomorphism.</p><h3>Our Law</h3><p>Let’s pretend that we are dealing with the OAS Act, but that there are only two provisions we are interested in. Section 1 of the Act says “subject to this Act and the regulations, birds fly.” But there is a Regulation 1 under the OAS Act, rule1 of which reads “penguins do not fly.”</p><h3>The Library</h3><p>I won’t share the code for the Flora-2 library I wrote, but suffice it to say it sets out a “LegalDoc” type, which includes “DocPart” elements, each of which has a parent element. LegalDocs also have a document type, and superior documents if they are subordinate to another document.</p><p>Using this library means that as you are encoding each section of the law, you document the new section as a “DocPart.” Then you use Flora-2 “tags” to associate that documentation with your rules. Then you can use the same names for those sections in your defeasibility statements.</p><p>If you’re playing with Flora-2 and would like to see how I implemented the LegalDoc type, let me know, I’ll be happy to share.</p><h3>Act, Section 1</h3><p>Here’s how you would implement “Subject to this act and the regulations, birds fly.”</p><pre>oas_1:DocPart[parent-&gt;oas_p1,description-&gt;&quot;section 1&quot;^^\string].</pre><pre>@{oas_1}<br>flies(?X) :- bird(?X).<br>\overrides(?other_section,oas_1) :-<br>  oas[descendent-&gt;?other_section[substantive-&gt;\true]];<br>  oas[subordinate-&gt;?_reg[legaldoc_type-&gt;regulation,descendent-&gt;?other_section[substantive-&gt;\true]]].</pre><p>The first line says “OAS Section 1 is a DocPart, whose parent is OAS Part I.”</p><p>The second line tags the following rule with the name of OAS Section 1.</p><p>The next line is the rule “birds fly.”</p><p>The next three lines encode “subject to this act and the regulations.” The first line says that the conclusion of Section 1 of the OAS can be overridden by another section. The next two lines set out two circumstances in which that is true. The first condition is when the section is a substantive part of the OAS Act. The second condition is when the section is a substantive part of a regulation that is subordinate to the OAS Act.</p><h3>Regulation Rule 1</h3><p>Now we want to implement rule 1 of the regulation, which says only “Penguins do not fly”, without reference to which rules that might override.</p><p>Here’s how we might do that.</p><pre>reg1_1:DocPart[parent-&gt;reg1,description-&gt;&quot;rule 1&quot;^^\string].</pre><pre>@{reg1_1}<br>\neg flies(?X) :- penguin(?X).</pre><p>Again, the first line defines rule 1 of the regulation as being a child of the regulation itself. The second line tags the following rule as coming from that section of the law. The third line is the encoding of “penguins do not fly.”</p><h3>Maintaining Structural Isomorphism</h3><p>You can see that this approach, of having documentation of the structure of the legal document, attaching elements of that structure to the individual rules, and then using the structure in order to specify which rules defeat which other rules, requires a little more work, but it allows you to faithfully implement statements like “subject to this act and the regulations” in a way that maintains the one-to-one relationship between the code and the law.</p><h3>Running the Code</h3><p>If we create a fact scenario like this:</p><pre>bird(tweety).<br>penguin(tweety).</pre><p>We can then ask the question “does tweety fly” like this:</p><pre>?- flies(tweety).</pre><p>And Flora-2 correctly answers “no”. Rule 1 of the Regulation says “no”, Section 1 of the act says “yes”, and Section 1 of the Act is defeated by Rule 1 of the regulation, so “no” wins.</p><h3>Other Uses for the LegalDoc Data Structure</h3><p>You may have noticed that our encoding of the structure of the act included information about the description of each DocPart. This is done to demonstrate how the structure can be used for other benefits. For example, let’s say that you want to use the tags associated with a rule in order to help explain your answer. It would be useful to be able to have Flora-2 generate natural language descriptions for each section in a way that is consistent with the structure of the act. So I implemented a property of DocPart called “full_description”, which if you query combines the descriptions of the DocPart and all of its parents to generate a useful description of where that section of law is located.</p><p>For example:</p><pre>oas_1_b_i:DocPart[parent-&gt;oas_1_b,description-&gt;&quot;paragraph (i)&quot;^^\string].<br>?- oas_1_b_i[full_description-&gt;?X].</pre><p>Will return:</p><pre>?X = &quot;Old Age Security Act, section 1, subsection (b), paragraph (i)&quot;^^\string</pre><p>You may notice that the description excludes “Part I” of the OAS Act, which is the direct parent of section 1. While Parts are part of the legislative structure, they are not typically used to pinpoint legal text. So oas_p1 exists as a part of the structure of the law, and you can use it to encode statements like “subject to the provisions of Part I”, but the code knows to exclude it from the description of a paragraph.</p><p>The data structure could likewise be extended with the actual text of the relevant section, whether the text of the section should be displayed as a continuation of the text of the parent section, a link to the source legislation, and other things that could be used to generate and improve natural language explanations for the conclusions of the rule.</p><h3>Thoughts</h3><p>Flora-2’s defeasibility method is impressive, and easily extended in this way to be able to implement scopes. The only things on the list of features from <a href="https://roundtablelaw.medium.com/what-one-section-of-law-tells-us-about-what-rules-as-code-needs-a69a77784311">my last post</a> that Flora-2 cannot do are some forms of date arithmetic, and hypothetical reasoning. Hypothetical reasoning might be possible to achieve, but date arithmetic has been intentionally removed from Flora-2 in order to nerf it in favour of its commercial cousin, ErgoAI. That is unfortunate, because the inability to subtract dates from one another to get a duration is probably fatal to the viability of Flora-2 in Rules as Code. And the closed source nature of ErgoAI, which adds explanations, and a wide array of libraries, is probably also fatal.</p><p>There is also a strong parallel between the kinds of information that are kept in the LegalDoc structure, and the kinds of information that are kept in XML Schemas like LegalDocML. In the future, it would be advantageous to be able to simply import the knowledge contained in a LegalDocML file, and then use the names of the elements in that document as the tags for your rules. Particularly if you live in a jurisdiction where LegalDocML is the format used, by default, to mark up legislation and regulations. Unfortunately, I don’t live in such a jurisdiction.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=36b046e30463" width="1" height="1" alt=""><hr><p><a href="https://medium.com/computational-law-diary/scoping-for-defeasibility-in-flora-2-36b046e30463">Scoping for Defeasibility in Flora-2</a> was originally published in <a href="https://medium.com/computational-law-diary">Rules as Code Diary</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What One Section of Law Tells us about what Rules as Code Needs]]></title>
            <link>https://medium.com/computational-law-diary/what-one-section-of-law-tells-us-about-what-rules-as-code-needs-a69a77784311?source=rss-a0ffc78977a0------2</link>
            <guid isPermaLink="false">https://medium.com/p/a69a77784311</guid>
            <category><![CDATA[rules-as-code]]></category>
            <category><![CDATA[legaltech]]></category>
            <category><![CDATA[canada]]></category>
            <dc:creator><![CDATA[Jason Morris]]></dc:creator>
            <pubDate>Wed, 17 Nov 2021 20:38:33 GMT</pubDate>
            <atom:updated>2021-11-17T20:38:33.090Z</atom:updated>
            <content:encoded><![CDATA[<p>I’m currently working within Service Canada’s Benefits Delivery Modernization Program, and I’m working with a team that is looking to automate calculations under the Old Age Security Act.</p><p>I have been looking at various approaches for encoding the relevant sections of the Act, and over the last couple of days I’ve been struck by what a good example section 3(1) of the OAS Act is of the kinds of features that we need in Rules as Code technologies.</p><h3>Section 3(1), OAS Act</h3><p><a href="https://www.canlii.org/en/ca/laws/stat/rsc-1985-c-o-9/latest/rsc-1985-c-o-9.html#sec3subsec1">Section 3(1) of the OAS Act</a> reads as follows:</p><blockquote><strong>3</strong> <strong>(1)</strong> Subject to this Act and the regulations, a full monthly pension may be paid to</blockquote><blockquote><strong>(a)</strong> every person who was a pensioner on July 1, 1977;</blockquote><blockquote><strong>(b)</strong> every person who</blockquote><blockquote><strong>(i)</strong> on July 1, 1977 was not a pensioner but had attained twenty-five years of age and resided in Canada or, if that person did not reside in Canada, had resided in Canada for any period after attaining eighteen years of age or possessed a valid immigration visa,</blockquote><blockquote><strong>(ii)</strong> has attained sixty-five years of age, and</blockquote><blockquote><strong>(iii)</strong> has resided in Canada for the ten years immediately preceding the day on which that person’s application is approved or, if that person has not so resided, has, after attaining eighteen years of age, been present in Canada prior to those ten years for an aggregate period at least equal to three times the aggregate periods of absence from Canada during those ten years, and has resided in Canada for at least one year immediately preceding the day on which that person’s application is approved; and</blockquote><blockquote><strong>(c)</strong> every person who</blockquote><blockquote><strong>(i)</strong> was not a pensioner on July 1, 1977,</blockquote><blockquote><strong>(ii)</strong> has attained sixty-five years of age, and</blockquote><blockquote><strong>(iii)</strong> has resided in Canada after attaining eighteen years of age and prior to the day on which that person’s application is approved for an aggregate period of at least forty years.</blockquote><p>Here are some portions of the text and the challenges they create for Rules as Code tools.</p><h3>“Subject to this Act and the regulations”</h3><p>Yeah, we’re starting right at the very beginning. And this section of text actually creates two different problems.</p><h4>“Subject to” : Defeasibility</h4><p>The first problem is that I want to be able to say, inside the encoding for section 3(1), that section 3(1) is a default— that if there is another rule that concludes to the contrary, the other rule wins.</p><p>Most systems do not provide a simple way of encoding that <em>inside the code that represents section 3(1)</em>. Most require you to go elsewhere. A great tool for Rules as Code would allow me to say this inside (or at least alongside) the encoding for section 3(1), to maintain a 1:1 relationship between small sections of law and small sections of code.</p><h4>“this Act and the regulations” : Scope</h4><p>Even the tools that I’m aware of that have features for defeasibility, and those tools where I have implemented defeasibility features on my own, I’m not aware of any tool that allows me to describe which rules defeat which other rules at a level of abstraction higher than the specific rule itself.</p><p>You could argue that “this Act and the regulations” is pretty darned close to “anything”, and probably doesn’t need to be specified. But even if that was good enough (and for a lot of purposes it wouldn’t be), legislation regularly does things like day “for the purposes of Part 3”, or “subject to Division II”.</p><p>A great Rules as Code tool would allow me to refer to specific rules, or groups of rules, in a way that respects the structure of the original legislation. This is one of the places where I feel that tools like Akoma Ntoso have something to add to the Rules as Code toolkit.</p><h3>“every person who was a pensioner on July 1, 1977”</h3><p>Any time that you see the phrase “on {date}” in legislation, you are dealing with a variable that changes over time, called a “fluent”. My birthdate doesn’t change, no matter how long I am alive. But my age does. Age is an example of a fluent.</p><p>Some Rules as Code tools out there do a really good job of making it straightforward to represent fluents. OpenFisca takes the approach of simply forcing all variables to be represented as fluents. That works, generally, but can cause some overhead. Oracle Intelligent Advisor creates a fluent whenever you explicitly calculate one based on a series of values and times. Then, if you calculate anything else using the value of that fluent, the things which depend on it become fluents automatically, too.</p><p>Those methods work by calculating a list of values, and the corresponding dates at which those values began to be true. There are other approaches, such as event calculus, which can be used in tools like LPS.</p><p>Whatever tool it is, you frequently need to be able to express how the rules change the state of the world over time, and check to see what the state of the world was as of a particular date. A great Rules as Code tool would make that easy.</p><h3>“not a pensioner”</h3><p>Negation is extremely complicated. When you say “not a pensioner”, does that mean “there are no facts in the system from which it is known or derivable that the person was a pensioner?” Or, does it mean “we know or can derive that the person was categorically not a pensioner?”</p><p>Being able to express those two different meanings of “not”, and being able to reason about their combinations and implications, is something that a great Rules as Code tool needs to be able to do.</p><h3>“or” (and “and” and “but”)</h3><p>The rule sets out non-exclusive disjunctive alternatives, where “at least one” needs to be satisfied. Most Rules as Code tools are able to give you a clear way to express “at least one” disjunction. Some also give you a way to specify mutually exclusive disjunction, where “only one” is true. All of them give you the ability to express conjunction, which is sometimes explicit when the legislation uses words like “and” and “but”, but is most often implied in legislative text.</p><h3>“has attained sixty-five years of age”</h3><p>This shouldn’t be surprising, but there are a lot of occasions on which the specific piece of information that a legislative clause expresses is a duration. In this case, “having attained sixty-five years of age” means that the person’s age is greater than or equal to 65. But what is a person’s age? It is is the difference between the relevant date (in this case, “today”), and the person’s birthdate, measured in the units of years. But you could choose a different unit. You could say how old is the person in years and months?</p><p>The ability to easily express and manipulate time periods and durations is critical to being able to encode legislation with things like deadlines. Pieces of legislation will often create their own defined periods like “work week” or “holiday period”. In fact, the very next section of the OAS Act refers to a time period defined in the Act, called a “payment quarter”. A great Rules as Code tool need to be able to facilitate that sort of conversation about time periods.</p><h3>“an aggregate period”</h3><p>In this case, what the legislation is asking is for the sum of all of the relevant time periods. That ability to easily calculate aggreagates (sum, count, average, etc.) is something that a good Rules as Code tool needs to have.</p><h3>“at least equal to”</h3><p>This is a mathematical comparitor, in this case the “greater than or equal to” comparitor, &gt;=. A great Rules as Code tool needs to have the ability to do mathematical comparisons against values.</p><h3>“three times”</h3><p>This is an arithmetic operation, specifically multiplication. A great Rules as Code tool needs to give you the ability to express arithmetic operations against values. Ideally, it would be possible to express them as relationships, rather than as imperative procedures. That way “X * 3 = 15” could be used to find 5, in addition to “5 * 3 = X” being used to find 15. That might require the use of constraint programming, for example.</p><p>In this case, you may be interested in answering the question “does bob qualify?” But you may also be interested in asking “when will bob qualify?” And in order to calculate both answers on the basis of the same rules and the same facts, the arithmetic relationships as expressed need to be reversible.</p><h3>“ten years immediately preceding”</h3><p>Again, we have a duration, but now we also have language that is dealing with a series of periods, and the relationships between them and dates. In this case, the ten year period immediately preceding a date. A great Rules as Code tool needs to understand phrases like “previous month,” and “subsequent work week”.</p><p>There are different ways of doing this. One more advanced approach is Allen Interval Logic, which allows you to express that one period immediately precedes another, without needing to know precisely what the start and end dates of those periods are. Most tools would require you to specify at least two of start date, end date, and duration, and calculate the third for you.</p><h3>“the day on which that person’s application is approved”</h3><p>This statement requires the consideration of counter-factual or hypothetical facts. Section 3 sets out when a person may be paid a full monthly pension. Presumably, you cannot approve the application of a person for whom section 3 does not make paying the pension possible. But the decision of whether they qualify needs to be made in advance of the actual approval. Which means that while section 3 is being considered, there is only a hypothetical “day on which the person’s application is approved.”</p><p>If you ask, without using hypotheticals, whether the person qualifies under section 3 immediately prior to being approved, the answer is at best “unknown”, because there is no date on which the person’s application is approved, so residency for the year prior cannot be calculated. What you need to do is to be able to express the idea “assuming I approved this application now, would the person qualify under section 3?”</p><p>That is a different question, and a great Rules as Code tool would allow you to ask that question in particular.</p><h3>All that in section 3(1)?</h3><p>Just from this one small section of law, we find we need:</p><ul><li>defeasibility,</li><li>scope,</li><li>conjunction,</li><li>disjunction,</li><li>negation,</li><li>durations,</li><li>dates,</li><li>aggregates,</li><li>comparators,</li><li>arithmetic,</li><li>interval relations, and</li><li>hypothetical reasoning</li></ul><p>And there are probably more things I’m leaving out.</p><p>What’s frustrating is I can count on the fingers of zero hands the number of Rules as Code tools I am aware of that make it easy to do all of those things. I can count on the finger of zero hands the number of Rules as Code tools in which this is all currently even possible. Which is frustrating, because I don’t think it needs to be that way.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a69a77784311" width="1" height="1" alt=""><hr><p><a href="https://medium.com/computational-law-diary/what-one-section-of-law-tells-us-about-what-rules-as-code-needs-a69a77784311">What One Section of Law Tells us about what Rules as Code Needs</a> was originally published in <a href="https://medium.com/computational-law-diary">Rules as Code Diary</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>