{"block_close_oss.c33fd1fe9c":"Community and ecosystem","compliance-matrix.7f98f01046":"Certified","compliance-matrix.c584a3644f":"Compliant","compliance-matrix.f61eadaf15":"In Progress","compliance-matrix.9cbe42aaff":"Planned","compliance-matrix.000bdb44ca":"View evidence","core-extras.96d330537a":"Base IR","core-extras.bee831a169":"Substrate","core-extras.61a0822826":"Apps on Core","core-extras.15438cc098":"not supported","core-extras.ad565d9d01":"Feature","core-extras.0155bf03e5":"Segment legend","core-extras.8b7110078e":"Algorithm groups by data type","core-extras.25ab4276a6":"Scrollable capability matrix","open-source-lattice.bacbf2a832":"ONE RECORD","open-source-lattice.f17f7bc1ae":"A decision can draw on a legal condition, a privacy limit, a structural check and a similarity result. Keeping those inputs in one register does not make them equivalent; it keeps their names, versions and evidence visible together.","open-source-lattice.356eb7cbbb":"That lets an operator see which part of the decision was deterministic, which depended on resemblance, and which rule must change if the answer is wrong. The distinction remains visible instead of being hidden inside one result.","open-source-lattice.5880ea283f":"AT REVIEW","open-source-lattice.73146b6faf":"A good answer is not merely a result. It carries the rule, constraint or source that produced it, together with the version that was in force at the time.","open-source-lattice.3d2c05a449":"That gives a reviewer something concrete to replay and challenge. If the underlying rule changed, the record shows the date and the decisions the earlier version touched.","open-source-lattice.acfca116d0":"IN A REPLY","open-source-lattice.05131464e9":"A sentence saying your case resembled another one gives you nowhere to start. You cannot tell what was checked, what was missing or what you could change before asking again.","open-source-lattice.45ff7e3033":"A written rule gives a different answer: the condition, the shortfall and the date it can change. That lets you decide whether to correct something, wait or challenge the rule itself.","open-source-lattice.0623f003f8":"IN OPERATION","open-source-lattice.7d34128d5c":"Policies often sit in a document while deadlines, assessments and retention dates move through separate systems. The organisation can show the policy existed without showing that the obligation was followed.","open-source-lattice.3792582c09":"When rules and follow-up obligations run together, missed dates and required actions are visible in the same record as the decision. That makes the operating gap reviewable before an incident exposes it.","open-source-lattice.8bfa6a8800":"THE HANDOVER","open-source-lattice.6d9ac46b4f":"A repeatable handover needs the same rule file, the same inputs and a clear record of the version in force. Another team should not have to reconstruct a previous answer from notes and screenshots.","open-source-lattice.a8541eed19":"That is also the exit condition for a pilot: the receiving team can run the recorded artefact with documented inputs on its own hardware, reach the same decision and explain it without the original team in the room.","open-source-lattice.a110000001":"Ask about the release","open-source-lattice.c989d3abf7":"Knowledge pipeline using Lattice as its policy gate.","open-source-lattice.4a86080d67":"Spindle","open-source-lattice.fe0a091fdb":"Products","open-source-lattice.82f505ca48":"Bit-exact arithmetic underneath numeric rules.","open-source-lattice.cd84197771":"Numerus","open-source-lattice.6cc3364a24":"Open source","open-source-lattice.93c7545a34":"Proof certificates that pair with Lattice answers.","open-source-lattice.df84637182":"AION","open-source-lattice.d5d6e83bf2":"Continue exploring","open-source-lattice.03f923bd0d":"Lattice","open-source-lattice.650fabe787":"Open Source","open-source-lattice.75e393a1ac":"See benchmark details","open-source-lattice.f9743247fa":"Read the documentation","open-source-lattice.0c77991f08":"See the benchmark","open-source-lattice.500887039a":"See how the rules run","open-source-lattice.0ca2c134c9":"Lattice compiles rules and constraints into a memory-mappable artefact and evaluates them inside the application. The same query produces the same answer across supported targets, with no network service in the decision path. Internal numeric values are binary, integer, or fixed-point; external floats convert at their declared boundary.","open-source-lattice.728880d6b2":"Microsecond rules","open-source-lattice.90e40d5043":"Get started","open-source-lattice.5a516af33b":"Source / Lattice","open-source-lattice.423bb50cf3":"undoes cleanly","open-source-lattice.630beedf2d":"Each step","open-source-lattice.7438edc353":"When satisfied, keep the supplied source and the rules. No trap.","open-source-lattice.a30ccf2ded":"For good","open-source-lattice.eaee261308":"Compare answers against your current checks for a while.","open-source-lattice.75e2eb3dec":"Alongside","open-source-lattice.3bb8615cb6":"Try a single check on real cases, off to the side.","open-source-lattice.e83ee960e5":"One decision","open-source-lattice.f3fe8258c0":"When Lattice publishes in the third round, read the whole thing yourself. No sales call, no closed box.","open-source-lattice.67ec8d614c":"Before you commit","open-source-lattice.bcd9ce6744":"Each one reversible","open-source-lattice.bfc5ad489d":"FOUR STEPS","open-source-lattice.a9bd085d51":"OWN IT","open-source-lattice.0ae563ebb2":"ALONGSIDE","open-source-lattice.ba7c70b77b":"PILOT","open-source-lattice.0a3768425d":"READ","open-source-lattice.558d328145":"Lattice compiles rules and constraints into a memory-mappable artefact and evaluates them inside the application. The same query produces the same answer across supported targets, with no network service in the decision path. Internal numeric values are binary, integer, or fixed-point; external floats convert at their declared boundary.","open-source-lattice.e9abbe699a":"one reversible step at a time","open-source-lattice.fcb2f49df5":"Take it on","open-source-lattice.a549c147b7":"Adopting it","open-source-lattice.f900c9e4b1":"One small component you can read in full, once it publishes, keeps supply-chain assurance simple.","open-source-lattice.76ac8f2a21":"NIS2 supply chain","open-source-lattice.30004f84a2":"The same answer on every server means a failover cannot quietly change a decision.","open-source-lattice.5c9dfb8dbf":"DORA operational resilience","open-source-lattice.4cd6ae34b0":"Each compiled rulebook carries its own checksum, so you can name the version that ran.","open-source-lattice.e260e84f9e":"EU AI Act transparency","open-source-lattice.bfa71e0019":"Replaying the rule that ran is the explanation, so a data subject gets a real answer.","open-source-lattice.df7eb7e5c0":"GDPR automated decisions","open-source-lattice.8788b8a933":"DORA","open-source-lattice.380f063397":"EU AI ACT","open-source-lattice.a5b7d57a85":"GDPR","open-source-lattice.b539a31f9b":"An auditor or regulator asks pointed questions, and a rules engine earns its keep by the answers it lets you give. Why was this person turned down? Which version of the rules ran? Could a failover have changed the answer? Lattice turns each of those into something you can show, not something you have to reconstruct.","open-source-lattice.1f107fdb2a":"and what you can show","open-source-lattice.6b3e815906":"The question,","open-source-lattice.056dab6fb1":"When the auditor calls","open-source-lattice.d30d63ea2a":"It stays put","open-source-lattice.8c854f4013":"You choose","open-source-lattice.a9690b2af0":"Nothing on the path of a decision crosses a border.","open-source-lattice.f5217b7f96":"Outside service","open-source-lattice.a5c1f29924":"The decision stays inside the European Union.","open-source-lattice.5d1cc3c5c6":"Jurisdiction","open-source-lattice.c82d1b09cf":"EU","open-source-lattice.0684124aa4":"A small companion next to what you already run.","open-source-lattice.4188eb7dc2":"Your systems","open-source-lattice.1ffe14aeb8":"Beside","open-source-lattice.12a7127db7":"On servers you control, behind your own walls.","open-source-lattice.9d914bfcf1":"Building","open-source-lattice.1be0035c25":"Own","open-source-lattice.4412c93780":"You choose the place","open-source-lattice.215475056e":"WHERE IT RUNS","open-source-lattice.ab80efb902":"NO OUTSIDE SERVICE","open-source-lattice.b77c84bcb9":"Where a decision is made matters as much as how. Lattice runs on hardware you control, inside the European Union, with no outside service sitting on the path of a decision. The same file runs in your own building, beside your systems, or right where your staff work.","open-source-lattice.dbb7c9a847":"Inside the EU","open-source-lattice.92d4bb29c3":"On your hardware","open-source-lattice.2fcde4b07e":"European sovereignty","open-source-lattice.be43f1c6e2":"One rulebook","open-source-lattice.aae6fe3179":"Four points","open-source-lattice.e557ec728b":"Consistent screening before anything settles.","open-source-lattice.86b4769072":"Fraud","open-source-lattice.6fa28ba202":"One rulebook for who can do what, across systems.","open-source-lattice.2f81a22de0":"Access","open-source-lattice.d802051b32":"Eligibility and discounts settled at the point of quote.","open-source-lattice.a0d9bbad5f":"Pricing","open-source-lattice.fa9ca74ea3":"Checked on every transaction, before it completes.","open-source-lattice.68f0ae4911":"Compliance","open-source-lattice.93f136cc99":"One component each","open-source-lattice.af0731e081":"FOUR DECISION POINTS","open-source-lattice.91de13eb99":"FRAUD","open-source-lattice.8e85cf5fbe":"ACCESS","open-source-lattice.0f0db55fd5":"PRICING","open-source-lattice.c4d9bc6083":"COMPLIANCE","open-source-lattice.4753ead43f":"The case for a single rules engine is clearest when you see the decisions it covers. Compliance on every transaction, pricing at the point of quote, access at the gateway, and fraud screening before anything settles. The same component handles all four, so there is one rulebook to maintain instead of four, and one consistent answer at each point.","open-source-lattice.8f7b7d2ffd":"across four decision points","open-source-lattice.b3fc8bebf4":"One engine","open-source-lattice.b93f80b8ba":"Where it fits","open-source-lattice.a6c1933f89":"What it de-risks","open-source-lattice.aba3dee917":"What it saves","open-source-lattice.428d3089f1":"A published repository and rules you own keep switching costs low.","open-source-lattice.a1f6f2efad":"No supplier trap","open-source-lattice.596bd0d00e":"The same rule returns the same answer on every server.","open-source-lattice.3422ea0221":"No drift","open-source-lattice.b53216355f":"The checks live inside what you already operate.","open-source-lattice.89236cbd08":"No sidecar to run","open-source-lattice.10a168c34b":"Compliance, pricing, and access run on the same component.","open-source-lattice.4d5c5740f5":"Cost and risk","open-source-lattice.9675887549":"THE TWO QUESTIONS","open-source-lattice.6555108b11":"NO TRAP","open-source-lattice.3d353c49dd":"NO DRIFT","open-source-lattice.cd61d17876":"NO EXTRA SERVICE","open-source-lattice.fafcfb2d49":"ONE ENGINE","open-source-lattice.65bd7749c9":"A rules engine earns its place by removing cost and removing risk. Lattice puts the checking inside the software you already run, so there is no separate service to host, and it returns the same answer on every server, so the decision you made today still reads the same in an audit later.","open-source-lattice.5dfc2cd8b0":"An audit that holds","open-source-lattice.42808b9ca6":"Fewer tools","open-source-lattice.676ffa603b":"What it saves, what it de-risks","open-source-lattice.35a0ab3b85":"At every boundary","open-source-lattice.63a8ba3b60":"Decision evidence","open-source-lattice.bd48e444d0":"Embed the library or run the same engine as a service inside your boundary.","open-source-lattice.376567246e":"Deployment","open-source-lattice.bbdf0e7d20":"The same supported input produces the same decision across targets.","open-source-lattice.ec923862fa":"Measured hot-path check inside the application rather than across a network.","open-source-lattice.7e49372992":"Hot-path check","open-source-lattice.f7dd5c66e9":"The short version","open-source-lattice.874565eaf5":"WHAT OPERATIONS GETS","open-source-lattice.d59ed14bf9":"RUST","open-source-lattice.3115880727":"NO NETWORK HOP","open-source-lattice.dcd47c86f6":"1.36 NS HOT","open-source-lattice.c968638a6e":"DETERMINISTIC","open-source-lattice.36684ad83a":"Lattice turns versioned rules into a compact decision artefact that runs inside the application. Operations gets bit-exact answers across supported targets, a measured 1.36 ns hot path under the referenced benchmark, no network dependency for each check, and the rule evidence needed to explain a decision later.","open-source-lattice.00d756e2ca":"and keep the hot path","open-source-lattice.0afde56699":"fast","open-source-lattice.3d1e7bdec2":"A deterministic rules engine","open-source-lattice.b9259f431a":"Operating contract","open-source-lattice.c93d273ae7":"Clear decisions","open-source-lattice.dfad7f6e00":"No guessing","open-source-lattice.02198a55b1":"A person can see which rule applied instead of accepting a mysterious answer.","open-source-lattice.0819e99b41":"The reason can be shown","open-source-lattice.9505adead7":"The same facts receive the same decision, even when the check happens later.","open-source-lattice.aec1ebd263":"Equal situation, equal answer","open-source-lattice.59916e3315":"The helper follows a clear rule rather than filling in the gaps itself.","open-source-lattice.97ec343175":"The rule is written down","open-source-lattice.42579f4401":"Three simple guarantees","open-source-lattice.265a920ce8":"WHAT STAYS STEADY","open-source-lattice.d8ddbc8b42":"REASON INCLUDED","open-source-lattice.8c8ff3aec4":"SAME ANSWER","open-source-lattice.3f0a3c5adf":"SAME INPUT","open-source-lattice.4a9768fab0":"VISIBLE RULES","open-source-lattice.3b51be1a1f":"Lattice gives the helper a written rule instead of leaving it to guess. Each situation is checked against that same rule, the answer stays consistent, and the reason can be shown later when someone asks what happened.","open-source-lattice.a282adeb2f":"and the answer stays consistent","open-source-lattice.78070ebe5c":"The rule stays visible,","open-source-lattice.f173d3a56f":"Why it stays dependable","open-source-lattice.d8cdb2be9e":"Plain answers","open-source-lattice.d3018b7011":"A real person stays in charge. The machine only helps.","open-source-lattice.09030b3cc6":"Who decides?","open-source-lattice.adc5dde7a5":"The same question gets the same answer, today and tomorrow.","open-source-lattice.af0beb7308":"Will it change?","open-source-lattice.b2899da142":"The checking stays on your own machine, not sent away.","open-source-lattice.ce1aee6de2":"My papers?","open-source-lattice.75ec8b4142":"Nothing happens until the rules allow it. The check comes first.","open-source-lattice.658a8547d7":"Is it safe?","open-source-lattice.7da8e84b16":"Answered plainly","open-source-lattice.5493f2c3ad":"WHAT PEOPLE WORRY ABOUT","open-source-lattice.33906a7dfd":"OPEN","open-source-lattice.c61a7c7f39":"FAIR","open-source-lattice.b0b7ba4666":"PRIVATE","open-source-lattice.04f52a5c28":"SAFE","open-source-lattice.f6511fdba0":"It is fair to be careful about anything new. So here are the plain answers to the questions people usually ask, one card at a time. No catch, no fine print.","open-source-lattice.39df9ae563":"to the things people worry about","open-source-lattice.d75b144a8a":"Six honest answers","open-source-lattice.6841b0058d":"comes first","open-source-lattice.76d6562c0a":"The check","open-source-lattice.9ee1fc88a9":"The reason is written down, kept, and easy to read back.","open-source-lattice.38e727cd1e":"You can ask why","open-source-lattice.65efdce894":"A clear yes or no, with the rule behind it.","open-source-lattice.bd1e65d567":"It gives an answer","open-source-lattice.a139211023":"The careful part reads the rulebook before anything moves.","open-source-lattice.9a10a200e9":"It reads the rules","open-source-lattice.518a0c958c":"You make a simple request. Nothing has happened yet.","open-source-lattice.7ed149da71":"You ask","open-source-lattice.fd49a6abf4":"In order, every time","open-source-lattice.fc2c6297a4":"THE FOUR STEPS","open-source-lattice.c4f5f05c42":"YOU CAN ASK","open-source-lattice.539d75d33b":"IT DECIDES","open-source-lattice.e5640b15ab":"IT READS","open-source-lattice.bad0d7b811":"YOU ASK","open-source-lattice.a3efa33e76":"It is easier to trust something once you have watched it work. So here is one everyday moment, a small top-up to your pension, walked through one step at a time. Move through the steps and a friendly note tells you exactly what is going on. No rush, no jargon.","open-source-lattice.610520ead5":"in one ordinary moment","open-source-lattice.13e2e1ec42":"Watch it happen","open-source-lattice.c16dfd1733":"Step by step","open-source-lattice.5b9ef21657":"The careful one","open-source-lattice.7cc70b7741":"The hurried one","open-source-lattice.6a14e82a0d":"One sends them away. The other keeps them on your machine.","open-source-lattice.2471d2a5d8":"With your papers","open-source-lattice.54d44f0754":"One cannot show its working. The other shows the rule, in writing.","open-source-lattice.a82e018089":"When you ask why","open-source-lattice.5f15933f2c":"One might say something different. The other stays the same.","open-source-lattice.674728ed78":"On another day","open-source-lattice.88adb075d1":"One guesses, the other reads the rulebook before answering.","open-source-lattice.2392861d83":"A question comes in","open-source-lattice.5f65cb44b2":"Side by side","open-source-lattice.99162c6390":"THE TWO HELPERS","open-source-lattice.9d7dfc73a9":"KEEPS IT SAFE","open-source-lattice.71d808c495":"SHOWS WHY","open-source-lattice.1a7d0ca644":"CHECKS","open-source-lattice.c8fa2d2f22":"GUESSES","open-source-lattice.68eddce5e8":"The easiest way to see what Lattice does is to put two helpers side by side. One is in a hurry and guesses. The other checks the rulebook first. The same situations, two very different ways of handling them.","open-source-lattice.a572bfad41":"And a careful one","open-source-lattice.7ffae6ed0c":"A hurried helper","open-source-lattice.8852360a3e":"A picture","open-source-lattice.6571689c03":"No waiting","open-source-lattice.1a03bcb291":"No jargon","open-source-lattice.39b63383db":"The checking happens on your own machine.","open-source-lattice.862044aac9":"Stays home","open-source-lattice.755844bc39":"Yours","open-source-lattice.0b9bddd9e4":"You can always ask which rule applied.","open-source-lattice.04fcd2bfb7":"On request","open-source-lattice.27fa5afc38":"It does not change its mind from one day to the next.","open-source-lattice.748288fd12":"Every time","open-source-lattice.b76aee974c":"Same","open-source-lattice.47a96b4493":"A clear answer, checked against the rules first.","open-source-lattice.895e891f25":"Or no","open-source-lattice.5397e0583f":"Yes","open-source-lattice.efffac7f8e":"On your side","open-source-lattice.06ebfec4be":"WHAT IT GIVES YOU","open-source-lattice.1c78903488":"ASK WHY","open-source-lattice.a81fc0b4a0":"NO WAITING","open-source-lattice.b00a146670":"SAME ANSWER","open-source-lattice.8fceb67367":"THE CLERK","open-source-lattice.c2ededa5d2":"Lattice compiles rules and constraints into a memory-mappable artefact and evaluates them inside the application. The same query produces the same answer across supported targets, with no network service in the decision path.","open-source-lattice.3b27e65f75":"that checks the rules","open-source-lattice.8762a28b08":"It is the part","open-source-lattice.704869f20f":"In plain words","open-source-lattice.8faedce292":"Four runtimes","open-source-lattice.70e4f2fee8":"Same artefact","open-source-lattice.9de0c97b36":"Trimmed build close to the data.","open-source-lattice.acbf062902":"Constrained","open-source-lattice.8440b9eb7d":"Edge","open-source-lattice.c428cb426e":"Same bytes, client-side eval.","open-source-lattice.54a2cf5e63":"Browser","open-source-lattice.4e946026a7":"WASM","open-source-lattice.add56deb64":"One binary per pod, shared mmap.","open-source-lattice.1d10323c27":"Standalone","open-source-lattice.2b068e1f87":"Sidecar","open-source-lattice.b27920d391":"Linked into a Rust service, zero copy.","open-source-lattice.ed778f5b65":"In process","open-source-lattice.b8100f5ba8":"Library","open-source-lattice.b5514af3d9":"One artefact, four targets","open-source-lattice.d576dc5942":"RUNTIMES","open-source-lattice.fe79447bad":"EDGE","open-source-lattice.d4407b4ee1":"SIDECAR","open-source-lattice.803a250cd3":"CRATE","open-source-lattice.e3f0ba69cd":"Lattice comes as a Rust crate, through a C ABI, as a standalone binary, or as a WASM module. The same artefact runs in all four, inside a service, beside a workload, in a browser, or on a constrained edge target.","open-source-lattice.5ecf8b6286":"Sidecar. Browser. Edge","open-source-lattice.91826ba9cb":"Embed","open-source-lattice.e677c20f56":"Deployment posture","open-source-lattice.4512351033":"Knowledge governance pipeline that runs Lattice gates.","open-source-lattice.5df9877fd1":"Parse rule sources with content-addressed trees.","open-source-lattice.188fb5d6cf":"Reed","open-source-lattice.3db662216b":"Pair Lattice answers with AION proofs for full audit.","open-source-lattice.9c9c867837":"Pair with","open-source-lattice.d5871175c9":"A single Rust crate keeps supply-chain assurance simple.","open-source-lattice.9cb60dc51d":"Same answer on every server prevents drift incidents during failover.","open-source-lattice.398f6acc90":"Compiled rule artefact is the explanation surface. The XXH3-64 checksum pins the version that ran.","open-source-lattice.d72317a8ce":"Replayable rule evaluation gives data subjects an explanation that is the audit artefact.","open-source-lattice.21f05ca70b":"12+ SOLVERS","open-source-lattice.6443d01b7e":"Lattice compiles rules and constraints into a memory-mappable artefact and evaluates them inside the application. The same query produces the same answer across supported targets, with no network service in the decision path.","open-source-lattice.c6a05b5488":"Bit-exact. Microsecond","open-source-lattice.a55e5a1229":"Deterministic policy evaluation","open-source-lattice.fca77b7e3a":"The rule engine, measured","open-source-lattice.0cf1be09c5":"Lattice compiles rules and constraints into a memory-mappable artefact and evaluates them inside the application. The same query produces the same answer across supported targets, with no network service in the decision path.","open-source-lattice.ad4e612540":"Lattice use cases","open-source-lattice.fc7b91c3d8":"Compliance checks, pricing engines, access control, fraud screening: anywhere a wrong answer is expensive and a slow answer is unusable.","open-source-lattice.2652fd24d8":"Rules that have to be fast and right cover every high-stakes decision point: compliance, pricing, access, fraud, routing, and eligibility.","open-source-lattice.a48a3ecb05":"Different rules","open-source-lattice.5906016d0e":"Same engine","open-source-lattice.3e95b6c321":"Multi-rule screening with consistent answers.","open-source-lattice.33a00b17c6":"1.36 ns","open-source-lattice.6a310f3013":"RBAC and ABAC checks at gateway latency.","open-source-lattice.342fc74063":"Discount and eligibility eval at request time.","open-source-lattice.138bf6d3e1":"Per-check cost on every transaction.","open-source-lattice.5c94c6506d":"Where Lattice ships","open-source-lattice.e933d6dad2":"OUTCOME TILES","open-source-lattice.6c71776e29":"ROUTING","open-source-lattice.c94771b05c":"have to be fast and right","open-source-lattice.b20489c44d":"Where rules","open-source-lattice.14a29ba383":"Use cases","open-source-lattice.13f71ffcde":"No external service","open-source-lattice.6b5eb5323e":"Deterministic policy evaluation","open-source-lattice.7827dd826c":"SAT, SMT, LP, MIP, CP, A*, MaxSAT","open-source-lattice.404ec31fc6":"12+ solvers","open-source-lattice.d18c01ae77":"AOT compiler, packed eval, XXH3-64 checksums","open-source-lattice.e225e0a0f5":"Lattice engine","open-source-lattice.d270310879":"Eval in browser and edge","open-source-lattice.f0317e204b":"Embed in C, Python, Go","open-source-lattice.9652018eda":"C ABI","open-source-lattice.437d0c008b":"build / verify","open-source-lattice.700b401ca5":"CLI","open-source-lattice.6fae63a153":"Native API, zero copy","open-source-lattice.0cbc58f0cf":"Rust crate","open-source-lattice.be94d17eba":"Where Lattice plugs in","open-source-lattice.07a56cd0db":"INTEGRATION GRAPH","open-source-lattice.4b8edbc37b":"Lattice comes as a Rust crate, a CLI for builds and audits, or a stable C ABI for embedding in any language. Rule artefacts are portable files; integration is a function call away.","open-source-lattice.ba9a5058fe":"C ABI","open-source-lattice.f8291ea26d":"Rust crate, CLI,","open-source-lattice.899e5920ef":"One rule artefact, four surfaces","open-source-lattice.9c3d44566b":"Measured on the ref-lattice criterion suite. Run the benchmark on your own hardware.","open-source-lattice.2e4e3b0d21":"Rust, embedded library or service","open-source-lattice.3229609e15":"Deterministic policy evaluation","open-source-lattice.8a120caf43":"Solver backends","open-source-lattice.89e5d5f04b":"Single-thread, scales with cores","open-source-lattice.fc65cf253d":"Throughput","open-source-lattice.3f53ea6018":"735M / s","open-source-lattice.b5962769d0":"First eval after mmap","open-source-lattice.19711ad279":"Cold lookup","open-source-lattice.9bb1636919":"39 ns","open-source-lattice.a6bc51b787":"Full hot-section coverage","open-source-lattice.5dd5a89a57":"Hot-path lookup","open-source-lattice.58c76110f0":"By the numbers","open-source-lattice.69bfc818a3":"No surprises","open-source-lattice.7f83ad84c7":"Re-apply rules to logged inputs for the same outcome.","open-source-lattice.17d120d8bb":"Replayable","open-source-lattice.84ff839ff5":"Compiled artefact carries XXH3-64 checksums.","open-source-lattice.84d0e984bc":"Checksummed","open-source-lattice.d8153b9a77":"Identical answer on every supported CPU.","open-source-lattice.065acc24fb":"Bit-exact","open-source-lattice.6c678a2386":"Always-on by default","open-source-lattice.0f5489b651":"DET MODE","open-source-lattice.3c9e174d9c":"REPLAYABLE","open-source-lattice.30ed3e35a3":"Lattice is bit-exact across CPU architectures and operating systems. The compiled rule artefact carries XXH3-64 checksums; replaying the same artefact replays the same answer.","open-source-lattice.a5e025760d":"Every platform. Every time","open-source-lattice.2a839616d2":"Same answer","open-source-lattice.2956ef9ad6":"Determinism","open-source-lattice.b740b8d719":"Single rule API","open-source-lattice.9412e238ce":"Auto-routed per constraint","open-source-lattice.fea17319bf":"Shortest path and weighted soft-constraint optimisation.","open-source-lattice.bce0641417":"Search","open-source-lattice.dcd055a941":"AC3 propagation and a Gecode backend, including non-linear.","open-source-lattice.e583e48f42":"Finite domains","open-source-lattice.05ec003d9a":"SCIP-backed branch and bound for integer decisions.","open-source-lattice.0b682ab7ed":"Mixed-integer","open-source-lattice.32519d7080":"HiGHS-backed pricing and allocation through an external solver boundary with declared fixed-point conversion.","open-source-lattice.3b498d6b17":"Linear programs","open-source-lattice.fd5488af8a":"Combines SAT with arithmetic, bitvectors, arrays via cvc5.","open-source-lattice.54b6415193":"Mixed theories","open-source-lattice.d47afc7e65":"CDCL core for pure-boolean rules. Fastest for access checks.","open-source-lattice.d3c2844b85":"Boolean satisfiability","open-source-lattice.798d8a3d7d":"12+ backends, auto-routed","open-source-lattice.9ce1806972":"SOLVER LADDER","open-source-lattice.a26e9253db":"A* / MAXSAT","open-source-lattice.f19057bfb8":"CP","open-source-lattice.008aff4dd5":"LP / MIP","open-source-lattice.ba42eddff9":"SMT","open-source-lattice.d20602f525":"SAT","open-source-lattice.1fcf1993c5":"Lattice routes constraints to the right solver class automatically. SAT for boolean rules, SMT for mixed-theory, LP and MIP for numeric optimisation, CP for finite domains, A* and MaxSAT for search and soft constraints. Internal numeric work is binary, integer, or fixed-point; an external solver boundary declares any conversion.","open-source-lattice.5ea64df62e":"One rule API","open-source-lattice.6445eaa4cc":"12+ solvers","open-source-lattice.c0ecfafe2d":"Audit fail mode","open-source-lattice.9b87de0dc0":"Black-box rules","open-source-lattice.1f40192245":"round trip","open-source-lattice.a0c3c7ed81":"A policy service across the wire, one more hop to keep up.","open-source-lattice.c93f6536dc":"Remote","open-source-lattice.9ea9fdf58d":"no proof","open-source-lattice.51a70d1452":"No replayable audit. Explanations are prose.","open-source-lattice.c637aebe3a":"Opaque","open-source-lattice.c93afd0238":"Engine version and JIT differences across servers.","open-source-lattice.4876f7b9e7":"Drift","open-source-lattice.d7d35de712":"Milliseconds per eval. Stacks up at scale.","open-source-lattice.3e39972526":"Latency","open-source-lattice.9be4f959b1":"Four common failures","open-source-lattice.58010365e8":"WHY ENGINES FAIL","open-source-lattice.98c526b9d1":"NETWORK HOP","open-source-lattice.a268dc3d48":"BLACK BOX","open-source-lattice.627fea839e":"DRIFT","open-source-lattice.49d6c10ece":"LATENCY","open-source-lattice.369cd8d6ba":"Interpreted rule engines add milliseconds per evaluation. Different versions return different answers on different servers. Auditors cannot replay decisions because the engine is a black box, and a policy service across the wire is one more thing that can be down.","open-source-lattice.e973973e7b":"are too slow and too vague","open-source-lattice.2c108f15f9":"Most rule engines","open-source-lattice.8a9400005c":"Rules should not change with the server","open-source-lattice.aab50eb6e3":"No GPU needed","open-source-lattice.98c200b9c5":"Standard CPU","open-source-lattice.2b84ec6dcc":"Single-thread, scales with cores.","open-source-lattice.9c3a1b70f7":"First lookup after mmap, cache miss.","open-source-lattice.032ad02f8c":"Cold eval","open-source-lattice.1b2e7186fb":"39.3 ns","open-source-lattice.cb69e5e5ea":"Standard section, aligned read.","open-source-lattice.57b4756a5d":"Tier 2 read","open-source-lattice.bbc43ecbbf":"6.6 ns","open-source-lattice.8e6194fdb2":"Cache-resident packed tree walk.","open-source-lattice.17200f98aa":"Hot eval","open-source-lattice.5278f246b7":"Per lookup at full hot-section coverage","open-source-lattice.3b10628d79":"LATENCY LADDER","open-source-lattice.d315d1600e":"In the referenced benchmark, hot-path eval averages 1.36 ns per check. Cold lookup, the first eval after mmap, averages 39 ns. Throughput reaches 735M lookups per second on one thread and scales with cores; no shared mutable state.","open-source-lattice.e8a68e4692":"39 ns cold","open-source-lattice.19e921baf3":"1.36 ns hot","open-source-lattice.63c9045599":"Performance","open-source-lattice.bd48f9baba":"That determinism is not a configuration option. It is a product property of the compiled artefact.","open-source-lattice.d2e92ef2e0":"Lattice project lede","open-source-lattice.eec653a274":"Lattice is the alternative: a deterministic constraint evaluation engine whose referenced benchmark reports 1.36 ns on the hot path, with bit-exact reproducibility across supported targets. Its internal numeric work is binary, integer, or fixed-point.","open-source-lattice.ce90a5a34e":"Compiled rules live in a memory-mappable binary file. Eval is a packed-tree walk with no allocator on the hot path.","open-source-lattice.0e7cd83602":"Bit-exact answers","open-source-lattice.a3faac4669":"No allocator on hot path","open-source-lattice.b9a7ebce68":"Tree walk over packed nodes. 1.36 ns hot.","open-source-lattice.e7b08833a4":"Eval","open-source-lattice.77fc03aa26":"Memory-mappable file, XXH3-64 checksums. Cold lookup 39 ns.","open-source-lattice.152a5035bf":"Pack","open-source-lattice.736e777cf9":"AOT to a packed binary tree, solver class pinned per rule.","open-source-lattice.c2f3e610ef":"Compile","open-source-lattice.adeb3ab433":"Rules and constraints declared and versioned with source.","open-source-lattice.5fda23d620":"Author","open-source-lattice.3292b98e20":"Rules to eval","open-source-lattice.8d79e6b5bb":"COMPILE PIPELINE","open-source-lattice.225a586b70":"EVAL","open-source-lattice.ac73217bc9":"MMAP","open-source-lattice.abe0707165":"COMPILE","open-source-lattice.8b61f8355a":"AUTHOR","open-source-lattice.19f0ebd5f3":"Rules are authored and versioned alongside source, compiled ahead of time to a packed binary tree, and stored in a memory-mappable file. Evaluation is a tree walk over packed nodes. Hot cache lines, no allocator on the hot path.","open-source-lattice.4ad413a9f3":"Memory-map. Evaluate","open-source-lattice.7e8494a31a":"Compile once","open-source-lattice.b040b4179b":"Architecture","open-source-lattice.3a12a3cf12":"12+ solver families","open-source-lattice.b240d04328":"Selector","open-source-lattice.7d15dd1bec":"Routing","open-source-lattice.06160a7a2e":"MaxSAT","open-source-lattice.0b8b39a192":"Combinatorial","open-source-lattice.5d4a442e89":"ILP","open-source-lattice.2ebe474136":"MIP","open-source-lattice.085ac9a633":"LP","open-source-lattice.30a6238040":"Numeric","open-source-lattice.3d52a6d8fe":"Logic","open-source-lattice.ac447144a3":"12+ solver backends","open-source-lattice.750e6cd9ac":"BACKEND CENSUS","open-source-lattice.8c1f3356d9":"Lattice compiles rules and constraints into a memory-mappable artefact and evaluates them inside the application. The same query produces the same answer across supported targets, with no network service in the decision path. Internal numeric values are binary, integer, or fixed-point; external floats convert at their declared boundary.","open-source-lattice.f85f27c315":"Not a sidecar","open-source-lattice.c08b3ccc13":"Policy in the hot path","open-source-lattice.8c2e3a4a92":"What Lattice is","open-source-lattice.28bb607630":"The benchmark suite reports scoped values. Run it on your own hardware once the repository publishes.","open-source-lattice.c12f85162a":"sustained throughput at full hot-section coverage","open-source-lattice.95c4399b04":"cold-path (first lookup after mmap)","open-source-lattice.402d6996b1":"                   No change in performance detected.","open-source-lattice.500a6433b7":"policy lookups: hot-path criterion run","open-source-lattice.971611bea5":"ref-lattice criterion benchmark","open-source-lattice.ae57abaf3f":"Scales with cores","open-source-lattice.9b36918854":"Single-thread","open-source-lattice.e733dea20e":"Single-thread, full coverage.","open-source-lattice.380178e3c8":"First query after artefact mmap.","open-source-lattice.e52f0a08b0":"10K rule artefact, full hot-section coverage.","open-source-lattice.2546591779":"Hot lookup","open-source-lattice.bdf7c3a858":"Per-lookup at full hot-section coverage","open-source-lattice.78e23f846c":"LATTICE BENCHES","open-source-lattice.d9074c5c77":"CRITERION","open-source-lattice.3f76181517":"39 ns COLD","open-source-lattice.8a0d19061d":"This is the criterion output from the ref-lattice benchmark suite. Hot-path eval averages 1.36 ns per check. Cold start, the first eval after mmap, averages 39 ns. Throughput rises with hot-section coverage to 735M lookups per second on one thread. Run it on your own hardware.","open-source-lattice.cfb237cdf6":"Measured. Reproducible. Yours to run","open-source-lattice.6b411e5ef5":"1.36 ns lookup","open-source-lattice.131f781cb4":"The benchmark","open-source-lattice.e2ae20d9ae":"Rust","open-source-lattice.6b0c36de27":"Built in","open-source-lattice.43db414b40":"Same answer every time","open-source-lattice.fa1703dd78":"Audit","open-source-lattice.45fa9adf4c":"Your hardware, in the EU","open-source-lattice.1d197d39c5":"Where it runs","open-source-lattice.486a225039":"Decision path","open-source-lattice.bf5dde2d06":"Lock-in","open-source-lattice.6da13addb0":"Source","open-source-lattice.7d85e2eb78":"Deterministic policy evaluation","open-source-lattice.a22d4e6d4b":"For decision makers","open-source-lattice.cdc8dd09fe":"Lattice is a deterministic policy and constraint engine in Rust for AI governance, compliance, pricing and access decisions. It compiles versioned rules into a checksummed artefact and evaluates live data on hardware you control, so every decision can be replayed and audited.","open-source-lattice.4e7477cef8":"for compliance decisions","open-source-lattice.00f0901d54":"Lattice","open-source-lattice.de569d012a":"A person, not the machine","open-source-lattice.993a665d35":"In charge","open-source-lattice.297470ed37":"Always allowed","open-source-lattice.129dd7fd69":"Ask why","open-source-lattice.4dc03ea146":"Stay with you","open-source-lattice.aca6dd17f0":"Your papers","open-source-lattice.0c371f9da6":"On every machine","open-source-lattice.3477f4d91d":"Same answer","open-source-lattice.1786d949d8":"Faster than you notice","open-source-lattice.2d2cb022bc":"Speed","open-source-lattice.98822265e7":"Yes or no, and why","open-source-lattice.29890e1545":"Its job","open-source-lattice.c571e25452":"The rules checker","open-source-lattice.f8c94a3b4b":"What it is","open-source-lattice.7ccd8cfc31":"For everyone","open-source-lattice.1b4f0ecc7e":"Why it is safe","open-source-lattice.06c805023d":"A fair rule, applied the same way","open-source-lattice.d94699397e":"Lattice is a rules engine for decisions a person can check. It applies explicit rules to live data and gives the same answer under the same rules, so a decision can be explained later without technical guesswork. It publishes in the third round of Dweve's foundation release programme.","open-source-lattice.40a92a357d":"for decisions you can check","open-source-lattice.906c366168":"An understandable rules engine","open-source-lattice.06887c4831":"12+ backends","open-source-lattice.fde68155d3":"Solvers","open-source-lattice.1234c96cf3":"Binary, memory-mapped","open-source-lattice.041a5dec48":"Format","open-source-lattice.2d33a16cd3":"Bit-exact across platforms","open-source-lattice.b7d1bbbe5d":"1.36 ns hot, 39 ns cold","open-source-lattice.89b86ab0e6":"Language","open-source-lattice.942587e61e":"Project sheet","open-source-lattice.d4a74b503a":"Read the docs","open-source-lattice.052bd397d3":"Lattice is a deterministic constraint engine in Rust for compliance, pricing and access rules. Under the referenced benchmark, hot-path evaluation averages 1.36 ns and returns bit-exact results across supported platforms.","open-source-lattice.d8e73e69d0":"for compliance decisions","open-source-lattice.777c7ac75c":"A deterministic rules engine","open-source-lattice.449673d56b":"A*","open-source-lattice.f541ab1317":"SAT","open-source-lattice.baa2eca220":"SMT","open-source-lattice.facee6dd84":"LP","open-source-lattice.da31905ffd":"MIP / ILP","open-source-lattice.e4918de402":"CP","open-source-lattice.3903223a31":"A* / MaxSAT","open-source-lattice.9cdc6c47aa":"always","open-source-lattice.78587c41ed":"integrity","open-source-lattice.b81f37a043":"audit","open-source-lattice.4bbe66e420":"Asks","open-source-lattice.f72894d8fb":"Again","open-source-lattice.d3ae14a50b":"Why","open-source-lattice.4f9f0dabcd":"Safe","open-source-lattice.cced28c6dc":"start","open-source-lattice.20f65c2867":"check","open-source-lattice.5589aa5863":"decide","open-source-lattice.0818ab2593":"explain","open-source-lattice.f411a1fb62":"Clear","open-source-lattice.ed077f3d81":"Same","open-source-lattice.54b26f7d3d":"Why","open-source-lattice.cf989ea142":"1.36 ns","open-source-lattice.0bd44968dd":"Repeatability","open-source-lattice.6c540ba965":"Bit-exact","open-source-lattice.b6cac10f50":"Local","open-source-lattice.1dabba21cd":"✓","open-source-lattice.9b9a8d05a7":"Read","open-source-lattice.383e2d9462":"Pilot","open-source-lattice.00d60e31a4":"Run","open-source-lattice.81b34dba3d":"Own","open-source-lattice.0f4b423c4b":"MEASURED","open-source-lattice.6e10953f3e":"OPEN","open-source-lattice.8215b59ccb":"ENGINE","open-source-lattice.5d0b2f6bd4":"OBSERVED","open-source-lattice.4fe467ac80":"ALL ON","open-source-lattice.35e0d0360a":"LIVE","open-source-lattice.caaed59b6a":"PORTABLE","open-source-lattice.00db09ab06":"PLAIN","open-source-lattice.a04f274bcc":"HONEST","open-source-lattice.80db3832a5":"OUTCOMES","open-source-lattice.9170a8b2fb":"EU","open-source-lattice.82cfc09234":"LOW RISK","open-source-lattice.a1a6a3b130":"Determinism, acted out","open-source-lattice.1df3e79521":"Ask the same question on four machines.","open-source-lattice.97521c1e56":"Compare the bytes.","open-source-lattice.263c9af264":"Rules compile ahead of time into a packed binary tree that is memory-mapped, never parsed. Evaluation walks that tree with no allocator on the hot path, no JSON in the way and no garbage collector waiting to pause.","open-source-lattice.40b7cef358":"So the answer belongs to the artefact, not to one machine. The same compiled file on supported targets returns the same result, byte for byte. Determinism is not a flag you set. It is what the file is.","open-source-lattice.e63a6e3216":"Artefact verify","open-source-lattice.014d005e2d":"x86-64 avx-512","open-source-lattice.26c190b0cf":"aarch64 neon","open-source-lattice.349787b19a":"riscv64","open-source-lattice.68d5f52dec":"wasm32 in browser","open-source-lattice.39620a260a":"same bytes out","open-source-lattice.d7c5fb66c2":"one artefact, four targets, checksum verified before the first evaluation","open-source-lattice.2c0a80a6f5":"The part the page never says","open-source-lattice.142da63823":"You do not choose the solver.","open-source-lattice.f58e2c547b":"Lattice chooses it.","open-source-lattice.37cd98f074":"Most constraint work is a lookup and never leaves the packed tree. What is left is not one problem but five, and each has its own literature, its own tuned implementations and its own way of falling over when you pick the wrong one.","open-source-lattice.40263648ce":"Solver route","open-source-lattice.5350df806e":"classified per problem, ranked on recorded performance, no manual backend selection","open-source-lattice.981f3aad26":"So Lattice classifies the problem first, extracts its structural features and routes it to whichever solver fits, ranked on what those solvers actually did on problems like it. Behind that single call sit around two hundred solver modules, sixty of them on a completed roadmap, from CDCL and DPLL(T) through mixed-integer convex programming to reactive temporal synthesis.","open-source-lattice.fbc943d5fe":"boolean sat","open-source-lattice.6ece626507":"smt, ten theories","open-source-lattice.66b251715b":"mixed integer","open-source-lattice.62683456ae":"temporal synthesis","open-source-lattice.e58e06b00c":"game equilibrium","open-source-lattice.91433e35ae":"two hundred modules, one call","open-source-lattice.b071b0203e":"you stop being believed and start being checked","open-source-lattice.cb959bb54f":"the same answer, or a named integrity failure","open-source-lattice.1ef37a1c36":"against their own input","open-source-lattice.22b403d22f":"on their hardware","open-source-lattice.721fe5656b":"they run them themselves","open-source-lattice.7f212f7312":"they hold the rules","open-source-lattice.6d3037cd72":"verified independently","open-source-lattice.435cd69cfc":"Handed over","open-source-lattice.3412672ce0":"Because the rules compile to a file, you can hand the file over. The other side runs it against the same input, on their own machine, and gets the same answer or does not. You stop being believed and start being checked, which is a considerably better position to be in.","open-source-lattice.67a3f01c82":"Every assurance an organisation offers about its own decisions has the same weakness: the organisation produced it. A report you compiled, from logs you control, about a system you operate. It may be entirely honest, and everybody in the room knows whose account it is.","open-source-lattice.8901558db8":"That is the whole test.","open-source-lattice.705bcde618":"Can you give it to the other side?","open-source-lattice.16588eeacf":"The test that matters","open-source-lattice.c7dcbfcbdb":"What you get is a register you can hold, and a decision that answers for itself","open-source-lattice.c74f1e0f78":"NOT A PROMISE","open-source-lattice.080b3a0177":"MAKES WRONG RULES VISIBLE","open-source-lattice.adab36ff5d":"ENFORCES, DOES NOT AUTHOR","open-source-lattice.e9af677ed0":"Correctness is a promise until it can be checked. A register can be checked: it names the rule, its owner and its date, and lets reviewers test the decisions it touched rather than take it on trust.","open-source-lattice.540990e62c":"What it does is make a wrong rule visible rather than arguable. It has a name, a version, a date, an owner and a list of every decision it touched, so it can be found, challenged and changed.","open-source-lattice.b07176feed":"The boundary","open-source-lattice.6ed562ce46":"Encoding an article as four conditions is an interpretation of that article, and the interpretation is yours to defend. Lattice will apply a badly drafted rule with total consistency and produce an impeccable record of having done so. It does not make you compliant, and nothing does.","open-source-lattice.06fcb1453e":"not whether they are right","open-source-lattice.83003287ba":"It enforces your rules exactly","open-source-lattice.9b8111568e":"Being straight about it","open-source-lattice.9e5b66f99d":"And it is worth being equally plain about what none of this fixes","open-source-lattice.3267bbc5ba":"EVERY STEP REVERSES","open-source-lattice.0fa665a070":"REPLAY PAST DECISIONS","open-source-lattice.d1bdaf5837":"READ IT BEFORE COMMITTING","open-source-lattice.4406024c7d":"Finding those is worth the exercise whether or not you go further, because it shows where operating practice and written policy separated. It is the kind of finding an internal audit function recognises immediately.","open-source-lattice.c8ad4781c2":"The disagreements are the useful output. In practice most turn out to be places where the existing rules were ambiguous rather than wrong, two defensible readings of the same policy applied inconsistently for years.","open-source-lattice.cac3da045e":"How it holds","open-source-lattice.2873dc8c19":"When Lattice publishes in the third round, read the whole thing before you commit. Replay decisions you have already made and compare. Pilot one decision off to the side. Then run it alongside your existing checks on live traffic, acting on nothing, recording where it disagrees.","open-source-lattice.8753af8854":"and let it disagree","open-source-lattice.5e1ddf6c7e":"Run it beside what you have","open-source-lattice.790d0207d3":"How this starts","open-source-lattice.8681fd6697":"Running it yourself helps only if adopting it is a step rather than a programme","open-source-lattice.ac0c29293d":"NOTHING TO BE UNAVAILABLE","open-source-lattice.b9836279e6":"EU JURISDICTION","open-source-lattice.d0158524ed":"YOUR HARDWARE","open-source-lattice.c4df720eee":"It also means none requiring a processing agreement or a transfer assessment of its own. The same file, with the same rule version, runs in your data centre, at the edge, or in a browser.","open-source-lattice.341f9159bb":"There is no endpoint of ours in the decision path, which means none to be unavailable during an incident, and none that can change behaviour beneath you on somebody else’s release schedule.","open-source-lattice.2f6a307ba7":"For operators","open-source-lattice.e61c764677":"Where a decision is made matters as much as how. Evaluation happens inside your own systems, on hardware you control, with no external service on the path of a decision. Personal data is assessed where it already sits rather than being sent somewhere to be assessed.","open-source-lattice.0b0df9ade1":"inside the European Union","open-source-lattice.64850edfb0":"On your hardware,","open-source-lattice.c229e5cdbc":"A record written when the decision happened costs nothing to produce later","open-source-lattice.7d2b137d0e":"AN ARGUMENT, NOT A RECORD","open-source-lattice.494e1a6c4a":"WEAKER AS IT AGES","open-source-lattice.377e435845":"DAYS, EVERY TIME","open-source-lattice.fc801413da":"It is weakest exactly when it matters most, because the decisions people ask about are the old ones that went wrong. It also costs four days every time, which nobody budgets for and everybody spends.","open-source-lattice.676e80c266":"Every piece of that is true and none of it is the record. It is a reconstruction, assembled after the fact by the organisation being asked the question. There is no authoritative version behind it.","open-source-lattice.5c82441a97":"The record","open-source-lattice.bbc3975930":"The current rules, pulled from wherever they live. A deployment log, read to guess which version was live. A changelog, read backwards. Two people who were there, asked what they remember. A spreadsheet somebody made at the time, if it still exists. Then it is written up as though it had been recorded all along.","open-source-lattice.95992cffcf":"that is probably right","open-source-lattice.5681d76670":"Four days, and an answer","open-source-lattice.48669aa902":"What happens today","open-source-lattice.1df428395b":"All of that is worth having because of what happens when somebody asks about one old decision","open-source-lattice.2ea65df1c8":"AN OWNER PER OBLIGATION","open-source-lattice.011ac9ce99":"STATES AND CLOCKS","open-source-lattice.67bedf4a47":"PASS, BLOCK, OR ACTION REQUIRED","open-source-lattice.1af651355e":"The engine that evaluates a consent condition also tracks the obligation that follows from it and records both together, which is where most compliance programmes lose the thread between having a policy and operating one.","open-source-lattice.f427d9d0c7":"So the outcome is not only pass or block. It can be action required: a request needing a response within a deadline, an assessment that must exist before this system may run, a retention period that has expired and now demands a decision.","open-source-lattice.46cfb3934a":"In practice","open-source-lattice.73a87d35e3":"Compliance is not only conditions. It is a request handled against a deadline, an impact assessment completed before a system goes live, a retention period enforced when data is read rather than by a job that may not have run, and a transfer recorded when it happens. Those are processes with states, clocks and owners.","open-source-lattice.c1e9b53dd3":"is a process, not a condition","open-source-lattice.77ce03859e":"A subject access request","open-source-lattice.6740bc2722":"Operational compliance","open-source-lattice.b90c7de316":"the rules are versioned with the thing they govern","open-source-lattice.fdd250c1da":"a reference, not a reconstruction","open-source-lattice.d959d9ae7a":"what changed after, and on what date","open-source-lattice.781b8d6818":"which nodes were running it","open-source-lattice.e53d757cf5":"who approved it, and when","open-source-lattice.cedf39e627":"which rule version was live","open-source-lattice.e46159ccf7":"In force in March","open-source-lattice.066ad2514b":"Somebody asks why an application was declined in March. The rules have not changed since, which sounds like a complete answer until you remember what else moves. The model was retrained in April. A threshold was adjusted. A retrieval index was rebuilt. The governing conditions and the thing they govern drift independently, and only one of them is usually versioned.","open-source-lattice.c67c1a21fc":"Something else did.","open-source-lattice.e95cac9649":"The rules did not change.","open-source-lattice.125abce20e":"The question after the incident","open-source-lattice.1c2b411db4":"Conditions are half of it, and the other half is the processes that follow from them","open-source-lattice.523cd28025":"BEFORE IT IS USED","open-source-lattice.cbbf0d2b0b":"CHECKSUM VALIDATED","open-source-lattice.18d9ed09d2":"INPUT AND TRAINING SET","open-source-lattice.717795aa8e":"Wrong in one direction and you have quietly corrupted a dataset somebody will rely on. Wrong in the other and you have a notifiable breach, found by somebody else, with a clock running from the moment you should have known.","open-source-lattice.884b00fa45":"Validating a format is the easy half. Deciding whether a well formed number is actually somebody's account needs the columns beside it and what the record is for. Context identifies the account and purpose; format cannot.","open-source-lattice.750c2096f3":"Why it matters","open-source-lattice.a822692a63":"Every data protection duty begins with knowing which fields hold personal data, and for a system that learns, that question is asked twice: once of what goes in at decision time, and once of what it was trained on. The second is where organisations discover they cannot answer, because the training set was assembled before anybody was asking.","open-source-lattice.4bc76652a0":"the data into the model","open-source-lattice.e8478f8223":"The obligation follows","open-source-lattice.a860ff50e1":"Asked twice, answered once","open-source-lattice.7ddc5a4040":"Every one of those duties assumes you know which data is personal, including what it learned from","open-source-lattice.6accf75e9f":"EVALUATED, NOT MAPPED","open-source-lattice.167999bc54":"HIGH RISK CATEGORIES","open-source-lattice.10f1694f6c":"PROHIBITED PRACTICES","open-source-lattice.a1c742681c":"The difference from a mapping document is that a mapping document claims a control exists somewhere, and this either ran or it did not. A named rule either admitted the case or refused it, and a refusal carries the owner who can act on it.","open-source-lattice.66798668c8":"Whether you are inside those categories has a determinate answer, and most organisations hold it as an opinion in a spreadsheet. Here it is evaluated against the facts of the case, with the article and version that made the duty apply recorded beside the answer.","open-source-lattice.fab7e71c01":"The guarantee","open-source-lattice.c5ec75fd2a":"The Act classifies before it measures. Some practices are prohibited outright. Some uses are high risk and carry documentation, oversight and record keeping duties that attach before a system goes live, not after an incident and not at the next audit. Article 5 holds the prohibitions and Annex III the high-risk uses, so the boundary is written down before anybody has to argue about it.","open-source-lattice.5b026725f2":"before they are switched on","open-source-lattice.b9f36672a8":"Some systems carry duties","open-source-lattice.07b1441792":"The AI Act does not start with performance","open-source-lattice.b3c2ee4ecc":"The register is worth having only if what is inside it is the actual regulation","open-source-lattice.cf1daf6565":"DIFFABLE QUARTER ON QUARTER","open-source-lattice.0f296fc768":"AN OWNER PER RULE","open-source-lattice.378ab6f25a":"NAMED AND VERSIONED","open-source-lattice.d19db0f58e":"Each rule carries an owner, so there is a named person accountable for it. Each carries a version and an effective date, so a change is an amendment rather than a deployment. Segregation of duties becomes checkable rather than asserted.","open-source-lattice.ad75e5c031":"Governance stops being a property of your architecture and becomes an artefact: a list you can print, circulate for review, hand to an auditor and compare quarter on quarter. It becomes a working record, not a description of one.","open-source-lattice.0ccfcd0de4":"What changes","open-source-lattice.db1f12e534":"Every governing rule becomes a named entry. Consent is one. Cross border transfer is another. Each personal data check is its own, as is each boundary on what software may do alone. An entry also names its effective version, owner and evidence shape, so a product team can see which rules were in force for a decision. A change creates a new address instead of silently mutating yesterday's one; affected cases can be replayed against both.","open-source-lattice.eba2fe67c4":"and somebody accountable","open-source-lattice.ea1e192b4b":"A number, a version,","open-source-lattice.1e8d3f98c4":"The turn","open-source-lattice.ad2cbf02c2":"Give each rule a name and an owner and the whole set becomes something you can hold","open-source-lattice.c1c268c0ce":"NO INVENTORY, NO REVIEW","open-source-lattice.dff3a93c0e":"NO NAME, NO INVENTORY","open-source-lattice.095a0e668d":"NOT THE POLICY DOCUMENT","open-source-lattice.3cf675581a":"It cannot be retired, because nobody can show it is unused. And it cannot be pointed at, so when a regulator asks which rule applied, the answer is a narrative rather than a reference anyone can verify.","open-source-lattice.9587c57298":"A rule without an identity cannot be inventoried, so every review begins with discovery. It cannot be versioned, so a change is a deployment rather than a dated amendment with an approver.","open-source-lattice.5905ea18e1":"The conditions evaluated in production, right now, that decide whether you may use a customer's data. Most organisations cannot produce that list, and the reason is structural rather than careless: those checks are code branches, table rows and configuration values, and none of them has a name. The list a regulator asks for is therefore assembled by hand each time, from whoever happens to remember.","open-source-lattice.fec61e8497":"but the checks themselves","open-source-lattice.05197fcc4b":"Not the policy document","open-source-lattice.18f28c6214":"The question that exposes it","open-source-lattice.f481ae95e8":"There is a simpler test that most organisations fail before any of that matters","open-source-lattice.82c448364a":"THE DECIDING PART SITS OUTSIDE","open-source-lattice.eba58ef414":"APPLIED TO THE FAMILIAR PARTS","open-source-lattice.a747190d9d":"BUILT FOR FIXED BEHAVIOUR","open-source-lattice.cc3178ee9d":"Meanwhile the part that decides sits outside them, governed by a tuning threshold. The framework is intact but aimed at the wrong thing, worse than an obvious gap because it still produces evidence of control.","open-source-lattice.fe36fe33f3":"So the controls get applied to the parts that still look familiar: the rules engine one department bought, the compliance module attached to a platform, the safety filter written after an incident.","open-source-lattice.59891b0f92":"Most governance programmes assume behaviour is decided in advance and written down. That model fits conventional software. It breaks when software selects its own next action, or when the reason for a decision cannot be read from the code that produced it. Lattice treats governing policy as Rules as Code: named, versioned checks that run at the boundary where the decision is made.","open-source-lattice.780a371e43":"the annual review","open-source-lattice.7c24f20107":"Change control, sign off,","open-source-lattice.a38f72e653":"Why the existing framework does not fit","open-source-lattice.72bde9c52e":"Getting a reason is one thing, and where your details went while it was worked out is another","open-source-lattice.69f2c46f23":"AND WHEN IT CHANGES","open-source-lattice.2b55873ea2":"NAMES WHAT FELL SHORT","open-source-lattice.71f8cc71b3":"A REASON IN WORDS","open-source-lattice.986dcc210f":"That is a conversation that ends. The alternative is a complaint, a wait, and an answer from somebody who was not involved and is working it out from what they can find. It leaves you responsible for finding the facts the first answer did not name.","open-source-lattice.64fb74c404":"Because the system had to check a written rule to reach its answer, it knows which condition was not met and can say so. Not that you are not eligible, but which specific thing fell short, by how much, and when it changes.","open-source-lattice.d0f99df519":"The easy half is explaining a decision that was made. The harder half, and the one people actually need, is why something you expected did not happen. Why an option was not offered. Why you did not qualify when you were fairly sure you would. Those are the questions that arrive later by letter, and a summary of the decision never answers them.","open-source-lattice.2461d512f1":"why something did not apply","open-source-lattice.ef40a5c3b4":"It can also tell you","open-source-lattice.91421ab698":"The reason, not just the result","open-source-lattice.90b2233698":"the reason exists at the moment of the decision","open-source-lattice.1b05ef85cc":"a conversation that ends","open-source-lattice.24415d1a73":"the date it changes","open-source-lattice.83e2100333":"the specific thing that fell short","open-source-lattice.a2dd297e3d":"the rule, in ordinary words","open-source-lattice.b259bd57a0":"the answer itself","open-source-lattice.d985c189d4":"on the day","open-source-lattice.d60c654f4d":"What you should be told","open-source-lattice.142924c781":"A system held to written rules does not have that problem. It knows which rule it used, because it had to check the rule before answering. So the reason exists at the moment of the decision rather than being assembled later by people working out what probably happened, and it can be given to you in ordinary words, on the day.","open-source-lattice.5f2f80b843":"Being turned down by a machine is worse than being turned down by a person, and not because the answer is different. It is because there is usually nobody to ask. The refusal arrives complete, with no reason attached, and the route to one is a complaint that takes weeks and reaches somebody who was not there either.","open-source-lattice.ed8d9bd41f":"No, because, is.","open-source-lattice.d40733806c":"A flat no is not an answer.","open-source-lattice.5abdfa9cd6":"The difference","open-source-lattice.b830820f30":"That sounds abstract until you watch one decision go through it","open-source-lattice.d61c7e7f70":"PREVIOUS VERSIONS KEPT","open-source-lattice.a30beaf4e4":"EVERYONE AT ONCE","open-source-lattice.a5fcbd6f06":"ONE SET OF RULES","open-source-lattice.00fdd2cdbd":"When the rules change they change for everybody at once, and the previous version is kept. So it is possible to say what the rules were on a particular day, which matters enormously if you are asking about something from last spring.","open-source-lattice.e49938e6b0":"Written in one place means the same rules reach everyone at the same moment, in every country the system operates in, with no version behaving differently somewhere and no local copy that missed a required update.","open-source-lattice.53861c3ac5":"A system can work an answer out for itself and still be held to rules it cannot argue with. What it may not do at all. What it has to check before acting. What it must be able to show afterwards. Those stay written, in words, in one place.","open-source-lattice.d3e491e5d3":"some things stay written","open-source-lattice.011332adeb":"However clever the rest gets,","open-source-lattice.0da9d07d38":"What this does","open-source-lattice.04ec28249a":"Those decisions used to follow a rule somebody wrote down, and increasingly they do not","open-source-lattice.bb914d44eb":"UNTIL IT GOES AGAINST YOU","open-source-lattice.a20efcff8b":"NO PERSON INVOLVED","open-source-lattice.8af7fe01a4":"FASTER THAN YOU NOTICE","open-source-lattice.2302c46252":"For a long time that was knowable because somebody had written the rule down, though finding it took time. Systems now increasingly work things out for themselves: useful, but harder to question.","open-source-lattice.cdd1446b00":"It stops being right the moment a decision goes against you. Then you want to know what decided, what would have changed it, and how to question the answer before it matters again.","open-source-lattice.0e26bd40f7":"A payment went through. A form was accepted. An application was held back for somebody to look at. Each of those was a decision, made without a person involved, in less time than it takes to blink. None of it was meant to be visible and most of the time that is exactly right. Lattice makes the decision legible when you need to ask: it can name the governing rule, its version and the reason the case took that path. The ordinary flow stays quiet; the explanation is there when the outcome matters.","open-source-lattice.5b25c4a372":"while you were reading this","open-source-lattice.29ca091c1c":"Something decided about you","open-source-lattice.f747dbb955":"compiled once, checkable by anybody","open-source-lattice.02d752187b":"and it answers the same next year","open-source-lattice.9521be9647":"runs on hardware you do not control","open-source-lattice.ced0c1dcaa":"the approximate step marked as such","open-source-lattice.124b51c2c9":"evaluated in one pass","open-source-lattice.1f9bf262ee":"every rule named, owned and versioned","open-source-lattice.b0e1a631d6":"one file","open-source-lattice.aa0a79f6ed":"One register","open-source-lattice.5d4b8376d8":"Which is why the answer can say how they combined, which rule decided, which part was approximate, which nearly held and by how much. And why that answer is the same next year, on different hardware, in front of somebody who has no reason to take your word for it.","open-source-lattice.b06b2918da":"A regulation, a safety limit, a boundary on what software may do alone, a structural requirement, a threshold on a similarity. In most estates those sit in separate systems that were integrated afterwards and reconcile badly. Here they are one register, evaluated together, from one compiled file.","open-source-lattice.30656ce884":"and becomes a register.","open-source-lattice.afcef0819c":"Governance stops being an architecture","open-source-lattice.481d0fc02c":"The whole argument","open-source-lattice.f0256d4fce":"What it does is put every rule that governs a decision somewhere you can point at it","open-source-lattice.2d65137b9c":"NOT FOR HOURLY CHURN","open-source-lattice.a15d9b558d":"CHANGES ARE A BUILD","open-source-lattice.2878f7cc94":"It has a name, version, date, owner and the decisions it touched, so it can be found, challenged and changed with that change dated. For exploratory work, something simpler fits better and we would say so.","open-source-lattice.f28402e23c":"That is the right trade for auditability and the wrong one if your rules change hourly. The gain is simple: a wrong rule is visible, with an owner and version, so the next review can find and correct it.","open-source-lattice.ce075da5bc":"Lattice does not decide what your rules should be and cannot tell you whether they are right. Encoding Article 7 as four conditions is an interpretation of the article, and the interpretation is yours to defend. Compilation is a build step, so changing a rule is a deploy rather than a runtime edit.","open-source-lattice.50b22f0b8b":"It will enforce a wrong rule","open-source-lattice.85f13df7ea":"perfectly","open-source-lattice.089175e2b7":"And it is worth being equally exact about what none of this does","open-source-lattice.a989530399":"735M LOOKUPS A SECOND","open-source-lattice.aa10984005":"6.6 NS STANDARD","open-source-lattice.34b5b7476a":"1.36 NS RESIDENT","open-source-lattice.432f74f037":"Coverage improves with size because the index amortises. Once the repository publishes, the figure is checkable rather than asserted, against the same rule set on hardware you provide.","open-source-lattice.b06d062a22":"Which number a lookup gets depends only on where it stopped: resident, one cache line away, in a compressed block, or following a reference out of line. The four sizes exist so that the common case is the one that stops soonest.","open-source-lattice.5b487a198c":"The measurement","open-source-lattice.a17da16827":"A constraint is stored at one of four sizes chosen by what it needs, from four bytes for a bit test up to variable length for anything carrying structure, with the standard case on a cache line boundary. A hot section holds whatever is actually being evaluated, promoted by how often it is reached.","open-source-lattice.10f3741478":"is where the lookup stopped","open-source-lattice.06e3d8b21c":"1.36 nanoseconds","open-source-lattice.0b835d9e81":"Four numbers, one explanation","open-source-lattice.d2b20391c8":"Handing it over is only useful if it also answers fast enough to sit in the request","open-source-lattice.366a00a60f":"FAILS CLOSED","open-source-lattice.d92c31e612":"RUN IT INDEPENDENTLY","open-source-lattice.1592aa88d1":"HAND IT OVER","open-source-lattice.c7a801d87d":"A system that keeps working after its rules were tampered with is worse than one that stops: it produces answers nobody has reason to question. Files from untrusted origins need a valid signature before loading.","open-source-lattice.8e73f72b82":"Integrity is checked at three levels, and an artefact altered afterwards fails to load rather than answering differently. That failure mode is deliberate. The content, manifest and signature each protect a distinct boundary.","open-source-lattice.873526df31":"A report you compiled, from logs you control, about a system you operate. It may be entirely honest and everybody in the room knows whose account it is. Because the rules compile to a file, you can hand the file over instead. The other side runs it on their own machine against the same input and sees the same answer, or does not.","open-source-lattice.0eee1c440b":"is your account of events","open-source-lattice.9e9215a5b8":"Every assurance you write","open-source-lattice.8365c011fd":"Compiled, not interpreted","open-source-lattice.08c56b8c23":"Routing only helps if the answer is the same tomorrow, and that is the artefact's job","open-source-lattice.7f9a3ce760":"ONE CALL SITE","open-source-lattice.12fa537db0":"ROUTED AUTOMATICALLY","open-source-lattice.d7dc177465":"CLASSIFIED PER PROBLEM","open-source-lattice.89af543a9a":"A learning layer improves that routing from outcomes on problems of the same shape, including whether a solver returned useful evidence promptly. It guides selection while the chosen solver produces the explanation; your call site never changes.","open-source-lattice.1d52966750":"The problem is classified first, its structure examined, then routed to the method that fits it: SAT/SMT, linear and mixed-integer programming, constraint and answer-set programming, or temporal-property checking. That route keeps evidence needed to explain the answer.","open-source-lattice.896b2f37be":"The mechanism","open-source-lattice.e86567dc6a":"It is recognising which family your problem belongs to, finding a library, learning its encoding, integrating it, and then discovering the answer is not reproducible across machines. What remains is not one problem but several kinds, each with its own literature and its own way of failing when you choose wrongly.","open-source-lattice.6cf99807d2":"running the solver","open-source-lattice.9ae99e1cbd":"The hard part was never","open-source-lattice.addfae9158":"Classification, then routing","open-source-lattice.f041a713dd":"Six shapes of answer, and you should not have to know which family your problem is in","open-source-lattice.acf8fdf886":"PLANS WITH SCHEDULES","open-source-lattice.eedea3b0db":"COUNTEREXAMPLES","open-source-lattice.10b1c5b37a":"CERTIFICATES AND ALTERNATIVES","open-source-lattice.a88b342277":"Because the shape follows the question rather than a deployment setting, a caller cannot receive an answer they were not expecting, and cannot ignore the evidence by accident.","open-source-lattice.0c943bd67c":"A verification carries a proof, or the counterexample that broke it. A plan carries steps, a schedule, a cost and a dependency graph. A generation carries candidates and the conditions synthesised from them.","open-source-lattice.1342cb950f":"Ask most engines whether the conditions hold and you get a boolean. Here the answer's shape follows the question. A decision carries an explanation and a confidence in a named fixed-point scale. A selection carries the choice, its objective value, a certificate, and the alternatives it beat, so you can see what it nearly chose.","open-source-lattice.4c34c7dad3":"an outcome, with evidence","open-source-lattice.bcec04940d":"Not true or false","open-source-lattice.9fa56bd0c4":"What a solve returns","open-source-lattice.1573de5590":"Four reasons to say no, and every one of them is a different shape of answer","open-source-lattice.783ed8cc1e":"HANDLEABLE","open-source-lattice.ad9d152f2e":"NAMES THE MISSING PREMISE","open-source-lattice.847680b515":"TYPED FAILURE REASONS","open-source-lattice.b787b93480":"That difference decides whether a system can be automated around or needs a person every time, and it is invisible when every failure looks like an empty list to resolve. A typed reason is what lets the retry be written once.","open-source-lattice.9c1608c86c":"Because the reason has a shape rather than being a message, it can be acted on. A missing premise can trigger a fetch and a retry. A violated constraint cannot and should not.","open-source-lattice.d858e3117c":"A wrong rule, missing data and a misspelled query all return the same empty list, and distinguishing them is most of the debugging. When a query does not hold here, the answer says why: no matching facts, no applicable rules, a constraint violated and named, a named fixed-point confidence short of its stated threshold, or a rule that was reachable with one premise absent and that premise identified.","open-source-lattice.b4bad90e2e":"tells you nothing","open-source-lattice.4c002ea241":"An empty result set","open-source-lattice.fb69cd9e71":"Accountability when the answer is no","open-source-lattice.d6c58c4bd0":"Knowing which step was a guess only helps if the engine also says why something failed","open-source-lattice.41e2a01b9a":"ONE CHAIN","open-source-lattice.1cd6c931f6":"ATTRIBUTED PER STEP","open-source-lattice.35c38e0a78":"SIMILARITY AND DEDUCTION","open-source-lattice.923bc4388f":"Governance needs exactly that distinction. A decision resting on a resemblance is a different thing to defend than one resting on a rule, and you cannot weigh it unless the record says which.","open-source-lattice.e9f85ae7bf":"Lattice keeps attribution in the final record. Every step in a derivation is tagged by where it came from, whether a fact was asserted, a rule fired, a similarity matched, or the solver established it.","open-source-lattice.f626b7a7da":"Under the surface","open-source-lattice.7b967bccd5":"Symbolic reasoning is exact and brittle: it cannot match what it was not told. Retrieval by similarity is tolerant and opaque: it finds the relevant thing and cannot justify it. Systems combining them almost always lose track of which half produced which part of the conclusion. Lattice tags each derivation step with its source, whether an asserted fact, a fired rule, a similarity match or a solver result. A reviewer can challenge one source without treating the whole chain as equally uncertain, and a replay can recompute the affected step.","open-source-lattice.15b9dd8f55":"and from resemblance","open-source-lattice.0cdc6c6005":"Built from reasoning","open-source-lattice.8667a13a70":"The question nobody else answers","open-source-lattice.f53ebcd00e":"A boundary is only worth as much as the record it leaves behind","open-source-lattice.e37ae0deae":"CHECKED IN ONE PASS","open-source-lattice.9d1673fb96":"SAME REGISTER","open-source-lattice.a8e2327173":"ENFORCED, NOT REQUESTED","open-source-lattice.518909b817":"Checked in the same pass, it produces the same evidence as a compliance rule at the decisive boundary. It is not a separate mechanism bolted on for agents, which would be one more thing nobody has reviewed.","open-source-lattice.5d6086fe63":"So the boundary is expressed as rules in the same register as everything else: how often it may run, what it may reach, how much work it may do before it stops, and it is enforced somewhere the software cannot reach.","open-source-lattice.b2e46e69ae":"Software that chooses its own next action was reviewed by nobody at the moment it acts, and that is the point of it. Which means every boundary written as an instruction, do not access that, do not call this, stop after ten attempts, is a request addressed to something with discretion. The registered boundary makes those limits executable: a call budget, destination set and stop condition travel with the decision. An agent can be capable without being sovereign because the check happens outside its choice.","open-source-lattice.17100c3523":"discretion can decline it","open-source-lattice.cdeb3e1bc0":"An instruction is a request","open-source-lattice.15b65e809d":"The control that did not exist before","open-source-lattice.64d0046719":"four domains, evaluated together, explained once","open-source-lattice.dd18bdba08":"declined, and it can name which rule","open-source-lattice.f6a2ce230f":"tool reach inside its limit","open-source-lattice.7be510067f":"transfer mechanism verified","open-source-lattice.3b55458b34":"consent checked against the article","open-source-lattice.ef77ca15a5":"personal data resolved","open-source-lattice.f46e03d644":"one outcome","open-source-lattice.637c686512":"In one register it is a property of the answer. The outcome names the rule that decided, the ones that held, and the one that nearly held with how far short it fell. Not because four logs were correlated afterwards, but because the four were evaluated together and the explanation was produced with the decision.","open-source-lattice.32e964e02d":"A customer is declined. Behind that sit a personal data determination, a consent check, a transfer restriction and a limit on what the software could do alone. Four rules from four domains, all of which had to hold. Spread across four systems, working out which one actually declined the customer is an investigation, and the answer arrives days later with caveats attached.","open-source-lattice.5b53a91fc8":"Which one, and can you say?","open-source-lattice.79a46f944d":"Four rules decided this.","open-source-lattice.a6607e1e2c":"Why these belong together","open-source-lattice.1746548b7f":"Detection settles what is personal, and the next question is what may act on it alone","open-source-lattice.8a30672926":"BEFORE ANYTHING ACTS","open-source-lattice.5b0851fc8c":"CONTEXT DECIDES","open-source-lattice.530a44dc7b":"FORMAT IS THE EASY HALF","open-source-lattice.2e0333d9d8":"Deciding whether a well formed number is actually somebody’s account needs the columns beside it, the values in them and what the record is for. That judgement is the product, which is why candidates are proposed generously and then eliminated.","open-source-lattice.17e89fc54e":"Validating the format is the easy half: IBANs by mod-97 across thirty four country lengths, cards by Luhn, VAT numbers by rules that differ per member state. It identifies a plausible number, not who it belongs to or whether this record may use it.","open-source-lattice.6c3a5918f1":"It passes the checksum. Redact it and you have quietly corrupted a dataset somebody will rely on next quarter. Leave it, if you were wrong, and you have a breach you will hear about from someone else. This is the actual problem in data protection, and better patterns do not solve it.","open-source-lattice.7622ec8ff2":"in a column called ref","open-source-lattice.bcd24a0240":"A nine digit number","open-source-lattice.c7872334a9":"Personal data as a governed domain","open-source-lattice.e96bbbcb77":"Every one of those rules assumes you already know which data is personal, and that is harder","open-source-lattice.2948027321":"ALL FOUR CONDITIONS","open-source-lattice.18676ecc1a":"Cross-border transfer holds the Chapter V mechanisms. eIDAS holds trust-service status. Each mechanism is named, versioned and tested against the facts in the case before it is applied. That is a control, not a claim that one exists somewhere.","open-source-lattice.b91c6572a9":"Both are executable checks, and the data-protection rules that follow work the same way. Consent under Article 7 must be explicit, withdrawable, documented and granular; if one condition fails, a record marked yes may be worthless until it is examined.","open-source-lattice.4492f5502b":"The EU AI Act does not begin with how well a system performs. It begins with whether it may operate. Article 5 lists practices prohibited outright. Annex III lists uses that are high risk and carry documentation, oversight and record keeping duties that attach before anything goes live. The register can evaluate that boundary before a model or workflow acts, and record the article, jurisdiction, version and facts that made the duty apply. Updating one named rule then creates a replayable change rather than a compliance note no runtime reads. Consent, transfer and trust-service mechanisms remain separate versioned entries, so a failure names the owner who can remediate it and a permitted case carries its rule set into the record.","open-source-lattice.ba274bdd55":"is not allowed to make","open-source-lattice.a3024ca99f":"Some decisions a system","open-source-lattice.65a445490d":"Before performance, before deployment","open-source-lattice.3753345851":"The same machinery holds regulation, and that is where most of the work went","open-source-lattice.e7af6fd001":"SAME EVIDENCE","open-source-lattice.3776cc26af":"ENFORCED, NOT REVIEWED","open-source-lattice.f1a6749c6a":"RULES ABOUT STRUCTURE","open-source-lattice.bb5473c305":"Their sophistication matters less than the fact that they sit beside a consent rule in the same register, carry a version, and answer the same question when something goes wrong: which rule decided, and when did it last change?","open-source-lattice.ad59e26a14":"The checks themselves are the kind a compiler makes: single assignment against a dominance tree, grammar conformance, and type conformance including subtyping. Together they establish one unambiguous program before evaluation begins.","open-source-lattice.1aae6fd41e":"Governance is not only about data. This service must not call that one. This value is assigned in exactly one place. This input must match this shape before anything acts on it. Those are rules about how your systems are built, they matter as much as a consent rule, and they usually live in a wiki page last edited two years ago.","open-source-lattice.83a5dbaa92":"with nothing enforcing them","open-source-lattice.dda1855b59":"Rules about your systems","open-source-lattice.daa73a790c":"Structure as a governed domain","open-source-lattice.b3c54d2a8d":"A register is bookkeeping until you look at what somebody encoded into it","open-source-lattice.fff6bff60a":"extensible, and not open ended","open-source-lattice.4d8ac7cc65":"every rule named and owned","open-source-lattice.f92eb3572d":"Where the governed thing is a judgement rather than a fact.","open-source-lattice.3bf1eca830":"Similarity","open-source-lattice.a73a5f8352":"Verification a compiler would recognise, applied to your systems.","open-source-lattice.9482c5d5bf":"Structure","open-source-lattice.4ba02b5fac":"What software may do alone: how often, what it may reach.","open-source-lattice.2ebc62a723":"Autonomous action","open-source-lattice.d89fa3dbfb":"Finding it reliably, before anything else runs.","open-source-lattice.b8ac03697d":"Personal data","open-source-lattice.854f17fa5f":"GDPR, the EU AI Act, eIDAS, cross border transfer.","open-source-lattice.0fd2d3dfbc":"Regulation","open-source-lattice.270e365bd3":"grouped by what is governed","open-source-lattice.6bf22df52d":"The register","open-source-lattice.39e18fc582":"YOU CAN POINT AT ONE","open-source-lattice.06d55361b1":"VERSIONED","open-source-lattice.bd5302381a":"OWNED","open-source-lattice.eb94216cda":"NAMED","open-source-lattice.58eb93e4bf":"Lattice gives every governing rule a name, a version, an owner and a place in a register you can print, hand to an auditor, and compare against last quarter's. Everything else on this page depends on that one move.","open-source-lattice.7fbe72615c":"That was survivable while software did what it was told, because the behaviour was written down somewhere even if finding it took a week. It stops being survivable the moment the software is choosing.","open-source-lattice.642743d70e":"Ask which rule declined an application last March and the honest answer is a search. The condition that decided is a branch in a function, a row in a table, or a threshold somebody set while tuning a model. It runs correctly and it answers to no name. Lattice gives that condition a versioned entry with an owner and a checksum, then keeps the older version addressable. A replay can identify the exact premises that were in force instead of searching every service for a clue. The register is the thing an auditor can be handed, and the same entry still answers the question next year.","open-source-lattice.21f5f2dcca":"and nobody can name it","open-source-lattice.16a9fc35c3":"One rule declined them","open-source-lattice.e8c513822c":"Where the rules actually live","open-source-lattice.a0fb821bda":"Purpose","open-source-lattice.75372d20cd":"AI governance engine","open-source-lattice.546a867824":"Lattice publishes in the third round of Dweve's foundation release programme. Read the whole thing before you commit. Every rule that governs a decision gets a name, a version, an owner and a place in a register you can print. Replay decisions you have already made, and see where it disagrees with you.","open-source-lattice.c24b818aa7":"WRONG RULES BECOME VISIBLE","open-source-lattice.ddfbed4cec":"ENFORCES, NEVER AUTHORS","open-source-lattice.e1852d2044":"READ IT FIRST","open-source-lattice.007ea5561d":"NOT A RECORD","open-source-lattice.99e8a2a70b":"AN OWNER EACH","open-source-lattice.b93e9edec0":"PASS, BLOCK, OR ACTION","open-source-lattice.90a1784272":"BEFORE USE","open-source-lattice.b6d058e990":"CHECKSUMMED","open-source-lattice.16247a5271":"HIGH RISK","open-source-lattice.fa499700de":"PROHIBITED","open-source-lattice.db17064d4a":"DIFFABLE EACH QUARTER","open-source-lattice.7b5eff5f65":"NO REVIEW","open-source-lattice.bc551f1da0":"NOT THE POLICY","open-source-lattice.161551f6df":"THE DECIDER SITS OUTSIDE","open-source-lattice.36ab3ee536":"AIMED AT THE FAMILIAR","open-source-lattice.8958c6e866":"BUILT FOR FIXED RULES","open-source-lattice.6cec060ae9":"AND WHEN","open-source-lattice.d8416ce1ac":"A REASON, IN WORDS","open-source-lattice.e5fff0c106":"UNTIL IT GOES WRONG","open-source-lattice.fea79c336d":"NOT FOR CHURN","open-source-lattice.4995369dc9":"PLANS AND SCHEDULES","open-source-lattice.81a360f604":"CERTIFICATES","open-source-lattice.031139e07c":"NAMES THE PREMISE","open-source-lattice.594c96ac59":"TYPED REASONS","open-source-lattice.b9e2e5ddab":"BEFORE IT ACTS","open-source-lattice.9c1ce0d2dc":"ALL FOUR, PER RECORD","open-source-lattice.1fb5bdaaac":"ENFORCED","open-source-lattice.84200c2666":"STRUCTURAL RULES","open-source-lattice.19b91f99e3":"NO PERSON","open-source-lattice.d5fc086645":"FASTER THAN YOU SEE","open-source-lattice.8c9a9d52ea":"WRONG RULES GO VISIBLE","open-source-lattice.2e6cdf9954":"THE DECIDER IS OUTSIDE","open-source-lattice.7782416d4c":"SIMILARITY AND RULES","open-source-lattice.e897d5f914":"WRONG RULES SHOW UP","open-source-lattice.0fb806be45":"What you get is what was missing, the answer, the reason, and somebody answerable","open-source-lattice.e1b1aacb1d":"DOES NOT JUDGE THEM","open-source-lattice.b1c8c9d1ec":"APPLIES RULES","open-source-lattice.6287ee19bf":"An unfair decision from a system nobody can inspect cannot be. Whether the rules are right stays a question for people, and one you are entitled to raise. This makes sure there is something to raise it about.","open-source-lattice.a4faccc7de":"That record is the point. An unfair rule that is written down and applied the same way to everybody can be found, argued with and changed through a proper record, and there is a named person to argue with.","open-source-lattice.eb0142e7a8":"This applies whatever rules it is given, consistently, to everyone. If those rules are unfair it will apply them unfairly to everyone, consistently, and produce a clear record of having done so. Consistency is therefore evidence about execution, not a verdict about the policy. The owner can inspect the named rule, change it deliberately and see which decisions the new version would alter instead of mistaking a clean log for a fair outcome.","open-source-lattice.371e1e94cf":"it does not judge them","open-source-lattice.320f6fb671":"It follows the rules exactly","open-source-lattice.60893a6564":"Being straight with you","open-source-lattice.e5385399b3":"And it is worth being straight about what none of this fixes","open-source-lattice.e14f956c5f":"THIRD RELEASE ROUND","open-source-lattice.30328ff62c":"EVERY RULE HAS AN OWNER","open-source-lattice.61fba4c819":"The people whose job is checking these things, regulators, researchers and journalists, will not need an introduction to do it. Once Lattice publishes, they can examine how it decides, against the same rules and the same recorded owner rather than a description of them.","open-source-lattice.536d1b82b6":"That makes an appeal a real thing. Whoever looks into your case can run the same rules against the same facts and get the same answer, rather than an approximation of what probably happened.","open-source-lattice.49d29d8499":"Every rule here belongs to somebody: a named person in the organisation, recorded against it, with the date it was last reviewed. So the two answers people usually get, that the system decided and that this is our policy, stop being the end of the conversation. The name is not there to blame anybody; it is there so that there is somebody to ask.","open-source-lattice.bb44ea6a0f":"but a person with a name","open-source-lattice.74d838c987":"Not the system that decided","open-source-lattice.80e7ca034d":"Accountability","open-source-lattice.c0e1d50583":"Which leaves the question people ask last and worry about first, is anyone answerable","open-source-lattice.f994356760":"NO OUTSIDE COMPANY","open-source-lattice.e45c09a812":"NOTHING IS SENT AWAY","open-source-lattice.7717fa7908":"Which is both why it is fast and why nothing has to leave. There is no outside company that has to be working, trustworthy, or still in business for you to get an answer when you need it.","open-source-lattice.a0e681a538":"This works the other way round. The rules are brought to your details rather than your details being sent to the rules. The check happens on the machine already holding them, and nothing about you is copied out to make it possible.","open-source-lattice.987004a9a2":"Many systems answer a question about you by sending your details somewhere else and waiting for a reply. Your information travelled, to a company you did not choose, possibly to a country you do not know about, and it is now somewhere you cannot see. A local rule engine does not make a decision fair by itself, but it keeps the inputs, rule version and explanation within a boundary you can inspect. You can ask what was used without first asking a supplier to reconstruct the request.","open-source-lattice.91dfe4c890":"where they already are","open-source-lattice.5337ddb4f4":"Your details stay","open-source-lattice.39e905eda8":"Where your information goes","open-source-lattice.43044c4524":"Step four is the one that matters, and it is the one most systems get wrong","open-source-lattice.dfbc55a45b":"IT ANSWERS","open-source-lattice.1c30545feb":"IT CHECKS FIRST","open-source-lattice.249381bbce":"And rather than afterwards, when somebody reviews a sample. Move through the steps at your own pace. There is no jargon and nothing you need to know beforehand to follow the result.","open-source-lattice.b9ac605bde":"Nothing happens to the money until the check is done. That order matters more than it sounds, because a check that runs after the money has moved is a report rather than a control. It comes first every time, rather than whenever there is room for it.","open-source-lattice.01c08313dc":"It is easier to trust something after watching it work. So here is one everyday moment, a small top up to a pension, taken a step at a time. You ask. It checks the rules. It answers. You can ask why. The answer carries the same rule reference a reviewer would see, so an exception is a named difference rather than a mysterious change in tone. If a fact is missing, the system can say that instead of quietly guessing.","open-source-lattice.52e2ddae1c":"taken slowly","open-source-lattice.b7a87c8307":"One ordinary moment","open-source-lattice.3daf499920":"The answer is not to go back to calculators, it is to write down what may and may not happen","open-source-lattice.344f75f594":"WORKING IT OUT","open-source-lattice.93694ab082":"FOLLOWING A RULE","open-source-lattice.efb65964b1":"That may be entirely correct and it is no use at all to somebody who wants to know what they should have done differently, or whether the answer would change tomorrow. Neither question has a line to point at either.","open-source-lattice.af3204de36":"It is also why they are hard to question. There is no line to point at, because there was never a line. Ask why, and the honest answer is often that your case resembled other cases.","open-source-lattice.9ee212dcd3":"A machine that follows a written rule has been deciding things about people for fifty years and nobody objects, because you can read the rule. Newer systems are different. They are shown a great many past examples and produce an answer that resembles them, which is why they cope with situations nobody anticipated.","open-source-lattice.67b7be6fab":"newer systems do not","open-source-lattice.d395a367c1":"A calculator follows a rule","open-source-lattice.7e4b91991b":"What changed","open-source-lattice.1d21a574bc":"Ready to review","open-source-lattice.40c39e5b7a":"Audience","open-source-lattice.77e7a3ad02":"Focus","open-source-lattice.e6a31c7e62":"Technical","open-source-lattice.a8f357bc92":"Personal","open-source-lattice.ee9d4d6a4c":"Business","open-source-lattice.banner.engine.eyebrow":"The runtime boundary","open-source-lattice.banner.engine.lead":"The agent chooses the action.","open-source-lattice.banner.engine.accent":"The rule decides whether it runs.","open-source-lattice.banner.engine.body":"An instruction inside a model can be ignored by the same model. An enforceable boundary sits outside that choice and evaluates the proposed action before the tool is called.","open-source-lattice.banner.engine.detail":"The runtime names the action, loads the applicable rule version, evaluates the known facts and records the result. A refusal therefore has a rule, an input and a place in the execution trail.","open-source-lattice.banner.engine.instrument":"One guarded tool call","open-source-lattice.banner.engine.tag":"BEFORE EXECUTION","open-source-lattice.banner.engine.item1":"Action proposed","open-source-lattice.banner.engine.item2":"Applicable rules loaded","open-source-lattice.banner.engine.item3":"Boundary evaluated","open-source-lattice.banner.engine.item4":"Decision added to the trail","open-source-lattice.banner.engine.status":"RECORDED","open-source-lattice.banner.engine.verdictLabel":"Runtime verdict","open-source-lattice.banner.engine.verdict":"the tool runs only after the external rule check passes","open-source-lattice.banner.engine.footer":"A hard boundary is useful only when a failed check explains what stopped the action.","open-source-lattice.banner.proof.eyebrow":"The explanation path","open-source-lattice.banner.proof.lead":"One answer can name","open-source-lattice.banner.proof.accent":"every rule behind it.","open-source-lattice.banner.proof.body":"A decision may combine a legal prohibition, a privacy condition, a solver result and a limit on autonomous action. Flattening those into one score hides which part actually settled the case.","open-source-lattice.banner.proof.detail":"Lattice keeps the source and outcome of each step. The final answer can point back through the route, so a reviewer sees which rule fired and which checks merely supplied context.","open-source-lattice.banner.proof.instrument":"Worked decision route","open-source-lattice.banner.proof.tag":"ATTRIBUTED","open-source-lattice.banner.proof.item1":"Legal rule","open-source-lattice.banner.proof.item2":"Privacy condition","open-source-lattice.banner.proof.item3":"Solver result","open-source-lattice.banner.proof.item4":"Typed outcome","open-source-lattice.banner.proof.status":"EXPLAINED","open-source-lattice.banner.proof.verdictLabel":"Evidence path","open-source-lattice.banner.proof.verdict":"the final outcome retains the route that produced it","open-source-lattice.banner.proof.footer":"The route explains the answer. The signed artefact keeps that explanation stable later.","open-source-lattice.banner.plain.eyebrow":"What you can ask for","open-source-lattice.banner.plain.lead":"A reason you can point to.","open-source-lattice.banner.plain.accent":"A person who owns it.","open-source-lattice.banner.plain.body":"A useful explanation says more than approved or refused. It names the rule, the facts used in your case and the version that applied when the decision was made.","open-source-lattice.banner.plain.detail":"The record also names who owns the rule. That gives an appeal somewhere to go and lets another reviewer run the same check against the same facts instead of reconstructing the answer from memory.","open-source-lattice.banner.plain.instrument":"Decision receipt","open-source-lattice.banner.plain.tag":"READABLE","open-source-lattice.banner.plain.item1":"Your question","open-source-lattice.banner.plain.item2":"Rule and version","open-source-lattice.banner.plain.item3":"Facts used","open-source-lattice.banner.plain.item4":"Named rule owner","open-source-lattice.banner.plain.status":"ANSWERABLE","open-source-lattice.banner.plain.verdictLabel":"What the receipt changes","open-source-lattice.banner.plain.verdict":"you can challenge a specific rule with a specific owner","open-source-lattice.banner.plain.footer":"The next question is where your details went while that check was made.","open-source-lattice.banner.governance.eyebrow":"From register to control","open-source-lattice.banner.governance.lead":"A policy in a register","open-source-lattice.banner.governance.accent":"must reach the runtime.","open-source-lattice.banner.governance.body":"An inventory shows that a rule exists. It does not show that the rule stopped a prohibited action or required a check before a high-risk decision went ahead.","open-source-lattice.banner.governance.detail":"The enforceable record connects the named owner and approved version to an obligation the runtime evaluates. The same entry later shows which version was in force for the decision under review.","open-source-lattice.banner.governance.instrument":"Control admission check","open-source-lattice.banner.governance.tag":"IN FORCE","open-source-lattice.banner.governance.item1":"Owner named","open-source-lattice.banner.governance.item2":"Version approved","open-source-lattice.banner.governance.item3":"Obligation encoded","open-source-lattice.banner.governance.item4":"Runtime gate active","open-source-lattice.banner.governance.status":"ENFORCED","open-source-lattice.banner.governance.verdictLabel":"Control state","open-source-lattice.banner.governance.verdict":"the approved rule is both reviewable and active in execution","open-source-lattice.banner.governance.footer":"The next test is whether legal duties and personal-data conditions resolve against a real case.","open-source-lattice.banner.operations.eyebrow":"Local decision, portable proof","open-source-lattice.banner.operations.lead":"Keep the decision local.","open-source-lattice.banner.operations.accent":"Hand the proof over.","open-source-lattice.banner.operations.body":"Running the check inside your boundary removes a standing dependency on an outside decision service. Review still needs a bounded artefact that another party can inspect without entering that boundary.","open-source-lattice.banner.operations.detail":"The handover carries the rule version, the relevant facts, the typed outcome and the attribution chain. A reviewer can replay the decision elsewhere while the source data and live systems stay where they belong.","open-source-lattice.banner.operations.instrument":"Review handover","open-source-lattice.banner.operations.tag":"PORTABLE","open-source-lattice.banner.operations.item1":"Local evaluation","open-source-lattice.banner.operations.item2":"Rule version attached","open-source-lattice.banner.operations.item3":"Decision replayed","open-source-lattice.banner.operations.item4":"Reviewer reaches the same result","open-source-lattice.banner.operations.status":"CHECKED","open-source-lattice.banner.operations.verdictLabel":"Sovereignty result","open-source-lattice.banner.operations.verdict":"the evidence travels without turning the live system into a supplier service","open-source-lattice.banner.operations.footer":"The final operational question is how to introduce that boundary without interrupting existing decisions.","open-source-lattice.728880d6b3":"and bit-exact answers","open-source-lattice.close.panelTag":"LATTICE","open-source-lattice.close.panelFoot":"Publication is planned in fortnightly rounds. The repository and its documentation go live together.","oss-lattice-accountability.0d7093d005":"enforces, does not author","oss-lattice-accountability.49fcde1a52":"Only one of them can fix it.","oss-lattice-accountability.431ee2d70c":"Neither column makes the rule right.","oss-lattice-accountability.bda9d7b4e1":"somewhere between hundreds and thousands","oss-lattice-accountability.7c2bce5c76":"Without one","oss-lattice-accountability.b9666a22df":"3,180 decisions since March","oss-lattice-accountability.40e228b5c0":"With a register","oss-lattice-accountability.56058bd819":"illustrative, visible not arguable","oss-lattice-accountability.8928eb06ad":"equally wrong in both","oss-lattice-accountability.92beb33972":"One wrong rule, twice","oss-lattice-accountability.88b7b5fe75":"Changed in a deployment, with no amendment anybody can point to.","oss-lattice-accountability.d93d3566ab":"Correction undated","oss-lattice-accountability.586e0d7b52":"Nobody can say which decisions it touched, so the answer is an estimate.","oss-lattice-accountability.c4def8004b":"Scope unknown","oss-lattice-accountability.177a260350":"Three teams touched it. None of them consider it theirs.","oss-lattice-accountability.83bff6b457":"Owner unclear","oss-lattice-accountability.7930534c1a":"Which is to say, found by a complaint, and after the fact.","oss-lattice-accountability.d4c0a984aa":"Found by a customer","oss-lattice-accountability.f4ad3296ed":"The amendment is dated and approved, and the previous version is kept.","oss-lattice-accountability.aef0106389":"Corrected","oss-lattice-accountability.32119a9e14":"It carries a decision list, so the blast radius is a number rather than a fear.","oss-lattice-accountability.24bdaf83e4":"Scoped","oss-lattice-accountability.8dd8a91aa3":"It has an owner, so there is a named person who answers for it.","oss-lattice-accountability.c67dee31d8":"Attributed","oss-lattice-accountability.9789a7943a":"It appears in the register, so it was found in a review rather than by a customer.","oss-lattice-accountability.bbba84135d":"Found","oss-lattice-act-duties.f93e4008f0":"or it did not","oss-lattice-act-duties.b9c583f6d0":"either it ran","oss-lattice-act-duties.1ef1fa1ee7":"not after an incident","oss-lattice-act-duties.24f96093f4":"Duties that attach first","oss-lattice-act-duties.05b177aa4a":"Before go live","oss-lattice-act-duties.ffb893f47a":"Named, with the authority to stop it, recorded as a condition.","oss-lattice-act-duties.b4d3a3bdc5":"Human oversight","oss-lattice-act-duties.e661104281":"Required to exist before the system may run at all.","oss-lattice-act-duties.9e9cf3221a":"Documentation","oss-lattice-act-duties.d2497597c8":"Annex III categories, checked against what the system does.","oss-lattice-act-duties.667c4baacc":"High risk","oss-lattice-act-duties.3fda9df085":"Practices the Act rules out, detected rather than declared.","oss-lattice-act-duties.030b0ae196":"Prohibited","oss-lattice-adopt-steps.b84ee6508d":"until you decide it is","oss-lattice-adopt-steps.7433362c80":"nothing is switched over","oss-lattice-adopt-steps.af1807fca1":"Low risk","oss-lattice-adopt-steps.f5c2cef0ca":"each one reversible","oss-lattice-adopt-steps.3173c4bbc5":"Four steps in","oss-lattice-adopt-steps.dbf430ebf6":"Live traffic, recording only where it disagrees with you.","oss-lattice-adopt-steps.5ffd4de11f":"Run alongside","oss-lattice-adopt-steps.10998af1be":"One decision, off to the side, acting on nothing.","oss-lattice-adopt-steps.3c769675cd":"Pilot","oss-lattice-adopt-steps.d03615e666":"Run decisions you have already made and compare the answers.","oss-lattice-adopt-steps.c0f85d6679":"Replay","oss-lattice-adopt-steps.3c1c4e7ea3":"When Lattice publishes in the third round, read the whole thing. No call, no closed box.","oss-lattice-adopt-steps.90b1fdef30":"Read it","oss-lattice-agent-boundary.f7e2c6d236":"enforced, not requested","oss-lattice-agent-boundary.5e8b23bc34":"It was issued one year, for eight seconds.","oss-lattice-agent-boundary.bdbe8914a8":"It asked for the estate.","oss-lattice-agent-boundary.6ceba2a1ac":"a system with discretion never saw the wider request","oss-lattice-agent-boundary.d49c9bc529":"Nothing here was asked of the model. The pass was cut before the call ran, by the same\n          register that holds the consent rules, and","oss-lattice-agent-boundary.123a7f2fcc":"Platform","oss-lattice-agent-boundary.2f272d950b":"tool reach v3","oss-lattice-agent-boundary.4916ed9409":"enforced by","oss-lattice-agent-boundary.d794254290":"Pass issued","oss-lattice-agent-boundary.67e101cddc":"what the register issued","oss-lattice-agent-boundary.43b11ec486":"Granted","oss-lattice-agent-boundary.9fa98b2c25":"what the agent asked for","oss-lattice-agent-boundary.c26bf60fed":"Requested","oss-lattice-agent-boundary.891aa78341":"issued in process","oss-lattice-agent-boundary.399d9d16f1":"four of five refused","oss-lattice-agent-boundary.937dc2ece7":"One tool call, at the boundary","oss-lattice-agent-boundary.d7bef4f233":"8 s","oss-lattice-agent-boundary.7ea101da72":"run time","oss-lattice-agent-boundary.181c2f4376":"one year","oss-lattice-agent-boundary.f1f2639ab2":"read /finance/ledgers/2026/*","oss-lattice-agent-boundary.bdceacb8ea":"40 s","oss-lattice-agent-boundary.137863c471":"any host","oss-lattice-agent-boundary.5159b44cec":"network egress","oss-lattice-agent-boundary.6fd9bf498c":"call payments.execute","oss-lattice-agent-boundary.bd8a20e39c":"all years","oss-lattice-agent-boundary.034c409993":"read /finance/ledgers/*","oss-lattice-artefact-powers.edbd35eab4":"a file is not","oss-lattice-artefact-powers.85963459b4":"an endpoint is your account","oss-lattice-artefact-powers.c6fe330e04":"Artefact","oss-lattice-artefact-powers.d96934ed89":"What a file can do","oss-lattice-artefact-powers.39d5ace751":"that an endpoint cannot","oss-lattice-artefact-powers.6c6d75b70e":"Altered after the fact, it does not load at all.","oss-lattice-artefact-powers.3eb80c1e86":"Refuse","oss-lattice-artefact-powers.1abf945944":"Diffed against last quarter's to show what changed and when.","oss-lattice-artefact-powers.44da169fbf":"Be compared","oss-lattice-artefact-powers.048b8d66a8":"Run by somebody else, without access to your systems.","oss-lattice-artefact-powers.8982aa012b":"Be handed over","oss-lattice-artefact-powers.1cffc3ac01":"Stored with the decision it made, not merely referenced by it.","oss-lattice-artefact-powers.de66d15c0e":"Be archived","oss-lattice-assembled.8de17c36cc":"and nobody budgets for it","oss-lattice-assembled.ab499378af":"four days, every time","oss-lattice-assembled.acf6368bfa":"the March decline, reconstructed","oss-lattice-assembled.04061c8051":"What gets assembled instead","oss-lattice-assembled.2e159b4438":"Observed","oss-lattice-assembled.a9a868916c":"If it still exists, and it usually does not.","oss-lattice-assembled.36280b3e16":"A spreadsheet","oss-lattice-assembled.5c35675664":"Asked what they remember. One has since left.","oss-lattice-assembled.f5b04b9dc7":"Two people who were there","oss-lattice-assembled.4341e849b8":"Read to guess which version was live at the time.","oss-lattice-assembled.f67621a63e":"A deployment log","oss-lattice-assembled.5cacbaef45":"Pulled from where they live now, not where they lived then.","oss-lattice-assembled.29d088d96e":"The current rules","oss-lattice-attribution.027fdb8130":"before you defend it","oss-lattice-attribution.0caf0af6e8":"the chain says which is which","oss-lattice-attribution.7c880f7f8d":"Per step","oss-lattice-attribution.c85232ec5b":"in the derivation","oss-lattice-attribution.158885eb4c":"How each step is attributed","oss-lattice-attribution.bdf92657af":"Established by the solver rather than by chaining.","oss-lattice-attribution.e1d3550543":"Solved","oss-lattice-attribution.e9fc9ad014":"Matched by resemblance rather than proved. Marked as such.","oss-lattice-attribution.3bf1eca830":"Similarity","oss-lattice-attribution.ac2b8e98eb":"Followed from a rule, and the rule is named.","oss-lattice-attribution.78e1790e29":"Rule","oss-lattice-attribution.5c2030b2a5":"Stated directly. Nothing derived it.","oss-lattice-attribution.95742cac43":"Asserted","oss-lattice-because-banner.4304d56f5b":"You will pass this rule\n            on 14 September.","oss-lattice-because-banner.caeb696f2f":"Yours has been open four months.","oss-lattice-because-banner.b5939ecf48":"Not approved, because an account needs six months before we can raise a limit without\n            somebody reviewing it.","oss-lattice-because-banner.6009a5a546":"what you should get","oss-lattice-because-banner.55acf372d0":"We are unable to approve your application at this time.","oss-lattice-because-banner.e7e8608deb":"what usually arrives","oss-lattice-because-banner.b22f9fda28":"A system held to written rules does not have that problem. It knows which rule it used,\n          because it had to check the rule before answering. So the reason exists at the moment of\n          the decision, and it can be given to you in ordinary words, on the day.","oss-lattice-because-banner.dee1575920":"Being turned down by a machine is worse than being turned down by a person, and not\n          because the answer is different. It is because there is usually nobody to ask. The\n          refusal arrives complete, with no reason attached, and the route to one is a complaint\n          that takes weeks and reaches somebody who was not there either.","oss-lattice-because-banner.ed8d9bd41f":"No, because, is.","oss-lattice-because-banner.d40733806c":"A flat no is not an answer.","oss-lattice-because-banner.5abdfa9cd6":"The difference","oss-lattice-business-glyph.9a11000001":"Latency","oss-lattice-business-glyph.9a11000002":"Determinism","oss-lattice-business-glyph.9a11000003":"Bit-exact","oss-lattice-business-glyph.9a11000004":"Runtime","oss-lattice-business-glyph.9a11000005":"Decision path","oss-lattice-business-glyph.9a11000006":"No network hop","oss-lattice-business-glyph.eb4e6ac270":"stay together","oss-lattice-business-glyph.6b5eb5323e":"Rules and answers","oss-lattice-business-glyph.d665b83285":"Compliance, pricing, access, fraud","oss-lattice-business-glyph.870c4d024a":"No network hop","oss-lattice-business-glyph.6a62f09af5":"Your hardware, inside the European Union. No outside service\n                  on the path of a decision.","oss-lattice-business-glyph.c82d1b09cf":"EU","oss-lattice-business-glyph.1d197d39c5":"Where it runs","oss-lattice-business-glyph.3fc79400cb":"Operating contract","oss-lattice-business-glyph.4c3bbb2510":"One engine, one answer, every server. The decision you made\n                today still reads the same next year.","oss-lattice-business-glyph.9d900b06ad":"Audit holds","oss-lattice-business-glyph.7becbf3f3a":"With Lattice","oss-lattice-business-glyph.6dc765a6fd":"A separate service","oss-lattice-business-glyph.a475b85411":"What it de-risks.","oss-lattice-business-glyph.74c2a3e955":"What it saves.","oss-lattice-business-glyph.5342989716":"Deterministic policy evaluation","oss-lattice-business-glyph.03f923bd0d":"Lattice","oss-lattice-business-glyph.c6a76eb73a":"Decision board","oss-lattice-business-glyph.6eef664840":"None","oss-lattice-business-glyph.1ebe1b944e":"1.36 ns hot path","oss-lattice-business-glyph.346a87017f":"Network round-trip per check","oss-lattice-business-glyph.c6b617260a":"Latency","oss-lattice-business-glyph.a5ca844717":"Replay the rule that ran","oss-lattice-business-glyph.d97949a052":"Reconstructed after the fact","oss-lattice-business-glyph.d51b35c242":"The audit","oss-lattice-business-glyph.f59144c3cf":"The same on every server","oss-lattice-business-glyph.2d59e161f6":"Drifts server to server","oss-lattice-business-glyph.7011b1a621":"The answer","oss-lattice-business-glyph.47168475cb":"Inside what you already run","oss-lattice-business-glyph.c502d3e3d8":"A separate service to host","oss-lattice-business-glyph.afb077c327":"The engine","oss-lattice-check-ledger.3c1d44232a":"on a real dominance tree","oss-lattice-check-ledger.074cb6ace8":"seven in total","oss-lattice-check-ledger.93ff909ce2":"Enforced","oss-lattice-check-ledger.71050ef829":"Structural","oss-lattice-check-ledger.8b45f8c51d":"on the dominance tree","oss-lattice-check-ledger.5098dd1999":"Checks","oss-lattice-close-banner.f747dbb955":"compiled once, checkable by anybody","oss-lattice-close-banner.8768ef7d10":"which rule decided, which held, which nearly held and by how much","oss-lattice-close-banner.f46e03d644":"one outcome","oss-lattice-close-banner.d51790f8ee":"Which is why the answer can say how they combined, which rule decided, which part was\n          approximate, and which nearly held. And why that answer is the same next year, on\n          different hardware, in front of somebody who has no reason to take your word for it.","oss-lattice-close-banner.a6a18010f4":"A regulation, a safety limit, a boundary on what software may do alone, a structural\n          requirement, a threshold on a similarity. In most estates those sit in separate systems\n          that were integrated afterwards and reconcile badly. Here they are one register,\n          evaluated together, from one compiled file.","oss-lattice-close-banner.30656ce884":"a register.","oss-lattice-close-banner.afcef0819c":"Governance becomes","oss-lattice-close-banner.481d0fc02c":"The whole argument","oss-lattice-close-banner.ed09422325":"tool reach","oss-lattice-close-banner.66299b2eb6":"safety limit","oss-lattice-consent-worked.ef7db413ee":"evaluated, not mapped","oss-lattice-consent-worked.248aab552e":"Three out of four is zero.","oss-lattice-consent-worked.785b7e4fed":"Four conditions, and they are not scored.","oss-lattice-consent-worked.7ed41b72b0":"One boolean, written at signup, never re-examined. It is not a lie. It is a summary\n            of a question nobody finished asking.","oss-lattice-consent-worked.bb5a90b40d":"the same fact, as most systems keep it","oss-lattice-consent-worked.9b8bf5f77e":"The remedy is a separate withdrawal path per purpose, after which the record can\n              be re-evaluated. Until then this customer has not consented to anything.","oss-lattice-consent-worked.21d5dc2996":"Three conditions were met and one was not, which under Article 7 is the same\n              outcome as meeting none. The failing condition is","oss-lattice-consent-worked.ad0ccc24e4":"No valid consent","oss-lattice-consent-worked.1ca0cd9283":"Never evaluated. The record already fails, so the answer here changes nothing.","oss-lattice-consent-worked.6992270d64":"Not reached","oss-lattice-consent-worked.f02b6071fa":"separate consent per purpose","oss-lattice-consent-worked.41769a6b0d":"Granular","oss-lattice-consent-worked.6a3aa80458":"Captured through a combined opt-in covering three purposes. Withdrawal is not\n              offered separately for any of them.","oss-lattice-consent-worked.f421aed614":"Not met","oss-lattice-consent-worked.75f29b6a2a":"as easy to withdraw as to give","oss-lattice-consent-worked.7345ca6fb2":"Withdrawable","oss-lattice-consent-worked.492f468eee":"Timestamp, form version and wording shown, all retained.","oss-lattice-consent-worked.e4028358c8":"Met","oss-lattice-consent-worked.6c0f70985f":"the controller can show it","oss-lattice-consent-worked.9681edd3b5":"Documented","oss-lattice-consent-worked.36f6b734da":"Unticked box, ticked by the customer, no pre-selection.","oss-lattice-consent-worked.03ef028b9e":"a clear affirmative act","oss-lattice-consent-worked.db95e1890c":"Explicit","oss-lattice-consent-worked.9e30a865a4":"captured 3 February 2026, signup form, marketing purposes","oss-lattice-consent-worked.769e3d01bd":"Customer 8842","oss-lattice-consent-worked.1be4d0b492":"article 7, all conditions","oss-lattice-consent-worked.d98c27af8c":"three of four","oss-lattice-consent-worked.b430876b67":"Consent, worked through","oss-lattice-consumer-glyph.0b19b7292f":"Quick, calm, and kind","oss-lattice-consumer-glyph.1e5486035c":"No special knowledge needed","oss-lattice-consumer-glyph.286ae60ab8":"What this means for you","oss-lattice-consumer-glyph.a25dbbd93d":"and here is why","oss-lattice-consumer-glyph.5397e0583f":"Yes","oss-lattice-consumer-glyph.91fc81cf8d":"Your form","oss-lattice-consumer-glyph.a118831ca5":"The rulebook","oss-lattice-consumer-glyph.1ebf1dac09":"The careful clerk who checks the rules","oss-lattice-consumer-glyph.b631213249":"A person stays in charge, not the machine","oss-lattice-consumer-glyph.7426ceebb0":"Your papers stay with you","oss-lattice-consumer-glyph.da093c5cbc":"The same answer today and tomorrow","oss-lattice-consumer-glyph.4b51b4f2b9":"A clear yes or no, and the reason why","oss-lattice-details-stay.4ece45cdc9":"nothing is sent away","oss-lattice-details-stay.1a3bea5f94":"One of them sends you somewhere.","oss-lattice-details-stay.1fd83c77aa":"Same question, same answer.","oss-lattice-details-stay.6dc763eda2":"A person stays in charge, not the machine.","oss-lattice-details-stay.ab0e8d5e16":"Nothing crosses a border you did not choose.","oss-lattice-details-stay.d5f0d700b2":"It still answers when the connection does not.","oss-lattice-details-stay.979b2fd37d":"the rules, in one place","oss-lattice-details-stay.29da45ba80":"the written rules, arriving","oss-lattice-details-stay.71c422ab06":"where your details are","oss-lattice-details-stay.0608e37330":"the rules travel","oss-lattice-details-stay.3f01362472":"this way","oss-lattice-details-stay.09b613f97d":"a company you did not choose","oss-lattice-details-stay.cf2460adea":"your name, your dates, your numbers","oss-lattice-details-stay.52a9703b06":"your details travel","oss-lattice-details-stay.92e79c83d2":"the usual way","oss-lattice-details-stay.77b18f33db":"your details stay put","oss-lattice-details-stay.8b9ad76bd5":"nothing leaves","oss-lattice-details-stay.4822f272c3":"Which way the arrow points","oss-lattice-encoded-checks.6773b33c04":"not in a document beside it","oss-lattice-encoded-checks.33ba5cefad":"the article is in the engine","oss-lattice-encoded-checks.9106bb4872":"In the engine","oss-lattice-encoded-checks.a888a07236":"what each check actually tests","oss-lattice-encoded-checks.44168b1a9e":"Encoded, not mapped","oss-lattice-encoded-checks.d45f753d28":"What the others add up to, returned as one decision.","oss-lattice-encoded-checks.b6c533b565":"Combined","oss-lattice-encoded-checks.b9ec0f581c":"Composite","oss-lattice-encoded-checks.d2a4d4bdc9":"Which mechanism covers this, verified before it happens.","oss-lattice-encoded-checks.8ff31316ab":"Chapter V","oss-lattice-encoded-checks.cbb4cc4982":"Transfer","oss-lattice-encoded-checks.47c001cd82":"Explicit, withdrawable, documented, granular. All four, per record.","oss-lattice-encoded-checks.11a2c24059":"Art. 7","oss-lattice-encoded-checks.0599298f6d":"Consent","oss-lattice-encoded-checks.d5e98c88e0":"Categories checked against what the system actually does.","oss-lattice-encoded-checks.62dffe3420":"Annex III","oss-lattice-encoded-checks.667c4baacc":"High risk","oss-lattice-encoded-checks.3fda9df085":"Practices the Act rules out, detected rather than declared.","oss-lattice-encoded-checks.ba463f6839":"Art. 5","oss-lattice-encoded-checks.030b0ae196":"Prohibited","oss-lattice-excavation.144e7ab2a7":"and the trace stopped before the bottom","oss-lattice-excavation.8d2b6ea821":"Not one of them has a name.","oss-lattice-excavation.08f3ab4c38":"Six conditions took part in that decision.","oss-lattice-excavation.19f4cb08d9":"was never written down anywhere.","oss-lattice-excavation.2b79822f1f":"Whatever set the rule above this one","oss-lattice-excavation.48064ec376":"The trace ends here.","oss-lattice-excavation.bec97147a6":"last edited 2023, links to a page that no longer exists","oss-lattice-excavation.c88422e7ca":"\"We agreed not to approve outside the EEA without a second pair of eyes.\"","oss-lattice-excavation.2a8b7dc7e0":"internal wiki, Risk policy","oss-lattice-excavation.ff446beb62":"14px 17px 22px","oss-lattice-excavation.682164f16a":"Policy page","oss-lattice-excavation.9cb16d00cb":"Training filter","oss-lattice-excavation.61a54255d7":"(final) (v3)","oss-lattice-excavation.50c3f10f5b":"AUTO","oss-lattice-excavation.611e03324b":"11px 12px","oss-lattice-excavation.d9a2a33e71":"Operations sheet","oss-lattice-excavation.1cfdf99a73":"team dissolved in June","oss-lattice-excavation.44357ae55a":"Payments","oss-lattice-excavation.57b4407f5b":"Deploy config","oss-lattice-excavation.8eae9b0264":"Feature service","oss-lattice-excavation.34a88c4716":"Request handler","oss-lattice-excavation.4b73aced85":"in force","oss-lattice-excavation.b00ede168f":"The applicant has asked which rule decided.","oss-lattice-excavation.7775bce5b3":"14 March 2026, no human involved.","oss-lattice-excavation.156bb5763e":"Application 48812, declined","oss-lattice-excavation.8feaa4174e":"which rule decided","oss-lattice-excavation.0aa9b66801":"One decision, traced backwards","oss-lattice-failure-types.936bf5853e":"these say four things","oss-lattice-failure-types.1c96bc129d":"an empty set says nothing","oss-lattice-failure-types.b01f7487b0":"each one a distinct case","oss-lattice-failure-types.60e5c23b14":"Typed","oss-lattice-failure-types.bde7827e35":"Why a query did not hold","oss-lattice-failure-types.ff7c52c7dd":"It nearly held. Here is what was needed against what was reached.","oss-lattice-failure-types.bef7cf891b":"Short of threshold","oss-lattice-failure-types.4a7b33b970":"Something actively ruled it out, with the constraint identified.","oss-lattice-failure-types.4dd18cc460":"Constraint violated","oss-lattice-failure-types.72f68e864d":"A rule could have fired. One condition was absent, and it is named.","oss-lattice-failure-types.f547426bff":"Missing premise","oss-lattice-failure-types.0869b0faa0":"The pattern was fine. Nothing matched it.","oss-lattice-failure-types.1cc534dfb3":"No matching facts","oss-lattice-families.050fea6a03":"it finds the family","oss-lattice-families.d4b92646c3":"you write the constraint","oss-lattice-families.c614ba7c45":"Auto","oss-lattice-families.45e286657a":"families, not backends","oss-lattice-families.6f866c41e5":"What the classifier routes across","oss-lattice-families.6dbab0200f":"Answer set programming, Datalog, temporal properties, Petri nets.","oss-lattice-families.6231f09938":"Logic and temporal","oss-lattice-families.85d84414bd":"Finite domains with propagation, including spatial and temporal.","oss-lattice-families.bee537a628":"Constraint programming","oss-lattice-families.2e6eb7d461":"Linear, quadratic and mixed integer over integer and fixed-point representations, where a variable must be whole when the model requires it.","oss-lattice-families.c794704381":"Optimisation","oss-lattice-families.e57c50472d":"Boolean and modulo theories, with arithmetic, arrays, bitvectors, strings.","oss-lattice-families.3a198b87ab":"Satisfiability","oss-lattice-fit-test.0d7093d005":"enforces, does not author","oss-lattice-fit-test.c4d8bebfa4":"Three where we would tell you not to.","oss-lattice-fit-test.0f2e2c24fc":"Three where it earns its keep.","oss-lattice-fit-test.37ad50bda7":"Not worth it","oss-lattice-fit-test.878e4cf83d":"Worth it","oss-lattice-fit-test.41de8279ac":"being straight about it","oss-lattice-fit-test.d669910eee":"and where it does not","oss-lattice-fit-test.b93f80b8ba":"Where it fits","oss-lattice-fit-test.24cc681e97":"The guarantee costs something. If you will throw the code away in a month, do not pay for it.","oss-lattice-fit-test.db64bd060d":"A prototype nobody will audit","oss-lattice-fit-test.0e653eeccc":"Compilation is a build step. At that rate you would spend more time deploying rules than writing them.","oss-lattice-fit-test.e708e8cce0":"A rule that changes twice a week","oss-lattice-fit-test.f36d6641af":"You are changing the question faster than you could compile the answer, and nobody will audit the intermediate steps.","oss-lattice-fit-test.7ae0995d9a":"Exploratory analysis","oss-lattice-fit-test.410b358505":"The question is never whether the decision was reasonable. It is which rule made it and when it last changed.","oss-lattice-fit-test.e79b05db9e":"Anything a regulator can ask about","oss-lattice-fit-test.8762200d52":"Four teams reading the same policy will encode four slightly different rules, and nobody finds out until an audit.","oss-lattice-fit-test.b15805e8e5":"A rule that must apply identically in four countries","oss-lattice-fit-test.2f10550d56":"By then the person who wrote the rule has moved on and the reasoning has not been written down anywhere else.","oss-lattice-fit-test.0d8d914a42":"A decision somebody will question in eighteen months","oss-lattice-five-systems.3a8d0c6a2f":"pointed at the wrong thing","oss-lattice-five-systems.3f656d714d":"Nobody can say what decided.","oss-lattice-five-systems.fab6fd5956":"The controls all passed.","oss-lattice-five-systems.dee30056a8":"Five departments, five records, each one\n            true and each one written for its own system: an identifier meaningful only inside the\n            engine that wrote it, a fixed-point score, an external probability before conversion, and a silence.\n            Every framework was followed and none of these can be joined to the others.","oss-lattice-five-systems.67c8fe1bfd":"Nothing above answers it.","oss-lattice-five-systems.b86ba9e1da":"which rule declined this customer","oss-lattice-five-systems.b222f5ec71":"five departments logged it, each in their own terms","oss-lattice-five-systems.156bb5763e":"Application 48812, declined","oss-lattice-five-systems.2842541ccb":"illustrative, one real shape","oss-lattice-five-systems.f9f9244f1c":"none of them join","oss-lattice-five-systems.668cd3d7a6":"One decline, five records","oss-lattice-five-systems.7dbce6dc9f":"Application code","oss-lattice-five-systems.4143d04801":"Engineering","oss-lattice-five-systems.0673efa838":"The model","oss-lattice-five-systems.d0516d105b":"Data science","oss-lattice-five-systems.6c9eae26f3":"The safety filter","oss-lattice-five-systems.5a8f23f567":"Risk","oss-lattice-five-systems.bf0b2368d3":"The compliance module","oss-lattice-five-systems.68f0ae4911":"Compliance","oss-lattice-five-systems.6b5b9fe6b8":"The rules engine","oss-lattice-five-systems.a1fdaa6b2a":"Operations","oss-lattice-four-steps.11c4598a13":"and step four is the point","oss-lattice-four-steps.7e5924ee45":"the check comes first","oss-lattice-four-steps.ce65202f26":"Slowly","oss-lattice-four-steps.89fdeae0e7":"in that order, every time","oss-lattice-four-steps.c7c457c8df":"The four steps","oss-lattice-four-steps.efc975271f":"On the day, in words, without making a complaint first.","oss-lattice-four-steps.38e727cd1e":"You can ask why","oss-lattice-four-steps.88de40303f":"And names the rule it used to get there.","oss-lattice-four-steps.126b8318a2":"It answers","oss-lattice-four-steps.6db86c4507":"Before anything moves. Not afterwards, not on a sample.","oss-lattice-four-steps.59eede3514":"It checks first","oss-lattice-four-steps.10d2bae02b":"In your own words, from wherever you already were.","oss-lattice-four-steps.7ed149da71":"You ask","oss-lattice-handover.c46d431e7a":"compiled, not interpreted","oss-lattice-handover.bf2f87e840":"That is the difference from a report.","oss-lattice-handover.41a924e8e9":"They ran it without trusting you.","oss-lattice-handover.87c7e14899":"rather than returning\n              something plausible. A system that keeps working after its rules were tampered with\n              is worse than one that stops, because it produces answers nobody has reason to\n              question.","oss-lattice-handover.a52129869a":"integrity: section digest mismatch at rules[2]","oss-lattice-handover.b38635e89e":"The load stops with","oss-lattice-handover.fe432f5f18":"No answer is produced.","oss-lattice-handover.1b752c11f7":"refuses to load","oss-lattice-handover.5d6031160f":"the same file, edited afterwards","oss-lattice-handover.e80566e44f":"One byte altered","oss-lattice-handover.48c5e9a613":"decline, rule account_age v4","oss-lattice-handover.cccbf50967":"no access to your systems","oss-lattice-handover.95a0dbaa52":"their hardware, their input","oss-lattice-handover.4577c74526":"the same file","oss-lattice-handover.cc8ef4a38e":"their machine","oss-lattice-handover.d4982cd832":"compiled 14 March 2026","oss-lattice-handover.620b3e09b7":"your hardware, your input","oss-lattice-handover.349e470ff9":"your estate","oss-lattice-handover.35abd870ea":"three integrity levels","oss-lattice-handover.cd1f3ff564":"fails closed","oss-lattice-handover.66f7e1b3f6":"The file, handed over","oss-lattice-handover-banner.b071b0203e":"you stop being believed and start being checked","oss-lattice-handover-banner.48c5e9a613":"decline, rule account_age v4","oss-lattice-handover-banner.5537048570":"access to you","oss-lattice-handover-banner.4577c74526":"the same file","oss-lattice-handover-banner.00b972491e":"their run","oss-lattice-handover-banner.f7a5cadc7e":"application 48812","oss-lattice-handover-banner.3fcceea305":"your run","oss-lattice-handover-banner.fdc9aed716":"Because the rules compile to a file, you can hand the file over. The other side runs it\n          against the same input, on their own machine, and gets the same answer or does not. You\n          stop being believed and start being checked, which is a considerably better position.","oss-lattice-handover-banner.04a787d9cc":"Every assurance an organisation offers about its own decisions has the same weakness: the\n          organisation produced it. A report you compiled, from logs you control, about a system you\n          operate. It may be entirely honest, and everybody in the room knows whose account it is.","oss-lattice-handover-banner.8901558db8":"That is the whole test.","oss-lattice-handover-banner.705bcde618":"Can you hand it over?","oss-lattice-handover-banner.16588eeacf":"The test that matters","oss-lattice-handover-banner.caa155adf8":"rules","oss-lattice-handover-banner.608cb271bb":"hardware","oss-lattice-handover-banner.140f86aae5":"input","oss-lattice-handover-banner.922cce49ed":"yours","oss-lattice-handover-banner.d16d743032":"theirs","oss-lattice-handover-banner.71f8e7976e":"none","oss-lattice-hero-glyph.354da705dd":"Total Constraints","oss-lattice-hero-glyph.4ebcffbc4f":"Tier 1","oss-lattice-hero-glyph.81ff427ffd":"Tier 2","oss-lattice-hero-glyph.7afd39eaf0":"Total Classes","oss-lattice-hero-glyph.3f9c43b6fc":"Total Sections","oss-lattice-hero-glyph.40301a5c5e":"hot lookup","oss-lattice-hero-glyph.33a00b17c6":"1.36 ns","oss-lattice-hero-glyph.68c52d6d5d":"cold lookup","oss-lattice-hero-glyph.9bb1636919":"39 ns","oss-lattice-hero-glyph.601da48321":"dweve-lattice [v1.0.0]","oss-lattice-hero-glyph.0ef8c6b19c":"exit 0","oss-lattice-hero-glyph.1301a1a22e":"policy compile","oss-lattice-hero-glyph.6b5eb5323e":"Deterministic policy evaluation","oss-lattice-hero-glyph.24ba16e708":"-o policy.dlat","oss-lattice-hero-glyph.0fb7ea3a85":"Policy is valid,","oss-lattice-hero-glyph.6ef4747e47":"14 rules indexed","oss-lattice-hero-glyph.52e68a873a":"Constraints","oss-lattice-hero-glyph.f9a42521ef":"header checksum","oss-lattice-hero-glyph.b659801d8a":"5 sections","oss-lattice-hero-glyph.d161f98b5b":"policy eval","oss-lattice-hero-glyph.53577bb5df":"Deny","oss-lattice-hero-glyph.13c1df2f3b":"event: pre_tool_use","oss-lattice-hero-glyph.ee42274cc2":"Recursive deletion command blocked","oss-lattice-hero-glyph.064c14e17e":"bit-exact on every platform","oss-lattice-hero-glyph.cae7533dee":"Section Directory","oss-lattice-hero-glyph.3deb745651":"Type","oss-lattice-hero-glyph.b7152342a2":"Size","oss-lattice-hero-glyph.53d8f4c3f2":"dump statistics","oss-lattice-hero-glyph.0503f4323d":"Hot section","oss-lattice-hero-glyph.6757848af7":"DETERMINISTIC","oss-lattice-hero-glyph.bafd9cc93a":"312 constraints, 5 sections","oss-lattice-hero-glyph.85deed7b48":"hot 1.36 ns, cold 39 ns","oss-lattice-hero-glyph.1be5a0dfa9":"mmap, no daemon","oss-lattice-hero-glyph.route.incoming":"Incoming action","oss-lattice-hero-glyph.route.boundary":"Autonomous boundary","oss-lattice-hero-glyph.route.outsideGrant":"path outside grant","oss-lattice-hero-glyph.route.artefact":"Policy artefact","oss-lattice-hero-glyph.route.verified":"signature verified","oss-lattice-hero-glyph.route.replay":"Replay","oss-lattice-hero-glyph.route.sameOutcome":"same outcome","oss-lattice-hero-glyph.route.denied":"Denied","oss-lattice-hero-glyph.route.reason":"Recursive deletion command blocked","oss-lattice-hero-glyph.route.exactReplay":"Bit exact on every platform","oss-lattice-hybrid-chain.3283a04d6d":"attributed per step","oss-lattice-hybrid-chain.6df8f760fc":"You can see which half did what.","oss-lattice-hybrid-chain.1d0f60dc38":"Both halves, in one chain.","oss-lattice-hybrid-chain.a7b9df38a5":"at step three. Defend the\n            conclusion and that is the step you will be defending.","oss-lattice-hybrid-chain.20323607c5":"The chain holds, and the whole\n            of it rests on a resemblance recorded internally at","oss-lattice-hybrid-chain.f9395aa9af":"Three exact steps, one approximate.","oss-lattice-hybrid-chain.e39262defe":"Conclusion","oss-lattice-hybrid-chain.dc31610963":", given the four steps before it.","oss-lattice-hybrid-chain.ce71b3cc7a":"Followed from","oss-lattice-hybrid-chain.121d998e6c":"eligible = true","oss-lattice-hybrid-chain.78e1790e29":"Rule","oss-lattice-hybrid-chain.5251965b5b":"Established by the solver from the declared figures, not by chaining.","oss-lattice-hybrid-chain.e1d3550543":"Solved","oss-lattice-hybrid-chain.a3d31e9b5a":"External score converted to fixed point; the match is not proved. Marked as such.","oss-lattice-hybrid-chain.3bf1eca830":"Similarity","oss-lattice-hybrid-chain.8fede5fa99":", and the rule is named.","oss-lattice-hybrid-chain.a31edd9944":"Stated directly on the record. Nothing derived it.","oss-lattice-hybrid-chain.60adc3d1f4":"residence = NL","oss-lattice-hybrid-chain.95742cac43":"Asserted","oss-lattice-hybrid-chain.60b9900b40":"five steps","oss-lattice-hybrid-chain.5e1b2b3a68":"one step approximate","oss-lattice-hybrid-chain.656be2a029":"One derivation, attributed","oss-lattice-in-force-banner.a9db906761":"June","oss-lattice-in-force-banner.c94f479833":"May","oss-lattice-in-force-banner.a0393902db":"April","oss-lattice-in-force-banner.433632ea5c":"March","oss-lattice-in-force-banner.9daf9699cc":"the build","oss-lattice-in-force-banner.92bdfd962a":"the index","oss-lattice-in-force-banner.cc98000819":"a threshold","oss-lattice-in-force-banner.45f0d38ea6":"the model","oss-lattice-in-force-banner.f9dad3ebd2":"the rules","oss-lattice-in-force-banner.93187ef5d7":"since the March decline","oss-lattice-in-force-banner.910e029098":"illustrative","oss-lattice-in-force-banner.4455e3764f":"versioned with the thing it governs, or the question has no answer","oss-lattice-in-force-banner.989e1e71f7":"The governing conditions and the thing they govern drift independently, and only one of\n          them is usually versioned. Deployment logs record what shipped, not which rules were\n          inside it.","oss-lattice-in-force-banner.99be862fbd":"Somebody asks why an application was declined in March. The rules have not changed\n          since, which sounds like a complete answer until you remember what else moves. The model\n          was retrained in April. A threshold was adjusted. A retrieval index was rebuilt.","oss-lattice-in-force-banner.c67c1a21fc":"Something else did.","oss-lattice-in-force-banner.e95cac9649":"The rules did not change.","oss-lattice-in-force-banner.125abce20e":"The question after the incident","oss-lattice-judge-flow.3b49317a61":"the judgement is the product","oss-lattice-judge-flow.7db1a23659":"the format check is cheap","oss-lattice-judge-flow.cce3962ad0":"Detection","oss-lattice-judge-flow.d32216d021":"elimination is the interesting case","oss-lattice-judge-flow.d622dab29f":"How a candidate is judged","oss-lattice-judge-flow.08c6512d09":"What remains is personal data, with the reason it qualified.","oss-lattice-judge-flow.d999aeb054":"Resolved","oss-lattice-judge-flow.769acca094":"Candidates the context rules out are dropped before anything acts.","oss-lattice-judge-flow.d5936b9a0d":"Eliminated","oss-lattice-judge-flow.8e75332b53":"The surrounding columns and values become conditions.","oss-lattice-judge-flow.0f06050830":"In context","oss-lattice-judge-flow.dda92725d3":"Format and checksum checks fire, deliberately catching too much.","oss-lattice-judge-flow.70cbd1d6b1":"Proposed","oss-lattice-lookup-path.4dd5ae4296":"checkable, not asserted","oss-lattice-lookup-path.26e2676969":"Where it stopped is the whole story.","oss-lattice-lookup-path.ce187795bc":"Four numbers, one explanation.","oss-lattice-lookup-path.6c0cbccb25":"resident 1.36 ns   standard 6.60 ns   cold 39.3 ns   sustained 735M/s","oss-lattice-lookup-path.e13ed1be1e":"the benchmark publishes with the repository","oss-lattice-lookup-path.15ce33e0ee":"lookup enters","oss-lattice-lookup-path.2647d64f2d":"run it yourself","oss-lattice-lookup-path.f15ddb7a15":"four exits","oss-lattice-lookup-path.a2d2ea4d16":"Where the lookup stopped","oss-lattice-lookup-path.921843464c":"Single thread at full coverage. Scales with cores.","oss-lattice-lookup-path.85005cca52":"Sustained","oss-lattice-lookup-path.f5e0f8bff0":"the tail","oss-lattice-lookup-path.ea5d27cefc":"Compressed block, decompressed on access.","oss-lattice-lookup-path.591f787e5e":"Cold","oss-lattice-lookup-path.1b2e7186fb":"39.3 ns","oss-lattice-lookup-path.7d7ce0c082":"the common case","oss-lattice-lookup-path.f9aba7879b":"One aligned read on a cache line boundary.","oss-lattice-lookup-path.2dfa66079d":"Standard","oss-lattice-lookup-path.bbc43ecbbf":"6.6 ns","oss-lattice-lookup-path.31a2b82f68":"most traffic","oss-lattice-lookup-path.d87e7fd07f":"In the hot section, promoted by access count.","oss-lattice-lookup-path.8769483c20":"Resident","oss-lattice-lookup-path.33a00b17c6":"1.36 ns","oss-lattice-not-in-scope.4c5366af63":"than have you find out later","oss-lattice-not-in-scope.c26ea1f447":"we would rather say it here","oss-lattice-not-in-scope.9caa367403":"Honest","oss-lattice-not-in-scope.afec0d6691":"deliberately, and we would say so","oss-lattice-not-in-scope.d9a5f9046a":"Not in scope","oss-lattice-not-in-scope.90e6f827ad":"Where reproducibility does not matter, simpler tools win.","oss-lattice-not-in-scope.38d441e6f1":"Every situation","oss-lattice-not-in-scope.a190032994":"Compilation is a build step. That is the cost of the guarantee.","oss-lattice-not-in-scope.e5c4577e4f":"Runtime edits","oss-lattice-not-in-scope.22528ab9d7":"A wrong rule applied perfectly is still wrong.","oss-lattice-not-in-scope.0186305325":"Judging them","oss-lattice-not-in-scope.2333a2f508":"Yours to write and yours to answer for.","oss-lattice-not-in-scope.262f495bd4":"Authoring rules","oss-lattice-not-in-scope-biz.1591246b2b":"a register is","oss-lattice-not-in-scope-biz.1f28748e79":"a promise is not checkable","oss-lattice-not-in-scope-biz.94fb70b1ab":"deliberately, and we would rather say so here","oss-lattice-not-in-scope-biz.9caa367403":"Honest","oss-lattice-not-in-scope-biz.d9a5f9046a":"Not in scope","oss-lattice-not-in-scope-biz.0d15096420":"Compilation is a build step, and that is the cost of the guarantee.","oss-lattice-not-in-scope-biz.2371a440d2":"Hourly change","oss-lattice-not-in-scope-biz.191cd9fe9c":"Nothing does that. It makes the rules checkable.","oss-lattice-not-in-scope-biz.e8ea371c0c":"Making you compliant","oss-lattice-not-in-scope-biz.22528ab9d7":"A wrong rule applied perfectly is still wrong.","oss-lattice-not-in-scope-biz.0186305325":"Judging them","oss-lattice-not-in-scope-biz.b8681bcbfe":"Yours to author, yours to answer for.","oss-lattice-not-in-scope-biz.02eda4fc3d":"Writing your rules","oss-lattice-nothing-leaves.01975ed00a":"no company in between","oss-lattice-nothing-leaves.4ece45cdc9":"nothing is sent away","oss-lattice-nothing-leaves.755844bc39":"Yours","oss-lattice-nothing-leaves.ac9a3381cf":"and what arrives instead","oss-lattice-nothing-leaves.27864408d9":"What never leaves","oss-lattice-nothing-leaves.9d52175333":"It still answers when the line is down.","oss-lattice-nothing-leaves.295ea39ff5":"No connection needed","oss-lattice-nothing-leaves.f8b69200d7":"None that has to be working, trustworthy, or still in business.","oss-lattice-nothing-leaves.c27d7cbfe3":"No outside company","oss-lattice-nothing-leaves.cf325a3b50":"Travel to them, rather than the other way round.","oss-lattice-nothing-leaves.03b34e8afe":"The rules","oss-lattice-nothing-leaves.b3abe06853":"Stay on the machine already holding them.","oss-lattice-nothing-leaves.a6252b6690":"Your details","oss-lattice-obligations.91f1524a51":"an owner per obligation","oss-lattice-obligations.0deb99f062":"Operating one has deadlines.","oss-lattice-obligations.8a4e3b4edb":"A policy has conditions.","oss-lattice-obligations.b42553b843":"The outcome most compliance programmes have nowhere to put, and the one that\n                actually needs somebody.","oss-lattice-obligations.a5f995a220":"Action required","oss-lattice-obligations.82dd2cdf36":"Block","oss-lattice-obligations.d7cd56f2a2":"Pass","oss-lattice-obligations.5272edd042":"states, not conditions","oss-lattice-obligations.f08fd2726f":"two need a decision","oss-lattice-obligations.fa8bb9c2dd":"Four obligations, with clocks","oss-lattice-obligations.902c91d94e":"Legal","oss-lattice-obligations.4f960a8470":"at the event","oss-lattice-obligations.4ac3777d17":"Processing in Zurich, mechanism recorded at the time","oss-lattice-obligations.828697f103":"Transfer record","oss-lattice-obligations.a1fdaa6b2a":"Operations","oss-lattice-obligations.42bddb44e1":"14 days ago","oss-lattice-obligations.06165647cb":"Closed accounts held beyond the stated period","oss-lattice-obligations.c7199d9e95":"Retention","oss-lattice-obligations.5a8f23f567":"Risk","oss-lattice-obligations.2657ccb0af":"blocks go live","oss-lattice-obligations.7e3fe7c3ea":"not started","oss-lattice-obligations.3e347ce123":"Required before the scoring model may run","oss-lattice-obligations.89dfbf6111":"Impact assessment","oss-lattice-obligations.b431c894e4":"Data Protection Office","oss-lattice-obligations.6bd4bd0944":"of 30","oss-lattice-obligations.5470f05e21":"day 27","oss-lattice-obligations.31780c8654":"Request from customer 8842, received 2 February","oss-lattice-obligations.8caa1f8a43":"Subject access","oss-lattice-ordinary-day.cae1998558":"until one goes against you","oss-lattice-ordinary-day.63c4da3301":"That is the point of them.","oss-lattice-ordinary-day.b5e29ef491":"You noticed none of these.","oss-lattice-ordinary-day.9f7bcc2601":"decisions about you before the afternoon, and a person looked at none of them. Most of\n            the time that is exactly what you want.","oss-lattice-ordinary-day.5e8441bc4e":"no person involved","oss-lattice-ordinary-day.6c3c635a2e":"none of which you watched","oss-lattice-ordinary-day.a2111d0e12":"four decisions","oss-lattice-ordinary-day.d2ebee5b8b":"One Tuesday","oss-lattice-ordinary-day.6545c9c656":"Something read it and moved it on.","oss-lattice-ordinary-day.e6e9bf0c6f":"A form was accepted","oss-lattice-ordinary-day.c8ffc247cf":"Quietly, and it stayed where it was.","oss-lattice-ordinary-day.7fed833147":"A credit limit was reviewed","oss-lattice-ordinary-day.7c0d94c48e":"Something chose a different depot for it.","oss-lattice-ordinary-day.80ce4a77c8":"A parcel was redirected","oss-lattice-ordinary-day.36d939d188":"Something checked the card and let it through.","oss-lattice-ordinary-day.0d534eea81":"The coffee was paid for","oss-lattice-outcomes.671c8818e6":"shape follows the question","oss-lattice-outcomes.28b22a6e1a":"You cannot ignore the evidence by accident.","oss-lattice-outcomes.78f4e822b4":"None of these is a boolean.","oss-lattice-outcomes.3ae3d3f38c":"retention overdue","oss-lattice-outcomes.8c213e5f7d":"transfers unmapped","oss-lattice-outcomes.ad056ab1ca":"consent gaps","oss-lattice-outcomes.2deaeabc5e":"ranked, with a total","oss-lattice-outcomes.ee45c30326":"Report","oss-lattice-outcomes.b2a16bba70":"conditions synthesised from the three, not chosen between them","oss-lattice-outcomes.a09430e8d9":"retain until closure","oss-lattice-outcomes.d17e19b6aa":"retain 36 months","oss-lattice-outcomes.86532482bf":"retain 24 months","oss-lattice-outcomes.916930cbe5":"3 candidates","oss-lattice-outcomes.8d441fb5f6":"Generation","oss-lattice-outcomes.52488a9af3":"2 dependencies","oss-lattice-outcomes.c5e3ab6667":"sign off","oss-lattice-outcomes.b6395529fd":"4 steps, 11 days","oss-lattice-outcomes.ae2f98a099":"Plan","oss-lattice-outcomes.6c62c5d8fb":"the property held for every case but this one","oss-lattice-outcomes.03128bed90":"Verification","oss-lattice-outcomes.e3e37f5334":"certificate attached, optimality proved","oss-lattice-outcomes.54ebadeb30":"route C, via Zeebrugge","oss-lattice-outcomes.c9a0806e26":"route A, via Antwerp","oss-lattice-outcomes.9ed96966a3":"route B, via Rotterdam","oss-lattice-outcomes.d1f8e5ea93":"Selection","oss-lattice-outcomes.cdb35feefe":"tariff_band unmet, and account_age carried it","oss-lattice-outcomes.7f59a1f1d5":"Decision","oss-lattice-outcomes.ba07846216":"the question decides which","oss-lattice-outcomes.61b0ff8d7b":"one solve, six possible returns, and","oss-lattice-outcomes.4e19841f3d":"the question picks the shape","oss-lattice-outcomes.ec97153ea8":"one failed","oss-lattice-outcomes.3095258bd0":"Six returns, six shapes","oss-lattice-owned-by.7afededc8b":"somebody, with a name","oss-lattice-owned-by.9fb17eb39d":"not the system decided","oss-lattice-owned-by.a25fcbbef9":"four things a rule carries here","oss-lattice-owned-by.e51845cb11":"Named","oss-lattice-owned-by.818718e94e":"Who answers for it","oss-lattice-owned-by.12dfc73848":"Anyone whose job is checking can check once it publishes.","oss-lattice-owned-by.a0a2d7a384":"A copy to check","oss-lattice-owned-by.0942792c0a":"The same facts give the same answer, years later.","oss-lattice-owned-by.1585ebd7c1":"A repeat","oss-lattice-owned-by.c46454a386":"When it was last looked at, and when it changed.","oss-lattice-owned-by.7556ac38bb":"A date","oss-lattice-owned-by.3eddaaa118":"Recorded against the rule, by name, not a department.","oss-lattice-owned-by.9e4b60c389":"A person","oss-lattice-pii-worked.34232e5a03":"context decides","oss-lattice-pii-worked.da6fd00e31":"The one that failed had the cleanest checksum.","oss-lattice-pii-worked.aee9ff93c2":"Three fired, two survived.","oss-lattice-pii-worked.c1186923f9":"orders, row 11492","oss-lattice-pii-worked.f17f2f6da8":"before anything acts","oss-lattice-pii-worked.819d6deef4":"one eliminated","oss-lattice-pii-worked.78c28d8f35":"One row, three candidates","oss-lattice-pii-worked.7d8a3a5d89":"A date of birth inside free text. Nothing validates it. It qualifies on context alone, which is the half no pattern reaches.","oss-lattice-pii-worked.b7d1ec8451":"no checksum exists","oss-lattice-pii-worked.55c9ab105f":"Confirmed by a labelled column and a country consistent value. The format check agreed and so did everything around it.","oss-lattice-pii-worked.b62f0a89ac":"passes mod-97","oss-lattice-pii-worked.f041b7a5ec":"The column runs sequentially and an order date sits beside it. A number can satisfy the arithmetic and still be an order reference.","oss-lattice-pii-worked.4f9f1b7ac1":"passes the identifier checksum","oss-lattice-plain-reason.fb29c5cc5d":"names what fell short","oss-lattice-plain-reason.d31d191fba":"The other one starts a complaint.","oss-lattice-plain-reason.0a86f51496":"One of these ends the matter.","oss-lattice-plain-reason.648c392e7d":"no rule named, no fact given, no date","oss-lattice-plain-reason.aa8943c035":"You may reapply in the future. If you have questions, please contact our customer\n              service team.","oss-lattice-plain-reason.55acf372d0":"We are unable to approve your application at this time.","oss-lattice-plain-reason.3a77aa5c58":"one thing","oss-lattice-plain-reason.667304fa8a":"what arrives today","oss-lattice-plain-reason.31d88f2023":"You will pass this rule on 14 September. You do not need to do anything before then.","oss-lattice-plain-reason.e2f7387e87":"four months","oss-lattice-plain-reason.ba46671be8":"Your account has been open for","oss-lattice-plain-reason.ca2e766b9c":"The rule is that an account needs to have been open for six months before we can\n              raise a limit without somebody reviewing it.","oss-lattice-plain-reason.616bcb2382":"Your application was not approved.","oss-lattice-plain-reason.a7a5426040":"four things","oss-lattice-plain-reason.6009a5a546":"what you should get","oss-lattice-plain-reason.af0b547cbf":"a reason, in words","oss-lattice-plain-reason.8ff16bd813":"one of them ends the conversation","oss-lattice-plain-reason.55aae165af":"The same no, written twice","oss-lattice-process-states.76a96782f1":"and operating one","oss-lattice-process-states.6d0e2572d8":"having a policy","oss-lattice-process-states.8459f93535":"Operational","oss-lattice-process-states.8d02b2223f":"states, deadlines and owners","oss-lattice-process-states.d03f5ca80e":"Obligations with a clock","oss-lattice-process-states.bed8854289":"Written when it happens, not reconstructed afterwards.","oss-lattice-process-states.828697f103":"Transfer record","oss-lattice-process-states.d133e97c65":"Enforced when data is read, not by a job that may not have run.","oss-lattice-process-states.c7199d9e95":"Retention","oss-lattice-process-states.3f62a78b0d":"Must exist before the system it covers may run.","oss-lattice-process-states.89dfbf6111":"Impact assessment","oss-lattice-process-states.6353b7e691":"A request against a deadline, with a response owed.","oss-lattice-process-states.8caa1f8a43":"Subject access","oss-lattice-read-or-not.5f35dd025d":"only one can be read","oss-lattice-read-or-not.37ee2545fc":"both are useful","oss-lattice-read-or-not.34118050b2":"Plain","oss-lattice-read-or-not.89a1879315":"both useful","oss-lattice-read-or-not.c3f53522e3":"Two kinds of helper","oss-lattice-read-or-not.0d2d675c2b":"It points at other people.","oss-lattice-read-or-not.879fbf7bc1":"Ask the second why","oss-lattice-read-or-not.b87e60951d":"It points at a line.","oss-lattice-read-or-not.e1662f0b55":"Ask the first why","oss-lattice-read-or-not.f73c922657":"Shown many past cases, and answers with something that resembles them.","oss-lattice-read-or-not.8b73dba5f4":"Works it out","oss-lattice-read-or-not.9dbdb35376":"Fifty years of this, and nobody objects, because you can read the rule.","oss-lattice-read-or-not.140fe9340b":"Follows a rule","oss-lattice-reconstruction.89a6f7a564":"an argument, not a record","oss-lattice-reconstruction.b2a4f1557d":"None of it is the record.","oss-lattice-reconstruction.97ebdbb60c":"Every piece of it is true.","oss-lattice-reconstruction.fe6f0e738a":", which are the ones people ask about","oss-lattice-reconstruction.402b84ff07":"weakest on the oldest decisions","oss-lattice-reconstruction.6734b3b497":"four days of work, every time it is asked","oss-lattice-reconstruction.1890b6439b":"Probably right. Assembled by the organisation being asked, from sources it controls,\n              about a decision nobody recorded.","oss-lattice-reconstruction.ee26c997e4":"\"It would have been the account age rule, at version three, and Credit Risk\n              owned it at the time.\"","oss-lattice-reconstruction.87b5ae9bdd":"what you hand over","oss-lattice-reconstruction.0c18132cdf":"which rule declined this customer in March, and who approved it","oss-lattice-reconstruction.37b4588725":"the question","oss-lattice-reconstruction.5fca457baf":"illustrative, assembled after the fact","oss-lattice-reconstruction.89e3566dfa":"one source missing","oss-lattice-reconstruction.d1cf64c251":"The March decline, reconstructed","oss-lattice-reconstruction.094b763b4c":"not found","oss-lattice-reconstruction.83170ba883":"If it still exists. It does not.","oss-lattice-reconstruction.46dcbc0456":"A spreadsheet somebody made","oss-lattice-reconstruction.ba08e904de":"one day","oss-lattice-reconstruction.5c35675664":"Asked what they remember. One has since left.","oss-lattice-reconstruction.f5b04b9dc7":"Two people who were there","oss-lattice-reconstruction.4341e849b8":"Read to guess which version was live at the time.","oss-lattice-reconstruction.f67621a63e":"A deployment log","oss-lattice-reconstruction.a083717479":"half a day","oss-lattice-reconstruction.0b79ae0edf":"Pulled from wherever they live now, not from where they lived in March.","oss-lattice-reconstruction.29d088d96e":"The current rules","oss-lattice-register-gives.4a09e653f9":"rather than a meeting","oss-lattice-register-gives.4fd7c1a435":"governance as a fact","oss-lattice-register-gives.1e8d3f98c4":"The turn","oss-lattice-register-gives.518afaaa0f":"that scattered rules cannot","oss-lattice-register-gives.cd2f412f9c":"What a register gives you","oss-lattice-register-gives.536f2dc6b3":"Which rule applied returns a name, a version and its text.","oss-lattice-register-gives.b15136f5ac":"An answer","oss-lattice-register-gives.2220fb478f":"What changed since last quarter, as three lines rather than a project.","oss-lattice-register-gives.13cd48fd9f":"A comparison","oss-lattice-register-gives.2f7d3c9790":"Each rule amended in its own right, with a date and an approver.","oss-lattice-register-gives.b77e4ebfce":"A version","oss-lattice-register-gives.7254bf4f80":"Every rule in force, listed, with no discovery exercise first.","oss-lattice-register-gives.1bb9949fe2":"An inventory","oss-lattice-register-ops.mobile.rule":"rule","oss-lattice-register-ops.mobile.owner":"owner","oss-lattice-register-ops.mobile.version":"version","oss-lattice-register-ops.4fd7c1a435":"governance as a fact","oss-lattice-register-ops.c218413fd4":"That is the whole board item.","oss-lattice-register-ops.e006d30dbb":"Three changes, three dates, three names.","oss-lattice-register-ops.699ec5f428":"approved by S. Lindqvist","oss-lattice-register-ops.059ac01859":"20 Jun 2026","oss-lattice-register-ops.801f7dc404":"Tool reach added, first version in force","oss-lattice-register-ops.51efb4d2d1":"approved by R. Okonkwo","oss-lattice-register-ops.befa7e2c84":"14 Jan 2026","oss-lattice-register-ops.28c18ba6ce":"Account age raised to v4, threshold moved from three months to six","oss-lattice-register-ops.4b22b3a2c7":"approved by M. Achterberg","oss-lattice-register-ops.c8ecf39893":"2 Sep 2025","oss-lattice-register-ops.cf3e8fae01":"Consent raised to v7, granularity condition added","oss-lattice-register-ops.762b8b16cd":"three, with approvers","oss-lattice-register-ops.cbf851fcb2":"Changes since Q4","oss-lattice-register-ops.eddc26a36c":"next due","oss-lattice-register-ops.7c696bbf2f":"last reviewed","oss-lattice-register-ops.38af41e8d3":"in force since","oss-lattice-register-ops.bb40374d58":"what it governs","oss-lattice-register-ops.9ffcf8f72b":"illustrative entries","oss-lattice-register-ops.0a81b590ca":"two flagged","oss-lattice-register-ops.6bc7aa0f5f":"The register, as it is used","oss-lattice-register-ops.70df507bbb":"changed since last audit","oss-lattice-register-ops.f781bb97b8":"14 Jul 2026","oss-lattice-register-ops.10a584c08d":"Credit Risk","oss-lattice-register-ops.ad9b2465a8":"Automated credit decisions","oss-lattice-register-ops.e8ab4fa611":"Account age","oss-lattice-register-ops.9a11abd027":"review overdue","oss-lattice-register-ops.f0abd5bc27":"not since v1","oss-lattice-register-ops.123a7f2fcc":"Platform","oss-lattice-register-ops.68d325323f":"What software may do alone","oss-lattice-register-ops.91692496d3":"Tool reach","oss-lattice-register-ops.f5cdd9cb65":"11 Jul 2026","oss-lattice-register-ops.8e37f3ee04":"11 Jan 2026","oss-lattice-register-ops.ac5ade6cca":"3 Nov 2025","oss-lattice-register-ops.902c91d94e":"Legal","oss-lattice-register-ops.914a5c847b":"Where processing may happen","oss-lattice-register-ops.f79cd5b264":"Non-EEA transfer","oss-lattice-register-ops.66b02cac3b":"4 Aug 2026","oss-lattice-register-ops.f9437d15e0":"4 Feb 2026","oss-lattice-register-ops.b431c894e4":"Data Protection Office","oss-lattice-register-ops.d86391e82d":"Marketing use of customer data","oss-lattice-register-ops.0599298f6d":"Consent","oss-lattice-review-cycle.6d969f83d3":"no name, no inventory","oss-lattice-review-cycle.c1ca0309ed":"None of it was the review.","oss-lattice-review-cycle.b723bc37bc":"Nine of those weeks were discovery.","oss-lattice-review-cycle.04ad78000b":"One sign off","oss-lattice-review-cycle.e7cc21be0a":"One comparison","oss-lattice-review-cycle.5914af9cb6":"One export","oss-lattice-review-cycle.0f5fc61ae3":"one afternoon, one person","oss-lattice-review-cycle.0ffb0df37f":"Against a register","oss-lattice-review-cycle.8a3552903a":"Two teams implemented the same rule differently.","oss-lattice-review-cycle.c745e5a32c":"Week 10","oss-lattice-review-cycle.fb5e2782e3":"Writing it up.","oss-lattice-review-cycle.1d7216f8e0":"Week 9","oss-lattice-review-cycle.b781460f41":"Deciding whether what was found matches what the policy says.","oss-lattice-review-cycle.8222961f6a":"Weeks 5 to 8, interpretation","oss-lattice-review-cycle.b801a0a7e0":"Engineers search the codebase for anything resembling a consent check.","oss-lattice-review-cycle.24874cc147":"Weeks 1 to 4, discovery","oss-lattice-review-cycle.6056fbd3ae":"ten weeks, four people","oss-lattice-review-cycle.a07c3cc96c":"As it runs now","oss-lattice-review-cycle.18bc16fefe":"illustrative, one real pattern","oss-lattice-review-cycle.226aab0833":"ten weeks against one","oss-lattice-review-cycle.6f05680fa7":"The annual control review","oss-lattice-route.c66cc22d3c":"learned from outcomes","oss-lattice-route.5f3959ee66":"One of these you have to maintain.","oss-lattice-route.72c4bbb9cd":"Same problem, same answer.","oss-lattice-route.f8c554b119":"your code, either way","oss-lattice-route.04ebd37617":"certificate attached","oss-lattice-route.94ed7e1e01":"objective 1 204","oss-lattice-route.7bd184c1ad":"mixed integer programming","oss-lattice-route.88eae33160":"no reals","oss-lattice-route.6ef050dbbb":"linear sums","oss-lattice-route.b2abbdf9d3":"boolean vars","oss-lattice-route.f37d8735d4":"structure examined","oss-lattice-route.088c57fc5b":"the constraint","oss-lattice-route.67e1de05d2":"one machine, one answer shape","oss-lattice-route.761f0a52da":"Classified","oss-lattice-route.edf1697ce9":"five stations, and the last one loops","oss-lattice-route.14c208d300":"By hand","oss-lattice-route.34223059e9":"your call site never changes","oss-lattice-route.2b463ffe1c":"five against one","oss-lattice-route.1e747f0c27":"One constraint, two routes","oss-lattice-route.d8f4a6d254":"start again","oss-lattice-route.c3befc35e0":"Find it is not reproducible","oss-lattice-route.6cadc98fff":"and maintain it","oss-lattice-route.a1aff2aefb":"Write an adapter","oss-lattice-route.cb9f7b3fcf":"the long part","oss-lattice-route.3ea409d528":"Learn its encoding","oss-lattice-route.5031042d6f":"a week of reading","oss-lattice-route.a16b05991b":"Choose a library","oss-lattice-route.7fdb334c1a":"a day, if you know","oss-lattice-route.4824e19665":"Identify the family","oss-lattice-rule-owner.fadd408f04":"every rule has an owner","oss-lattice-rule-owner.18442d3255":"A person, with a name and a date.","oss-lattice-rule-owner.3f95aaf766":"Not the system decided.","oss-lattice-rule-owner.d998a08d22":". Once Lattice publishes in the third round, the people whose job is checking these things\n          can examine how it decides.","oss-lattice-rule-owner.726dd067a1":"like a seatbelt that clicks before the car\n          moves","oss-lattice-rule-owner.8120ed105a":"The check runs before anything happens,","oss-lattice-rule-owner.5700f3d49e":"Whoever looks into your case runs the same rule against the same facts and gets the\n              same answer. If they disagree with the answer, they are disagreeing with a rule that\n              has a name on it.","oss-lattice-rule-owner.ecdcec6d62":"what it becomes","oss-lattice-rule-owner.ec799fdbe5":"Somebody who was not involved works out what probably happened, from what they can\n              find, weeks later. Two answers people get: the system decided, and this is our policy.","oss-lattice-rule-owner.5c81ea1495":"what an appeal usually is","oss-lattice-rule-owner.c21a4b681d":"publishes in round three","oss-lattice-rule-owner.f43721bc7e":"repository","oss-lattice-rule-owner.391ff63441":"14 January 2026","oss-lattice-rule-owner.7c696bbf2f":"last reviewed","oss-lattice-rule-owner.d040c2946c":"R. Okonkwo, Credit Risk","oss-lattice-rule-owner.7f7614ec7f":"owned by","oss-lattice-rule-owner.3735bf14f4":"An account needs to have been open for six months before a limit goes up without\n            somebody reviewing it.","oss-lattice-rule-owner.4b73aced85":"in force","oss-lattice-rule-owner.db7f3cf8d9":"the rule used on your case","oss-lattice-rule-owner.9fb17eb39d":"not the system decided","oss-lattice-rule-owner.a4da8aebc9":"somebody owns it","oss-lattice-rule-owner.3cfb86547c":"The rule that decided","oss-lattice-rule-states.95769d6e84":"enforced, not reviewed","oss-lattice-rule-states.952a2ecc75":"Only the one with something behind it holds.","oss-lattice-rule-states.d16f42d3c9":"Same rule, written twice.","oss-lattice-rule-states.88785a0595":"the rule is real, and it stops nothing","oss-lattice-rule-states.e6f1d34932":"no matches","oss-lattice-rule-states.f341ef62b0":"looking for it in the build","oss-lattice-rule-states.466ed46908":"No version, no owner, no date it came into force.","oss-lattice-rule-states.a0f74a7339":"Cited by three other pages, two of which are archived.","oss-lattice-rule-states.7dc0f316c9":"Last edited March 2023, by an author who has left.","oss-lattice-rule-states.d1f1fbabd2":"\"Services must not read another service's database directly.\"","oss-lattice-rule-states.741ce1d131":"the same rule, elsewhere","oss-lattice-rule-states.8132fda735":"Written down","oss-lattice-rule-states.2191d96fda":"blocked at the boundary","oss-lattice-rule-states.98a3328fa9":"No direct data access","oss-lattice-rule-states.2241d9ed53":"Dominance","oss-lattice-rule-states.a5c666ef6f":"Defined once","oss-lattice-rule-states.2ec31196bd":"7 run","oss-lattice-rule-states.6ffca7a99a":"merge request 4471, structural checks","oss-lattice-rule-states.d787a75b07":"v3 / PLATFORM / IN FORCE","oss-lattice-rule-states.4d2d1b0e36":"NO DIRECT DATA ACCESS","oss-lattice-rule-states.d4e6a8eeb4":"REFUSED","oss-lattice-rule-states.3c4493709c":"PERMITTED","oss-lattice-rule-states.7c5d6329aa":"url(#latticeArrow)","oss-lattice-rule-states.eeae4780b0":"userSpaceOnUse","oss-lattice-rule-states.c16d62d90e":"A service graph in which one forbidden call is stopped at a barrier","oss-lattice-rule-states.e36f77aec4":"the rule as a barrier","oss-lattice-rule-states.93ff909ce2":"Enforced","oss-lattice-rule-states.96dfe8bbca":"no direct data access, v3","oss-lattice-rule-states.1c21518e1c":"only one is live","oss-lattice-rule-states.b9e70ed6f8":"One rule, in two states","oss-lattice-rule-states-biz.5a9c9896ad":"they have no identity","oss-lattice-rule-states-biz.997ae32924":"the rules exist","oss-lattice-rule-states-biz.1fff6a3166":"Pattern","oss-lattice-rule-states-biz.8f9bec3460":"with a rule that has no identity","oss-lattice-rule-states-biz.ba6a7c6a5d":"What you cannot do","oss-lattice-rule-states-biz.64a2b9a1df":"Nobody can prove it is unused, so nothing is removed.","oss-lattice-rule-states-biz.6b49e9da37":"Retire it","oss-lattice-rule-states-biz.12fc1b9c31":"Which rule declined this has no answer with a name in it.","oss-lattice-rule-states-biz.a82172578d":"Point at it","oss-lattice-rule-states-biz.0591d4423c":"A change is a deployment, not a dated amendment.","oss-lattice-rule-states-biz.349b9dc5ac":"Version it","oss-lattice-rule-states-biz.6c2bfb3ba2":"Review starts with discovery, every time.","oss-lattice-rule-states-biz.f70f7108e8":"Inventory it","oss-lattice-run-places.2dced1945f":"it stays put","oss-lattice-run-places.b0cc26e4ee":"you choose","oss-lattice-run-places.c82d1b09cf":"EU","oss-lattice-run-places.b2136468d2":"you choose the place","oss-lattice-run-places.1d197d39c5":"Where it runs","oss-lattice-run-places.a9690b2af0":"Nothing on the path of a decision crosses a border.","oss-lattice-run-places.f5217b7f96":"Outside service","oss-lattice-run-places.a5c1f29924":"The decision stays inside the European Union.","oss-lattice-run-places.5d1cc3c5c6":"Jurisdiction","oss-lattice-run-places.513ab99958":"A small companion next to what you already operate.","oss-lattice-run-places.4188eb7dc2":"Your systems","oss-lattice-run-places.1ffe14aeb8":"Beside","oss-lattice-run-places.12a7127db7":"On servers you control, behind your own walls.","oss-lattice-run-places.9d914bfcf1":"Building","oss-lattice-run-places.1be0035c25":"Own","oss-lattice-run-places.6eef664840":"None","oss-lattice-runtime-checks.0c92881cd4":"the register disposes","oss-lattice-runtime-checks.e221c870d7":"the software proposes","oss-lattice-runtime-checks.93fd709f8a":"nine checks, four of them here","oss-lattice-runtime-checks.c4740e4ca2":"Runtime","oss-lattice-runtime-checks.0f30d139d2":"Governing autonomous action","oss-lattice-runtime-checks.d4c6227fb2":"The same outcome record as any other rule, for every action.","oss-lattice-runtime-checks.6deecea5a1":"With what record","oss-lattice-runtime-checks.935bf6824f":"Untrusted logic runs metered and stops when the budget is spent.","oss-lattice-runtime-checks.8bcb3d390a":"How much work","oss-lattice-runtime-checks.9cf2185264":"Paths and resources granted explicitly rather than assumed.","oss-lattice-runtime-checks.b267fcb1e2":"What it reaches","oss-lattice-runtime-checks.79196c7ba0":"Rate limits enforced in process, not requested in a prompt.","oss-lattice-runtime-checks.bd88489720":"How often","oss-lattice-shadow-findings.b1c0c0d0d3":"every step reverses","oss-lattice-shadow-findings.1cd5b643d0":"They were the same rule, read twice.","oss-lattice-shadow-findings.ae41653775":"Most disagreements were not errors.","oss-lattice-shadow-findings.bb78089383":"owner and recommendation","oss-lattice-shadow-findings.2a19d45a21":"disagreements, grouped below","oss-lattice-shadow-findings.fdf47fd148":"decisions compared","oss-lattice-shadow-findings.d3f2311914":"identical","oss-lattice-shadow-findings.a82d7d3928":"illustrative figures","oss-lattice-shadow-findings.091a67cf13":"acting on nothing","oss-lattice-shadow-findings.1397a913ff":"Shadow run, six weeks","oss-lattice-shadow-findings.758e82dd99":"Correct, and check the decisions it touched.","oss-lattice-shadow-findings.10a584c08d":"Credit Risk","oss-lattice-shadow-findings.9240e16b24":"A threshold transcribed wrongly when the rule was last changed.","oss-lattice-shadow-findings.c4c7a474e7":"Genuine error","oss-lattice-shadow-findings.1b56bbf06e":"Retire the second copy and record the date.","oss-lattice-shadow-findings.a1fdaa6b2a":"Operations","oss-lattice-shadow-findings.53d78c37c4":"Withdrawn from the platform in 2024 and still live in the batch path.","oss-lattice-shadow-findings.92547ca5e9":"A rule retired in one system, not the other","oss-lattice-shadow-findings.030bdccfaa":"Decide which reading stands, then amend once.","oss-lattice-shadow-findings.b431c894e4":"Data Protection Office","oss-lattice-shadow-findings.83e7b16a96":"Two teams each applied a defensible reading of the same policy, consistently, for years.","oss-lattice-shadow-findings.9a04a9d963":"One ambiguous clause, read two ways","oss-lattice-shape-list.ea070936b2":"the question picks","oss-lattice-shape-list.041ebee957":"generation and reporting complete the six","oss-lattice-shape-list.6848ce552e":"Outcomes","oss-lattice-shape-list.670c3fb5e0":"six shapes, four of them here","oss-lattice-shape-list.f436f4a952":"What each one hands back","oss-lattice-shape-list.36cc7a5d90":"Steps, a schedule, a cost, and a dependency graph.","oss-lattice-shape-list.ae2f98a099":"Plan","oss-lattice-shape-list.5ff04d0854":"Passed with a proof, or failed with the counterexample.","oss-lattice-shape-list.03128bed90":"Verification","oss-lattice-shape-list.64713a4bbc":"The choice, its value, a certificate, and the runners up.","oss-lattice-shape-list.d1f8e5ea93":"Selection","oss-lattice-shape-list.69c8724ee0":"Accept or reject, an explanation, and a confidence.","oss-lattice-shape-list.7f59a1f1d5":"Decision","oss-lattice-stays-steady.241d9425f4":"they change for everybody","oss-lattice-stays-steady.9029909b5d":"when they change","oss-lattice-stays-steady.846ac5efea":"three plain guarantees, however clever the rest gets","oss-lattice-stays-steady.cf9b77061f":"Open","oss-lattice-stays-steady.4655ab6084":"What stays steady","oss-lattice-stays-steady.2b867fcb8f":"So it is possible to say what the rules were last spring.","oss-lattice-stays-steady.e738ee3e8b":"The old versions are kept","oss-lattice-stays-steady.727edd6bf4":"Kept","oss-lattice-stays-steady.a2aa47f42e":"One set of rules, reaching every country at the same moment.","oss-lattice-stays-steady.e3273169bb":"Everyone gets the same one","oss-lattice-stays-steady.b76aee974c":"Same","oss-lattice-stays-steady.6cd9eb5d49":"In words, in one place, not buried in how something was built.","oss-lattice-stays-steady.7fbc068f1d":"The rule is written down","oss-lattice-stays-steady.719ea396ad":"Clear","oss-lattice-store-tiers.0669f029e7":"run it on your hardware","oss-lattice-store-tiers.31122ca6dc":"the benchmark ships with it","oss-lattice-store-tiers.65184247f7":"checkable once the repository publishes","oss-lattice-store-tiers.9550373e8b":"Measured","oss-lattice-store-tiers.15e882d31c":"Where a lookup stopped","oss-lattice-store-tiers.921843464c":"Single thread at full coverage. Scales with cores.","oss-lattice-store-tiers.85005cca52":"Sustained","oss-lattice-store-tiers.ea5d27cefc":"Compressed block, decompressed on access.","oss-lattice-store-tiers.591f787e5e":"Cold","oss-lattice-store-tiers.1b2e7186fb":"39.3 ns","oss-lattice-store-tiers.f9aba7879b":"One aligned read on a cache line boundary.","oss-lattice-store-tiers.2dfa66079d":"Standard","oss-lattice-store-tiers.bbc43ecbbf":"6.6 ns","oss-lattice-store-tiers.d87e7fd07f":"In the hot section, promoted by access count.","oss-lattice-store-tiers.8769483c20":"Resident","oss-lattice-store-tiers.33a00b17c6":"1.36 ns","oss-lattice-straight-with-you.eedf12e636":"they stop being invisible","oss-lattice-straight-with-you.6e964c18f0":"unfair rules stay unfair","oss-lattice-straight-with-you.2501c65292":"Straight","oss-lattice-straight-with-you.82cfd9881a":"and we would rather say so","oss-lattice-straight-with-you.dcdf2d9f3f":"What this does not fix","oss-lattice-straight-with-you.c700e6549c":"Nothing does. It makes the rules checkable.","oss-lattice-straight-with-you.da4a51b0d1":"Make anyone compliant","oss-lattice-straight-with-you.713f0e8dc6":"That is the job of the owner, and there is one.","oss-lattice-straight-with-you.724c707723":"Answer for the rule","oss-lattice-straight-with-you.30a5e4b0c6":"An unfair rule applied consistently is still unfair.","oss-lattice-straight-with-you.2302d622eb":"Make a rule kind","oss-lattice-straight-with-you.28779b947a":"It applies them. Whether they are fair is a question for people.","oss-lattice-straight-with-you.dbb3de01a4":"Judge the rules","oss-lattice-today-count.673deb4810":"and a person saw none","oss-lattice-today-count.77a795c443":"four before lunch","oss-lattice-today-count.34118050b2":"Plain","oss-lattice-today-count.e7bfc3673b":"none of which you watched happen","oss-lattice-today-count.560cc833e6":"Decided about you today","oss-lattice-today-count.41f70856d7":"Something read it and moved it along.","oss-lattice-today-count.41dc798a0e":"On a form","oss-lattice-today-count.97292b6a9d":"A limit was looked at, and left where it was.","oss-lattice-today-count.5e45cf57a0":"At the bank","oss-lattice-today-count.2264c289ce":"Something chose a different depot for a parcel.","oss-lattice-today-count.7884d39af9":"On the way","oss-lattice-today-count.3f507900b0":"Something checked the card and let the payment through.","oss-lattice-today-count.b56a5bb40a":"At the shop","oss-lattice-two-helpers.5f35dd025d":"only one can be read","oss-lattice-two-helpers.dde1a01c7d":"Only one of them can show its working.","oss-lattice-two-helpers.e442c5fa36":"Same words, same outcome.","oss-lattice-two-helpers.ad058eefc5":"It is to write down what may and may not happen, and hold the second one\n          to it.","oss-lattice-two-helpers.fa378e7875":"The answer is not to go back to\n          calculators.","oss-lattice-two-helpers.7c92e7a4c0":"Both of these are worth having. The second copes with situations nobody anticipated,\n          which is exactly why it is hard to question.","oss-lattice-two-helpers.f9300aeace":"There is no line to point at, because there never was one","oss-lattice-two-helpers.d9a8827ed7":"Gives a quick guess that sounds sure of itself, even when it is wrong. Ask why, and\n              the honest answer is that your case resembled other cases.","oss-lattice-two-helpers.c524cdf0f6":"Not yet.","oss-lattice-two-helpers.3a64a8f678":"something working it out","oss-lattice-two-helpers.4a33958da7":"There is a line to point at, and you can read it","oss-lattice-two-helpers.a8f26f99cf":"An account needs to be six months old before a limit goes up without somebody\n              reviewing it. Yours has been open four months.","oss-lattice-two-helpers.ffe365b28f":"something following a rule","oss-lattice-two-helpers.107408410e":"can I raise my limit?","oss-lattice-two-helpers.5b0f4fe647":"You ask:","oss-lattice-two-helpers.37ee2545fc":"both are useful","oss-lattice-two-helpers.8523d0e828":"one can be read","oss-lattice-two-helpers.415878f088":"The same question, twice","oss-lattice-two-questions.8e9e8cac87":"is the one nobody can answer","oss-lattice-two-questions.89b9cf317d":"the second question","oss-lattice-two-questions.cce3962ad0":"Detection","oss-lattice-two-questions.d720692337":"once of the input, once of the training set","oss-lattice-two-questions.3790c88fd2":"Asked twice","oss-lattice-two-questions.357a291216":"Context rules candidates out, and the elimination is recorded.","oss-lattice-two-questions.5d094e3d5e":"Then eliminated","oss-lattice-two-questions.dda92725d3":"Format and checksum checks fire, deliberately catching too much.","oss-lattice-two-questions.7da2abbbdb":"Proposed generously","oss-lattice-two-questions.1cdcf24998":"The training set, assembled before anybody was asking.","oss-lattice-two-questions.19896010fd":"What it learned from","oss-lattice-two-questions.50336ade55":"The fields present at decision time, checked before anything acts.","oss-lattice-two-questions.c6bd66604c":"What goes in","oss-lattice-unfair-visible.f01517ce20":"applies rules, does not judge them","oss-lattice-unfair-visible.4606074a4b":"They stop being invisible.","oss-lattice-unfair-visible.9916b7be19":"Unfair rules stay unfair.","oss-lattice-unfair-visible.8563259f4f":"What changes is that there\n          is something to raise, somebody to raise it with, and a record of how long it ran.","oss-lattice-unfair-visible.84afd38e37":"Whether the rules are right stays a question for people.","oss-lattice-unfair-visible.f7e024f050":"The rule is exactly as unfair on both sides, and this does not make it fair.","oss-lattice-unfair-visible.9c054db6dc":"worked out from examples","oss-lattice-unfair-visible.b15641d09a":"written down","oss-lattice-unfair-visible.953cea8fb6":"Applications from this postcode need a second check before approval.","oss-lattice-unfair-visible.f7fffb4c5e":"being straight with you","oss-lattice-unfair-visible.d97971b043":"unfair in both","oss-lattice-unfair-visible.5f306338c7":"An unfair rule, twice","oss-lattice-unfair-visible.2b4f81914f":"Its reach is a guess, and the guess is always low.","oss-lattice-unfair-visible.329155fb1e":"It has no date, so nobody can say when it started.","oss-lattice-unfair-visible.68e66981d7":"Nobody owns it, so there is nobody to take it to.","oss-lattice-unfair-visible.824d2de0bf":"It can only be suspected, from the pattern of who gets turned down.","oss-lattice-unfair-visible.fd6a96260a":"It lists every decision it touched, so the harm has a size.","oss-lattice-unfair-visible.5cbb48840d":"It carries the date it came into force, and the date it changed.","oss-lattice-unfair-visible.1a915e0855":"It has a name against it, so there is somebody to argue with.","oss-lattice-unfair-visible.23c6a0a2ea":"It can be read, by you and by anyone else.","oss-lattice-watch-one.8f535464a4":"it checks first","oss-lattice-watch-one.96de9cd6df":"Step four is the one most systems skip.","oss-lattice-watch-one.7c423939af":"Four beats, in that order.","oss-lattice-watch-one.b18437d842":"That order matters more than\n          it sounds. The check comes first every time, rather than whenever there is room for it, and\n          rather than afterwards when somebody reviews a sample.","oss-lattice-watch-one.cb1e54271e":"Nothing happens to the money until the check is done.","oss-lattice-watch-one.29b096f659":"Less time than the screen took to change. You did not wait for the check.","oss-lattice-watch-one.31f0b544f3":"how long it took","oss-lattice-watch-one.6059468289":"And get the rule back in words, not a reference number. On the day, not after a\n              complaint.","oss-lattice-watch-one.ba8f695337":"you can ask why","oss-lattice-watch-one.2b18b1cd62":"Contributions under 100 euro do not need a second check. Yours was 50.","oss-lattice-watch-one.51c9043ae8":"Done, and here is the rule it used","oss-lattice-watch-one.8233aa812b":"it answers","oss-lattice-watch-one.8ba99c7871":"it checks the rules","oss-lattice-watch-one.e2e61bb97e":"Typed on a Tuesday evening, from the app, like any other transfer.","oss-lattice-watch-one.9faead4b32":"Add 50 euro to my pension","oss-lattice-watch-one.16f9012579":"you ask","oss-lattice-watch-one.d1292b13aa":"nothing to know beforehand","oss-lattice-watch-one.7e5924ee45":"the check comes first","oss-lattice-watch-one.629723dd04":"A pension top up, slowly","oss-lattice-what-you-get.64a2310fd0":"rather than a complaint","oss-lattice-what-you-get.1b05ef85cc":"a conversation that ends","oss-lattice-what-you-get.9caa367403":"Honest","oss-lattice-what-you-get.bd9d28c609":"instead of a flat no","oss-lattice-what-you-get.86f2216df0":"What you should get back","oss-lattice-what-you-get.7645f9b750":"When it changes, so you know whether to wait or to act.","oss-lattice-what-you-get.f3488c72aa":"The date","oss-lattice-what-you-get.05fd4a20e1":"Which specific thing fell short, and by how much.","oss-lattice-what-you-get.354e828eee":"The fact","oss-lattice-what-you-get.fc4290ef60":"Written in ordinary words, not a reference number.","oss-lattice-what-you-get.0056e788fc":"The rule","oss-lattice-what-you-get.f54f551c4a":"Not approved. The part every system already gives you.","oss-lattice-what-you-get.7011b1a621":"The answer","oss-lattice-where-it-runs.19f7b58dae":"no external service","oss-lattice-where-it-runs.fa0af0dfd3":"It stays put.","oss-lattice-where-it-runs.3e2398a6c3":"You choose the place.","oss-lattice-where-it-runs.81f4358d55":"None of these is waived. They do not apply, because there is nothing external in the\n            decision path for them to apply to.","oss-lattice-where-it-runs.89d0589234":"What you do not have to produce","oss-lattice-where-it-runs.c35412161f":"One and the same file runs in every place. No outside service sits on the path of a\n              decision, so nothing crosses a border you did not choose.","oss-lattice-where-it-runs.ee4a590f11":"eu jurisdiction","oss-lattice-where-it-runs.a50057b85f":"nothing on the path","oss-lattice-where-it-runs.af1be1e0f2":"Where the decision is made","oss-lattice-where-it-runs.a5842e9b78":"Behaviour cannot change beneath you between one week and the next.","oss-lattice-where-it-runs.0b41a98e9f":"Somebody else's release schedule","oss-lattice-where-it-runs.1f6dfb79fa":"No endpoint of ours can be unavailable during your incident.","oss-lattice-where-it-runs.4eea4dec33":"An availability dependency","oss-lattice-where-it-runs.a72a6c3687":"Nothing leaves the jurisdiction, so there is no transfer to cover.","oss-lattice-where-it-runs.3a549d54cc":"A transfer mechanism","oss-lattice-where-it-runs.dfd2c94c06":"There is no supplier in the decision path to assess.","oss-lattice-where-it-runs.f4b36fc77d":"A supplier assessment","oss-lattice-where-it-runs.4185a39b76":"in the browser, at the edge","oss-lattice-where-it-runs.f3b957d62f":"Right where people work","oss-lattice-where-it-runs.bcb58e3a71":"a small helper next door","oss-lattice-where-it-runs.cf03529cad":"Beside your own systems","oss-lattice-where-it-runs.5360685962":"on hardware you control","oss-lattice-where-it-runs.37635ed161":"In your own building","oss-lattice-where-rules-live.1d0870a260":"one decision","oss-lattice-where-rules-live.907f1fbea1":"four owners","oss-lattice-where-rules-live.51ed61aa56":"and who owns each one","oss-lattice-where-rules-live.2c2a9c03e0":"Where a governing rule ends up","oss-lattice-where-rules-live.2e159b4438":"Observed","oss-lattice-where-rules-live.2ad9a576d7":"A number chosen during tuning, owned by nobody in particular.","oss-lattice-where-rules-live.52f2a9a9ee":"A model threshold","oss-lattice-where-rules-live.c7176bb5e3":"Written after an incident. Its author has since left.","oss-lattice-where-rules-live.6c9eae26f3":"The safety filter","oss-lattice-where-rules-live.eaab0dc5df":"On the vendor's release schedule rather than yours.","oss-lattice-where-rules-live.bf0b2368d3":"The compliance module","oss-lattice-where-rules-live.3764dd62b9":"Bought for one department. Nobody outside it knows what is in there.","oss-lattice-where-rules-live.6b5b9fe6b8":"The rules engine","oss-lattice-why-not.3906c5eeed":"handleable, not just readable","oss-lattice-why-not.f0df2c1787":"Only one of them said why.","oss-lattice-why-not.83cc96e813":"Both queries returned nothing.","oss-lattice-why-not.a7822f7fcf":". That is a fetch and a retry in two months, decided without a person.\n            A violated constraint returned from the same query would not be, and the caller can\n            tell the two apart because they are different types, not different sentences.","oss-lattice-why-not.04cf31247d":"The rule was reachable, one condition was\n            absent, and the condition is","oss-lattice-why-not.81fd87c9d0":"A missing premise, named.","oss-lattice-why-not.fd3cc608bd":"what the caller receives","oss-lattice-why-not.dd691d8c6a":"missing premise, not an empty set","oss-lattice-why-not.1c4ba9e864":"Never reached.","oss-lattice-why-not.e637d8d452":"offer = true","oss-lattice-why-not.8cec6f8fad":"Satisfied, and it changes nothing.","oss-lattice-why-not.0a4ee2212c":"4 months on the record","oss-lattice-why-not.5b7f151f1c":", and not satisfied.","oss-lattice-why-not.2706edf6bb":"Required by","oss-lattice-why-not.0f88a908da":"it breaks at one premise","oss-lattice-why-not.769e3d01bd":"Customer 8842","oss-lattice-why-not.e50aaaa4b7":"held, offer extended","oss-lattice-why-not.43327ad8a9":", both premises satisfied.","oss-lattice-why-not.6ca90042ee":"Fired from","oss-lattice-why-not.7a3217a941":"Asserted on the record.","oss-lattice-why-not.a404b3b076":"the derivation closes","oss-lattice-why-not.a9a9087a11":"Customer 4471","oss-lattice-why-not.3f6155f18d":"reason has a shape","oss-lattice-why-not.3d14308384":"missing premise","oss-lattice-why-not.b493b9e87b":"One query, two records","oss-lattice-written-rule.a68b348c75":"previous versions kept","oss-lattice-written-rule.7be8791e7c":"It still answers to the left hand side.","oss-lattice-written-rule.33ae2dbf9f":"It can get as clever as it likes.","oss-lattice-written-rule.b0fdc5f7dc":"Retrained, shifting, genuinely useful, and not readable the way a rule is.","oss-lattice-written-rule.c9b9011351":"The part that decides","oss-lattice-written-rule.ff0d510e2c":"works it out","oss-lattice-written-rule.4ae1cb0acc":"holds it to them","oss-lattice-written-rule.9df4eb957f":"and never back","oss-lattice-written-rule.70cdcb8150":"What it must be able to show afterwards","oss-lattice-written-rule.4f5d99056c":"What it may never do at all","oss-lattice-written-rule.15a792b9d0":"What it has to check before acting","oss-lattice-written-rule.cff0a3a858":"Kept in words, in one place, so they read the same to everyone.","oss-lattice-written-rule.eec790e15b":"The rules it is held to","oss-lattice-written-rule.b15641d09a":"written down","oss-lattice-written-rule.d02563fe46":"in words, in one place","oss-lattice-written-rule.c3269184ab":"the arrow only goes one way","oss-lattice-written-rule.0fd4ccb252":"Two halves of one system","page-breadcrumb.c766e66518":"Breadcrumb","page-toc.7e439c353e":"On this page","section_st_a1_display-split.7c9a7c0610":"Detail","section_st_f1_cta-dark.90e40d5043":"Get started","toc-rail.f5cbdf6bfb":"Contents"}