Logic Production Systems 2

A new implementation of the LPS engine in SWI-Prolog. It reproduces the earlier engine's own recorded test runs, cycle for cycle. Build 2026-10-03T19:40:04.971Z

Examples (expand all · collapse all)

LPS2 147

# LPS2 examples LPS2's own example programs, by purpose. Each folder's README title reads `Label — what it is`: the IDE and the start page show the folder under that label and description. | Folder | What | |---|---| | [`start/`](start/README.md) | the six programs the documentation walks through | | [`collections/kowalski-book/`](collections/kowalski-book/README.md) | Kowalski's book, the chapters on time and agents | | [`agents/`](agents/README.md) | programs driving an agent: an LLM, Minecraft | | [`planning/`](planning/README.md) | PDDL planning problems, solved by LPS2's planner | | [`if/`](if/README.md) | interactive fiction: the library, the stories, Inform 7 | | [`le/`](le/README.md) | Logical English for LPS: programs written in English | | [`migration/`](migration/README.md) | other systems' programs: twins of Daml, Drools and Solidity programs in Logical English for LPS, and (`drools/drl/`) DRL files LPS2 opens directly | The original LPS corpus is in `legacy_lps1/examples`. An example is opened by name, `/ide?example=start/blocks`; old names keep working through `example_alias/2` in `src/edges/lps_http.pl`. **A folder's README.** The start page shows each folder's README in a panel (📖 *About this folder*; `src/edges/readme_panel.js`, the same file as LE2's `web_extras/landing/readme-panel.js`). A README of a substantial folder is short (about 40 lines) and has the same parts: the title (`Label — what it is`), one to three sentences on what the folder holds, **Start here** (two to four programs), **Try this** (four to seven steps with what to expect), **More** (a `DETAILS.md` beside it for the long material, the manual, and online sources) and, for twins, the **Disclaimer**. Links are written as they work on GitHub, relative to the README: a program opens in the IDE, `sub/` opens that folder's README in the panel, and any other file opens on GitHub.
- Start here 6
  
  # Start here — the shortest way in Six small programs that the tutorial and the start page open. Each shows one thing that LPS does: it plans, it draws, it reacts to a click, it keeps running while it waits for the world, or it shows the order in which LPS does things. ## Start here - [The wolf, the goat and the cabbage](goat_declarative.pl): the puzzle is stated, not solved, and LPS finds the crossings. - [Blocks](blocks.lps): a tower of seven blocks, rebuilt in the reverse order by the planner. [Blocks in 3D](blocks3d.lps) is the same, drawn in 3D. - [Café](cafe.lps): one coffee machine and three customers. The run shows, cycle by cycle, which goal the engine works on first, which action waits, and why. [How a program runs](/docs/user/tutorials/how-lps-runs) walks through it. - [Lights](lights.lps): four lamps that you switch on and off by clicking them. - [Thermostat](thermostat.lps): a program that never ends. It waits for events that you send it. ## Try this 1. Open [the wolf, the goat and the cabbage](goat_declarative.pl) and press **Run**. The status line says how many cycles the run took. 2. Look at the **Timeline** pane. Each row is a fluent: a fact that holds for a stretch of time, such as where the goat is. The events of each cycle, such as `row(south,north)`, are listed under the rows. 3. Right-click a bar on the timeline. The explanation says why that fact held at that cycle. 4. Open [Blocks in 3D](blocks3d.lps), press **Run**, then choose the **3D** pane and press ▶ to watch the tower being rebuilt. 5. Open [Lights](lights.lps). Open the **Live** panel from the top bar and start the session, then press **2D** and click the lamps. A rule refuses to switch the last lamp off. 6. Open [Thermostat](thermostat.lps), start a live session and send `temperature(18)`. The heating comes on. ## More - [Learning LPS](/docs/user/tutorials/lps-tutorial): the tutorial that walks through these programs. - [Using the editor](/docs/user/guide/ide): the panes, the menus and asking why.
  - start/blocks — blocks.lps — the example that separates the two searches, breadth-first and greedy. Seven blocks in one tower, to be rebuilt in the reverse order.…
  - start/blocks3d — blocks3d.lps — the same blocks world, in three dimensions. * * `display3d/2` is a separate declaration from `display/2` rather than * a…
  - start/cafe — cafe.lps — the order in which LPS does things, cycle by cycle. * * A café with one coffee machine. Ann and Bob are waiting when the run * starts; the…
  - start/goat_declarative — The wolf, goat and cabbage, stated rather than solved.
  - start/lights — lights.lps — a program you can click on. * * An animation can be an interface rather than a picture. A program * that defines `lps_mousedown/3`,…
  - start/thermostat — thermostat.lps — a program that never ends, waiting for the world. * * The first LPS2 example written for a *live* session rather * than for a finite…
- Logical English 19
  
  # Logical English — LPS programs written in English LPS programs written in Logical English. Each document starts with `the target language is: lps.` and states its actions, events, fluents (facts that hold for a while) and reactive rules as sentences. Most of them are programs of the older LPS collection written again in English. Five have a companion `.lps` file for what the English does not say, such as drawings. ## Start here - [The wolf, the goat and the cabbage](goat.le): the puzzle, in English. - [Bad light](badlight.le): two people who disagree about the lights, drawn in 2D from [its companion](badlight.lps). - [A loan agreement](loan_agreement.le): real dates, and a legal text behind every rule. - [Escrow](escrow.le): a buyer, a seller and an escrow agent, with their obligations. ## Try this 1. Open [the wolf, the goat and the cabbage](goat.le) and press **Run**. The **Timeline** shows the crossings, one cycle at a time. 2. Open the older version, [goat_declarative.pl](../start/goat_declarative.pl), in a second tab and run it. Switch between the tabs and compare the two programs. 3. Open [Bad light](badlight.le), press **Run**, then choose the **2D** pane and press ▶. The lamps go on and off as the two people switch them. 4. Right-click a lamp in the picture. The explanation says which event switched it, and which rule. 5. Open [the bank transfer](bank_transfer.le) and choose **View ▸ Legal view**. It opens a Logical English program without time, which says who may do what: *a payer may transfer an amount to a payee* if the payer's balance is at least that amount. ## Two runs that end in failure, on purpose [prospective_goat.le](prospective_goat.le) and [rock_paper_scissors_minimal.le](rock_paper_scissors_minimal.le) end with *failure after N cycles*. That is the expected result, and the same one the LPS1 programs they come from give: each shows a constraint refusing something, and says so in its first lines. ## More - [Logical English for LPS](/docs/user/reference/le-for-lps): the language, with a table of these programs and what each one shows. - [Using the editor: Logical English](/docs/user/guide/ide#logical-english).
  - le/badlight.le — Two agents disagreeing about the lights.
  - le/bank_transfer.le — The canonical "contract" shape: an obligation that fires on a transfer.
  - le/delivery_delay.le — Late Delivery and Penalty (Accord Project). Deadlines and elapsed time.
  - le/dining_philosophers.le — Concurrent actions, and a precondition over a set of them.
  - le/escrow.le — Multi-party obligations: buyer, seller and an escrow agent.
  - le/fee_token.le
  - le/fire_simple.le — The smallest interesting reactive rule.
  - le/functions.le — "the functions are:" in Logical English for LPS (§2.3 of LE2's language reference, docs/user/reference/language.md).
  - le/goat.le — Wolf, goat, cabbage and farmer. Composite events with recursive decomposition.
  - le/goat_declarative.le — The same puzzle, stated rather than solved: no decomposition, just denials saying when an action is possible, and one goal.
  - le/life.le — Conway's Game of Life: an intensional fluent recomputed over a grid every cycle. The stress case.
  - le/loan_agreement.le — A simplified loan agreement: real time, calendar dates, and a legal text behind every rule.
  - le/map_colouring.le — Timeless-heavy, almost no state: the constraints do the work.
  - le/prospective_goat.le — THIS RUN IS EXPECTED TO END IN FAILURE, like the LPS1 program it comes from:
  - le/rock_paper_scissors_base.le — The second LE1 specimen, re-expressed in LE2 idiom.
  - le/rock_paper_scissors_ethereum.le — The third LE1 specimen, re-expressed in LE2 idiom.
  - le/rock_paper_scissors_minimal.le — THIS RUN IS EXPECTED TO END IN FAILURE: the second player's input arrives after the game has paid out, and the constraint refuses it, which is the
  - le/self-driving-car2.le — A place is written column-row, as in 2-1.
  - le/token.le
- Interactive fiction 26
  
  # Interactive fiction — the library and the stories, on LPS Text adventures written in Logical English and run by LPS. `world.le` is the library: rooms, things, doors, people, a dozen actions, as in Inform 7's standard rules. `turns.le` is the clock, counted in turns. Every other `.le` file is a story that includes the library, and most of them are Inform 7 programs brought across. ## Start here - [Doors](doors.le): the smallest story, a hall and a door that must be opened before you can go east. - [Alice](alice.le): chapters one and two of *Alice's Adventures in Wonderland*, the showcase. - [IQ Test](iqtest.le): a character asked to fetch something through a locked case. - [The Inform sources](inform/): the Inform 7 programs these stories are read from. ## Try this 1. Open [Doors](doors.le) and press **Play** in the top bar. The play panel opens on the hall. 2. Type `e`. The door is closed, so there is no way east, and the story says so. 3. Type `why`. The answer names the rule and the fact that refused the move. 4. Type `open door`, then `e`. Now you are in the garden. 5. Open [Alice](alice.le), press **Play**, and play until Alice finds the bottle. Press **Fork** to start a second game from there, play it differently, and press **Diff** to see what happened in one game and not in the other. ## More - [Details](DETAILS.md): every story, how commands are read, and the conventions of the library. - [LPS for Inform users](/docs/user/tutorials/inform-users): the tutorial. - [Inform 7 and LPS](/docs/user/integrations/inform-7): how an Inform source becomes a story.
  - if/alice.le — alice.le — Alice's Adventures in Wonderland, chapters I and II, as a story on the library (docs/project/plans/InformPlan.md phase 3). The text is…
  - if/alice_garden.le — alice_garden.le — the other path through alice.le: take the key first, then drink, and walk into the garden. Everything is alice.le's (which brings…
  - if/alice_pure_lps.le — alice_pure_lps.le — alice.le without the turn.
  - if/boston_cream.le — Inform Recipe Book, Boston Cream (Goal-Seeking Characters), the first seven turns: the player frees the key, opens the case, climbs in and locks it
  - if/doors.le — A door, after Writing with Inform §3.12 (hand-written, not a test case):
  - if/implicit_connections.le — Inform test case ImplicitConnections:
  - if/iqtest.le — Inform Recipe Book, IQ Test (phase 0's second spike), on the library. The two "Before someone" rules are the library's fetch plan; the story only
  - if/mre.le — Inform Recipe Book, MRE (Future events), phase 0's third spike, on the library. The clock and the turn are the library's; the story adds food,
  - if/negated_rp.le — Inform test case NegatedRP:
  - if/nothing_as_term.le — Inform test case NothingAsTerm:
  - if/npc_going.le — Inform test case NPCGoingTwistily:
  - if/regarding.le — Inform test case Regarding (the state half of it):
  - if/scene.le — Inform test case C9SceneEndSequence, on the library (phase 0's first spike):
  - if/turns.le — turns.le — the clock: Inform's turn as a layer over LPS cycles.
  - if/world.le — world.le — the interactive-fiction library, phase 1 of docs/project/plans/InformPlan.md.
  - Inform 7 11
    
    if/inform/BostonCream.ni
    
    if/inform/C9SceneEndSequence.ni
    
    if/inform/GoingSouthIn.ni
    
    if/inform/IQTest.ni
    
    if/inform/ImplicitConnections.ni
    
    if/inform/MRE.ni
    
    if/inform/NPCGoingTwistily.ni
    
    if/inform/NegatedRP.ni
    
    if/inform/NothingAsTerm.ni
    
    if/inform/Regarding.ni
    
    if/inform/TakingInventory.ni
- Planning 21
  
  # Planning — PDDL problems, solved by LPS2's planner Classical planning problems written in PDDL, the Planning Domain Definition Language: blocks, gripper, towers of Hanoi, logistics, an elevator, a rover and lights. Each problem is one file, and its domain is another. LPS2 turns the pair into an LPS program when it opens the problem, and plans with its own planner. ## Start here - [Blocks, problem 1](blocks-p1.pddl): four blocks on a table, to be stacked into one tower. - [Towers of Hanoi, problem 1](hanoi-p1.pddl): the classic puzzle. - [Lights, problem 1](lights-p1.pddl): a domain that uses types, `or`, conditions on every object, and effects that depend on the state. ## Try this 1. Open [blocks, problem 1](blocks-p1.pddl). The editor shows the LPS program written from it, with a note saying which two files it came from. 2. Press **Run**. On the **Timeline**, one action runs in each cycle: pick up `b`, stack it on `a`, then `c`, then `d`, in six steps. 3. Choose **View ▸ The original this was converted from** to see the PDDL beside the program. 4. Open [Hanoi](hanoi-p1.pddl) and compare how long its plan is. ## More - [PDDL and LPS](/docs/user/integrations/pddl): how the files are read and paired, how the plans are checked, and the traps. - [The International Planning Competition](https://www.icaps-conference.org/competitions/), where these domains come from.
  - planning/blocks-domain.pddl — ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; 4 Op-blocks world ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  - planning/blocks-p1.pddl
  - planning/blocks-p2.pddl
  - planning/blocks-p3.pddl
  - planning/elevator-domain.pddl — Miconic-style elevator, STRIPS subset.
  - planning/elevator-p1.pddl — Two passengers, four floors. Optimal is 6 actions.
  - planning/elevator-p2.pddl — One passenger going down: the `down` action has to be used, which the up-only problems never exercise. Optimal is 4.
  - planning/gripper-domain.pddl
  - planning/gripper-p1.pddl
  - planning/gripper-p2.pddl
  - planning/hanoi-domain.pddl — Towers of Hanoi, STRIPS.
  - planning/hanoi-p1.pddl — Three discs. The optimal plan is 2^3 - 1 = 7 moves, which makes this a useful check on the planner: any answer other than 7 is suboptimal by a
  - planning/hanoi-p2.pddl — Two discs — 3 moves optimal. Here so there is a hanoi problem that finishes quickly under breadth-first search as well as under the heuristic.
  - planning/lights-domain.pddl — Lights: a caretaker, rooms joined by doors, lamps on switches. Written for LPS2 to exercise what goes beyond STRIPS: typed parameters and objects,
  - planning/lights-p1.pddl — A negative goal: the broken lamp in the study must end up off.
  - planning/lights-p2.pddl — A disjunctive goal with a quantifier: some lamp in the kitchen is on, or the kitchen is tidy. `wall-switch` is a switch, not a room, so a plan that
  - planning/logistics-domain.pddl
  - planning/logistics-p1.pddl
  - planning/rover-domain.pddl — Rovers, the sampling-and-communicating core.
  - planning/rover-p1.pddl — One rover, one store, one soil sample to fetch and radio home.
  - planning/rover-p2.pddl — Both samples, so the store has to be dropped in between. This is the problem the `drop` action exists for.
- Agents 5
  
  # Agents — LPS driving something outside it Programs in which LPS decides and something outside it acts: a language model or a game character. The program's rules and constraints stay in charge, and every action can be asked why it was taken or refused. ## Start here - [Language model agent](llm/): a language model proposes actions, and an approval rule decides whether they run. - [Minecraft](minecraft/): a bot in a Minecraft world, with LPS choosing what it does. ## Try this 1. Open [the approval gate](llm/approval_ide.lps) and read its opening comment: it is a six-step walk-through in the live panel. 2. Open [the hungry bot](minecraft/hungry.lps) and press **Run**. The bot is hungry and sees a cow, but it is badly hurt. 3. Right-click the timeline and ask `why_not(happened(attack(cow)), 4)`. A constraint forbids attacking while health is low, and the answer names it. ## More - [LPS over MCP](/docs/user/api/mcp): the same engine offered to an agent as a set of tools (the Model Context Protocol).
  - LLM agent 2
    
    agents/llm/approval — approval.lps — Appendix C's approval gate, as a running program (Part II). * * The claim the whole architecture rests on: **the model is never the…
    
    agents/llm/approval_ide — approval_ide.lps — the Part II safety property, from the IDE alone. * * `approval.lps` next to this file is the same program driven by a Node script…
  - Minecraft 3
    
    agents/minecraft/craft — craft.lps — planning over crafting (Part III). * * `achieve has(wooden_pickaxe)` and let the planner find the chain: chop a * tree, turn logs into…
    
    agents/minecraft/hungry — hungry.lps — a constraint blocking an action, and then explaining itself. * * The same rules as safety.lps, with the world scripted so the scenario…
    
    agents/minecraft/safety — safety.lps — the supervisory tier of a Minecraft agent (Part III, §V.4). * * The bot's *reflexes* live in JavaScript: walking, jumping, swinging,…
- Collections 12
  
  # Collections — examples of a book Programs taken from a book, kept together so that they can be read beside it. ## Start here - [Kowalski's book](kowalski-book/): *Computational Logic and Human Thinking*, the chapters on time, agents and the event calculus, as twelve LPS programs. Each is also written in Logical English. ## More - The chapters of the book without time are Logical English programs, in [Logical English 2's collection](https://github.com/LogicalContractsOrg/LogicalEnglish2/tree/main/examples/moreExamples/collections/kowalski-book).
  - Kowalski's book 12
    
    collections/kowalski-book/citizenship_time.le — lps-converted-from: citizenship_time.lps This document was written from the LPS program citizenship_time.lps, which says the same thing in the older…
    
    collections/kowalski-book/event_calculus.le — lps-converted-from: event_calculus.lps This document was written from the LPS program event_calculus.lps, which says the same thing in the older…
    
    collections/kowalski-book/fox_crow.le — lps-converted-from: fox_crow.lps This document was written from the LPS program fox_crow.lps, which says the same thing in the older syntax. The two…
    
    collections/kowalski-book/hunger.le — lps-converted-from: hunger.lps This document was written from the LPS program hunger.lps, which says the same thing in the older syntax. The two run…
    
    collections/kowalski-book/louse.le — lps-converted-from: louse.lps This document was written from the LPS program louse.lps, which says the same thing in the older syntax. The two run…
    
    collections/kowalski-book/mars_explorer.le — lps-converted-from: mars_explorer.lps This document was written from the LPS program mars_explorer.lps, which says the same thing in the older…
    
    collections/kowalski-book/penalty.le — lps-converted-from: penalty.lps This document was written from the LPS program penalty.lps, which says the same thing in the older syntax. The two…
    
    collections/kowalski-book/plan_generation.le — lps-converted-from: plan_generation.lps This document was written from the LPS program plan_generation.lps, which says the same thing in the older…
    
    collections/kowalski-book/trolley.le — lps-converted-from: trolley.lps This document was written from the LPS program trolley.lps, which says the same thing in the older syntax. The two…
    
    collections/kowalski-book/umbrella.le — lps-converted-from: umbrella.lps This document was written from the LPS program umbrella.lps, which says the same thing in the older syntax. The two…
    
    collections/kowalski-book/underground.le — lps-converted-from: underground.lps This document was written from the LPS program underground.lps, which says the same thing in the older syntax.…
    
    collections/kowalski-book/violations.le — lps-converted-from: violations.lps This document was written from the LPS program violations.lps, which says the same thing in the older syntax. The…
- Migration twins 58
  
  # Migration twins — other systems' programs in Logical English for LPS Programs of other systems, translated into Logical English for LPS by translators (programs that rewrite another system's program). Each translation is called a *twin*. Each twin has one folder, with its migration ledger (what was translated, and how) and the original files under `sources/`. The twins that do not need time (Blawx, LegalRuleML, Miniscript, s(CASP), OIPA) are in [Logical English 2's examples](https://github.com/LogicalContractsOrg/LogicalEnglish2/tree/main/examples/migration). ## Start here - [Daml](daml/): contracts of the Daml SDK's own templates. - [Drools](drools/): the Drools examples, as events in a world. - [L4](l4/): contracts of the L4 language — obligations with deadlines, and what follows when they are met or missed. - [Solidity](solidity/): OpenZeppelin and Circle token contracts, and a replay of real USDC transactions. ## Try this 1. Open [the pausable token](solidity/pausable/pausable.le) and press **Run**. On the **Timeline**, two calls are crossed out in red: the blockchain refused them too. 2. Right-click a crossed-out call. The answer is *refused_by_constraint*, and it names the rule that refused it. 3. Choose **View ▸ Legal view**: who may pause the token, and when. 4. Choose **View ▸ The original this was converted from** to read the Solidity contract beside the twin. ## More - [Other systems](/docs/user/integrations/index): how LPS2 reads and writes other systems' programs. ## Disclaimer A twin is written by a translator, and it is provided **"as is", without warranty of any kind**, express or implied, including any warranty that it is accurate, complete or fit for a particular purpose. A translation may be wrong: check a twin against its source before relying on it. A twin is not legal, tax, insurance, financial or other professional advice. Its authors accept no liability for any loss or damage arising from its use. Every twin repeats this notice in its opening comment; the translators write it there themselves (`twin_disclaimer` in Logical English 2's `i18n/writer_words.csv`).
  - Daml twins 22
    
    daml twin: coin_issuance 1
    
    migration/daml/coin_issuance/coin_issuance.le — Daml patterns: coin issuance by an issuer's invitation (propose and accept)
    
    daml twin: compose 7
    
    migration/daml/compose/compose.le — Daml intro, composing choices: assets, roles and an atomic trade
    
    migration/daml/compose/compose_test_asset.le — The Daml Script test_asset of the project Daml intro, composing choices: assets, roles and an atomic trade, run on its twin (compose.le, which this…
    
    migration/daml/compose/compose_test_issuance.le — The Daml Script test_issuance of the project Daml intro, composing choices: assets, roles and an atomic trade, run on its twin (compose.le, which…
    
    migration/daml/compose/compose_test_merge.le — The Daml Script test_merge of the project Daml intro, composing choices: assets, roles and an atomic trade, run on its twin (compose.le, which this…
    
    migration/daml/compose/compose_test_split.le — The Daml Script test_split of the project Daml intro, composing choices: assets, roles and an atomic trade, run on its twin (compose.le, which this…
    
    migration/daml/compose/compose_test_trade.le — The Daml Script test_trade of the project Daml intro, composing choices: assets, roles and an atomic trade, run on its twin (compose.le, which this…
    
    migration/daml/compose/compose_trade_setup.le — The Daml Script tradeSetup of the project Daml intro, composing choices: assets, roles and an atomic trade, run on its twin (compose.le, which this…
    
    daml twin: contact 1
    
    migration/daml/contact/contact.le — Daml intro, choices: a contact whose owner and party update it
    
    daml twin: locking 1
    
    migration/daml/locking/locking.le — Daml patterns: locking a coin by changing its state
    
    daml twin: multiparty 1
    
    migration/daml/multiparty/multiparty.le — Daml patterns: a multiple-party agreement signed one party at a time
    
    daml twin: parties 2
    
    migration/daml/parties/parties.le — Daml intro, parties: proposals, authorization and delegation
    
    migration/daml/parties/parties_iou_test.le — The Daml Script iou_test of the project Daml intro, parties: proposals, authorization and delegation, run on its twin (parties.le, which this program…
    
    daml twin: quickstart 2
    
    migration/daml/quickstart/quickstart.le — The quickstart IOU: issue, transfer, split, merge, and a delivery-versus-payment trade
    
    migration/daml/quickstart/quickstart_trade_test.le — The Daml Script trade_test of the project The quickstart IOU: issue, transfer, split, merge, and a delivery-versus-payment trade, run on its twin…
    
    daml twin: restrictions 1
    
    migration/daml/restrictions/restrictions.le — Daml intro, constraints: an IOU with ensure and assertMsg
    
    daml twin: simple_iou 1
    
    migration/daml/simple_iou/simple_iou.le — Daml intro, choices: an IOU transferred along a chain of owners
    
    daml twin: skeleton 1
    
    migration/daml/skeleton/skeleton.le — The SDK's skeleton: an asset its owner gives away
    
    daml twin: token 4
    
    migration/daml/token/token.le — Daml intro, Daml Script: tokens a party may only issue to itself
    
    migration/daml/token/token_token_test_1.le — The Daml Script token_test_1 of the project Daml intro, Daml Script: tokens a party may only issue to itself, run on its twin (token.le, which this…
    
    migration/daml/token/token_token_test_2.le — The Daml Script token_test_2 of the project Daml intro, Daml Script: tokens a party may only issue to itself, run on its twin (token.le, which this…
    
    migration/daml/token/token_token_test_3.le — The Daml Script token_test_3 of the project Daml intro, Daml Script: tokens a party may only issue to itself, run on its twin (token.le, which this…
  - Drools twins 6
    
    drools twin: discount 2
    
    migration/drools/discount/discount.le — Discounts by customer tier (LPS2's rule base, as valid DRL; a decision service)
    
    migration/drools/discount/discount_decision.le — Discounts by customer tier (LPS2's rule base, as valid DRL; a decision service) (the decision-service reading)
    
    drools twin: fire_alarm 1
    
    migration/drools/fire_alarm/fire_alarm.le — Fire alarm: sprinklers and an alarm (Drools examples, fire/simple)
    
    drools twin: honest_politician 1
    
    migration/drools/honest_politician/honest_politician.le — The honest politician (Drools examples, truth maintenance)
    
    drools twin: insurance 1
    
    migration/drools/insurance/insurance.le — Insurance eligibility (LPS2's rule base, as valid DRL)
    
    drools twin: shipping 1
    
    migration/drools/shipping/shipping.le — Order shipping (LPS2's rule base, as valid DRL)
  - L4 twins 15
    
    l4 twin: because_example 1
    
    migration/l4/because_example/because_example.le — because-example.l4
    
    l4 twin: ceo_performance_award 1
    
    migration/l4/ceo_performance_award/ceo_performance_award.le — ceo-performance-award.l4
    
    l4 twin: charity_obligation 1
    
    migration/l4/charity_obligation/charity_obligation.le — charity-obligation.l4
    
    l4 twin: deontic_example 1
    
    migration/l4/deontic_example/deontic_example.le — deontic-example.l4
    
    l4 twin: may_example 1
    
    migration/l4/may_example/may_example.le — may-example.l4
    
    l4 twin: module_1_examples 1
    
    migration/l4/module_1_examples/module_1_examples.le — module-1-examples.l4
    
    l4 twin: module_5_examples 1
    
    migration/l4/module_5_examples/module_5_examples.le — module-5-examples.l4
    
    l4 twin: module_6_examples 1
    
    migration/l4/module_6_examples/module_6_examples.le — module-6-examples.l4
    
    l4 twin: module_a1_regulatory_examples 1
    
    migration/l4/module_a1_regulatory_examples/module_a1_regulatory_examples.le — module-a1-regulatory-examples.l4
    
    l4 twin: module_a2_cross_cutting_examples 1
    
    migration/l4/module_a2_cross_cutting_examples/module_a2_cross_cutting_examples.le — module-a2-cross-cutting-examples.l4
    
    l4 twin: must_example 1
    
    migration/l4/must_example/must_example.le — must-example.l4
    
    l4 twin: party_example 1
    
    migration/l4/party_example/party_example.le — party-example.l4
    
    l4 twin: promissory_note 1
    
    migration/l4/promissory_note/promissory_note.le — promissory-note.l4
    
    l4 twin: sale_contract 1
    
    migration/l4/sale_contract/sale_contract.le — sale-contract.l4
    
    l4 twin: shant_example 1
    
    migration/l4/shant_example/shant_example.le — shant-example.l4
  - Solidity twins 15
    
    solidity twin: airdrop 1
    
    migration/solidity/airdrop/airdrop.le — Twin of Airdrop (contracts/Airdrop.sol: batch calls, the loops over arrays of Phase 1e (d)), translated by the Solidity translator.
    
    solidity twin: erc20 1
    
    migration/solidity/erc20/erc20.le — Twin of RefERC20 (OpenZeppelin Contracts 5.0.2, token/ERC20/ERC20.sol), translated by the Solidity translator.
    
    solidity twin: fiat_token 1
    
    migration/solidity/fiat_token/fiat_token.le — Twin of FiatTokenSubset (Circle stablecoin-evm contracts/v1 (FiatTokenV1, Ownable, Pausable, Blacklistable), transcribed to Solidity 0.8 in…
    
    solidity twin: mytoken 4
    
    migration/solidity/mytoken/erc20.le — Twin of RefERC20 (OpenZeppelin Contracts 5.0.2, token/ERC20/ERC20.sol), translated by the Solidity translator.
    
    migration/solidity/mytoken/mytoken.le — Twin of MyToken (an OpenZeppelin Wizard token: ERC20 + Ownable + Pausable (OpenZeppelin Contracts 5.0.2)), translated by the Solidity translator.
    
    migration/solidity/mytoken/ownable.le — Twin of RefOwnable (OpenZeppelin Contracts 5.0.2, access/Ownable.sol), translated by the Solidity translator.
    
    migration/solidity/mytoken/pausable.le — Twin of RefPausable (OpenZeppelin Contracts 5.0.2, utils/Pausable.sol with access/Ownable.sol), translated by the Solidity translator.
    
    solidity twin: ownable 1
    
    migration/solidity/ownable/ownable.le — Twin of RefOwnable (OpenZeppelin Contracts 5.0.2, access/Ownable.sol), translated by the Solidity translator.
    
    solidity twin: pausable 2
    
    migration/solidity/pausable/ownable.le — Twin of RefOwnable (OpenZeppelin Contracts 5.0.2, access/Ownable.sol), translated by the Solidity translator.
    
    migration/solidity/pausable/pausable.le — Twin of RefPausable (OpenZeppelin Contracts 5.0.2, utils/Pausable.sol with access/Ownable.sol), translated by the Solidity translator.
    
    solidity twin: replay 2
    
    migration/solidity/replay/usdc_window.le — Replay of 0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48 (USDC) on Ethereum mainnet, blocks 25968821 to 25968823, against the FiatToken twin (E11).
    
    migration/solidity/replay/usdc_window_12.le — Replay of 0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48 (USDC) on Ethereum mainnet, blocks 25968820 to 25968831, against the FiatToken twin (E11).
    
    solidity twin: vault 3
    
    migration/solidity/vault/vault.le — Twin of Vault (contracts/Vault.sol: a collateral vault reading a price feed (the E12 worked example)), translated by the Solidity translator.
    
    migration/solidity/vault/vault_oracle.le — The E12 convention, worked: the residue of vault.le (the `borrow` function, which calls an external price feed) filled in by the convention of
    
    migration/solidity/vault/vault_view.le — The E12 convention in a legal-readable view: an external value the contract reads (a price feed) is an ASSUMABLE template. With the price
corpus 158
- Ballot — By BK, modified by MC:
- bank account_terse — /** <examples> ?- go(Timeline).
- binaryChop
- binaryChop2 — %a(Position,Content)
- dining_philosophers_terse — this must be the FIRST directoive in the file:
- ethereumAntecedent — system fluents below will take a while to succeed, so avoid using maxTime(Cycles):
- ethereumAsync — This illustrates the use of assynchronous Ethereum calls
- goat
- just rains — just rains.lps
- lamport_clock — Lamport's clock example in LPS by Jacinto Dávila and Bob Kowalski (based on Lamport's Clock Protocol spec.)
- oneprisoner — oneprisoner.lps solving the prisoner dilema from the stand point of one agent coder: Jacinto Dávila 2007 this code is free software with the Affero…
- party
- party_minimal — This ilustrates a bug:
- readwrite — %timeout(3600).
- saidsay — %timeout(3600).
- server_space_monitor — Notice that this background server needs relaunching after SWI Prolog restarts.
- simple-smart-contract
- slamodel — slamodel.lps SLA Model as a smart contract version alfa 1.0 Jacinto Dávila
- tictactoe — slot((R,C)) :- member(R, [1,2,3]), member(C,[1,2,3]).
- CLOUT workshop 76
  - CLOUT_workshop/Escrow — From section 2.2 in http://csp2017.mimuw.edu.pl/data/uploads/papers/CSP2017_paper_24.pdf : 1. Either the Buyer or the Seller begins a transaction.…
  - CLOUT_workshop/GameWithOracle — Based on http://www.liquidity-lang.org/doc/tutorial/game.html, a single player game Simple standalone version, not on Tezos blockchain
  - CLOUT_workshop/GameWithOracleSimpler — Inspired on http://www.liquidity-lang.org/doc/tutorial/game.html, a single player game Simple standalone version, not on Tezos blockchain
  - CLOUT_workshop/RockPaperScissors — From "Step by Step Towards Creating a Safe Smart Contract: Lessons and Insights from a Cryptocurrency Lab", Delmolino et.al.
  - CLOUT_workshop/RockPaperScissors-Minimal — these could be inferred:
  - CLOUT_workshop/RockPaperScissors-Minimal-en — Formal English specification of the game:
  - CLOUT_workshop/RockPaperScissorsBase — Rock, Paper, Scissors
  - CLOUT_workshop/RockPaperScissorsBaseEN — Rock, Paper, Scissors
  - CLOUT_workshop/RockPaperScissorsEthereum — Rock, Paper, Scissors "gambling" on Ethereum
  - CLOUT_workshop/RockPaperScissorsEthereumFEn — /** <examples> ?- serve_ethereum(Address).
  - CLOUT_workshop/RockPaperScissorsServer — From "Step by Step Towards Creating a Safe Smart Contract: Lessons and Insights from a Cryptocurrency Lab", Delmolino et.al.
  - CLOUT_workshop/RockPaperScissorsServer-noProspectivePCs — From "Step by Step Towards Creating a Safe Smart Contract: Lessons and Insights from a Cryptocurrency Lab", Delmolino et.al.
  - CLOUT_workshop/SzaboLanguage_futures — /* Original first example from https://nakamotoinstitute.org/contract-language/ : future(rightA="1 round lot pork bellies", rightB="$1,500.00", p =…
  - CLOUT_workshop/SzaboLanguage_futures_failing — First example from https://nakamotoinstitute.org/contract-language/
  - CLOUT_workshop/SzaboLanguage_insurance_base — Original: (The insured is the Holder, the insurer is the Counterparty) insureGoods(goodsPremium, principal, penalty, t1, t2, goodsInsured) =…
  - CLOUT_workshop/SzaboLanguage_insurance_eternal — would never end, because the lawyer allowed foreclosing in any later future... but the reactive rule in SzaboLanguage_insurance_base.pl added a limit…
  - CLOUT_workshop/SzaboLanguage_insurance_foreclosing — should succeed because of foreclosing observe safeArrival("10 John D. tractors") at "2018-06-21T15:00".
  - CLOUT_workshop/SzaboLanguage_insurance_irrelevant_events — irrelevant events happened, but our truth prevails so we succeed...
  - CLOUT_workshop/SzaboLanguage_insurance_noncompliant — fails, claim not paid observe safeArrival("10 John D. tractors") at "2018-06-21T15:00".
  - CLOUT_workshop/SzaboLanguage_insurance_normal_claim — succeeds correctly, claim being paid observe safeArrival("10 John D. tractors") at "2018-06-21T15:00".
  - CLOUT_workshop/SzaboLanguage_insurance_tricky_claim — can't claim when it arrives
  - CLOUT_workshop/badlight — /** <examples> ?- godc(Timeline).
  - CLOUT_workshop/badlight_user — A click in a room switches its light on. Rooms have atom names
  - CLOUT_workshop/ballot — single ballot per program instance, added method names as in Solidity original http://solidity.readthedocs.io/en/v0.4.24/solidity-by-example.html
  - CLOUT_workshop/bankTransfer — Uncomment this to get an experimental 2d display: display(balance(Person,V), [from:[X,0], to:[RightX,V], label:(Person:V), type:rectangle,…
  - CLOUT_workshop/bankTransfer_lazy2d — /** <examples> ?- serve(S).
  - CLOUT_workshop/bubbleSort — bubble sort with relational data structure .
  - CLOUT_workshop/burning — /* This LPS program simulates a matrix of burning cells. A burning cell ignites neighbours towards one of several wind directions, given as a Prolog…
  - CLOUT_workshop/concurrentTowers — Note the execution of this program is very sensitive to the order in which the clauses for make_on and make_clear are written.
  - CLOUT_workshop/concurrent_towers — Note the execution of this program is very sensitive to the order in which the clauses for make_on and make_clear are written.
  - CLOUT_workshop/consolidatedLoan — consolidated loan example.
  - CLOUT_workshop/d_test — A few examples of display specifications Now there's no need for dummy fluents anymore, just use display(timeless,...).
  - CLOUT_workshop/deliveryDelay — Example from Accord Project: https://docs.google.com/document/d/1UacA_r2KGcBA2D4voDgGE8jqid-Uh4Dt09AE-shBKR0/edit# https://www.accordproject.org/ *…
  - CLOUT_workshop/derivative_contract — contract for derivative of UCITS ETF FTSE MIB https://www.bloomberg.com/quote/ETFMIB:IM INCOMPLETE, missing receiving of investment
  - CLOUT_workshop/diningPhilosophers — /** <examples> ?- go(Timeline).
  - CLOUT_workshop/diningPhilosophers-client — Dining philosophers, detaching the dining table and cutlery from the guests and their seating arrangements First start the program in…
  - CLOUT_workshop/diningPhilosophers-table — see diningPhilosphers-client.pl
  - CLOUT_workshop/email — /** <examples> ?- godc(Timeline).
  - CLOUT_workshop/employment_contract — Originally at http://demo.logicalcontracts.com/example/employment_contract.pl Employment contract, for one employee
  - CLOUT_workshop/employment_contract_base — Originally at http://demo.logicalcontracts.com/example/employment_contract.pl Employment contract, for one employee
  - CLOUT_workshop/fireRecurrent — fire2
  - CLOUT_workshop/fireSimple — /** <examples> ?- go(Timeline).
  - CLOUT_workshop/fire_recurrent — fire2
  - CLOUT_workshop/goat — wolf, goat, cabbage and farmer are objects and are located at the south margin.
  - CLOUT_workshop/goto_with_ifthenelse — Showing if-then-else originating an iteration like behavior, inspired on RAK's: An agent goes to a place if whenever the agent is not at the place…
  - CLOUT_workshop/helloemail — /** <examples> ?- godc(Timeline).
  - CLOUT_workshop/life — Conway's game of life.
  - CLOUT_workshop/life_lazyGUI — Conway's game of life.
  - CLOUT_workshop/loanAgreementPostConditions — Adapted by RAK from the simplified loan agreement in Flood and Goodenough, 2015. Contract as automaton: the computational representation of financial…
  - CLOUT_workshop/loanAgreementPostConditionsRT — Adapted by RAK from the simplified loan agreement in Flood and Goodenough, March 2017. Contract as automaton: the computational representation of…
  - CLOUT_workshop/loanAgreementPostConditionsRTbase — Adapted by RAK from the simplified loan agreement in Flood and Goodenough, March 2017. Contract as automaton: the computational representation of…
  - CLOUT_workshop/loanAgreementPostConditionsRTbaseBorrowerCures — Borrower cures a violation of covenant
  - CLOUT_workshop/loanAgreementPostConditionsRTbaseBorrowerCuresRep — Borrower cures a violation of representation or warrant
  - CLOUT_workshop/loanAgreementPostConditionsRTbaseBorrowerDefaults — The borrower defaults, by paying but not notifying the payment, the payment of 0 does not become due, and the contract terminates "correctly".
  - CLOUT_workshop/loanAgreementPostConditionsRTbaseNoComplications — The simplest case with no complications:
  - CLOUT_workshop/loanAgreementPostConditionsRTbasePaysEarly — %NOTE: this example is taking too long to run for the web (it takes about 90 seconds on barebones lps.swi), likely due to unconstrained times
  - CLOUT_workshop/loanAgreementPostConditionsRTbasePaysEarlyTricky — Borrower pays early, in violation of the contract.
  - CLOUT_workshop/loanAgreementPostConditionsRTbasePaysLate — Borrower pays late but cures the default
  - CLOUT_workshop/loan_agreement — Adapted by RAK from the simplified loan agreement in Flood and Goodenough, 2015. Contract as automaton: the computational representation of financial…
  - CLOUT_workshop/mapColouring — What happens if we add the following commented out constraint?. false paint(X,_), paint(Y,_), X\=Y.
  - CLOUT_workshop/negatedEvents — Masochistic agent
  - CLOUT_workshop/negatedEvents-FS — /** <examples> ?- go(Timeline).
  - CLOUT_workshop/prisoners — /** <examples> ?- go(Timeline).
  - CLOUT_workshop/quicksort — Prolog programs can be called from LPS.
  - CLOUT_workshop/redis_toggler — Minimal example to toggle a Redis binary tag value First you need to call (only once) create(RedisHost,Password)
  - CLOUT_workshop/rstapi_test — /* In straight Prolog: ?- restapi_login("https://ictlab.ap.ngrok.io/restapi/","USER","PASSWORD"), restapi_request('tag/devices/',ID). Some seconds…
  - CLOUT_workshop/simulateExternalEvent — Technique to simulate an "outside world" event new_lustrum(_) every 5 cycles
  - CLOUT_workshop/smartHomePrimitives — /* ?- redisclient:restapi_request_result(restapi5,R), print_term(R,[]). json([ count = 1, next = @(null), previous = @(null), results = [ json([ (id…
  - CLOUT_workshop/sortWithTime — Shortest sorting algorithm:-) A single logical implication, universally quantified on the antecedent. Maps the ordeable feature into time. Just a…
  - CLOUT_workshop/sos — RK's SOS recognizer/generator
  - CLOUT_workshop/trash — % trash.lps
  - CLOUT_workshop/turingTest — for XSB only:
  - CLOUT_workshop/use_insulin — This is based on the example in Bench-Capon, Persuasion in practical argument using value-based argumentation frameworks. Journal of Logic and…
  - simulation 3
    
    CLOUT_workshop/simulation/SimulationKit — A collection of "classes", related groups of fluents and other predicates representing some real world "object",
    
    CLOUT_workshop/simulation/cookingMachine — "if true at T then ..." is a way to "observe" (e.g. request to perform) a composite event/action test pump
    
    CLOUT_workshop/simulation/simpleConveyor — Based on https://www.youtube.com/watch?v=5ms_idvN8Tg
- forTesting 63
  - forTesting/BugEndingWithSimulatedRealTime — %maxTime(60). no need for this...
  - forTesting/DelayPenalty — Late Delivery and Penalty. In case of delayed delivery except for Force Majeure cases, the Seller shall pay to the Buyer for every 2 weeks of delay…
  - forTesting/RockPaperScissors-3players — From "Step by Step Towards Creating a Safe Smart Contract: Lessons and Insights from a Cryptocurrency Lab", Delmolino et.al.
  - forTesting/RockPaperScissors-3players-badFluent — From "Step by Step Towards Creating a Safe Smart Contract: Lessons and Insights from a Cryptocurrency Lab", Delmolino et.al.
  - forTesting/authoriseCard — Bob's April 3, 2020 email
  - forTesting/backgroundBankTransfer — golps('examples/forTesting/backgroundBankTransfer.pl',[background(ID),silent])
  - forTesting/backgroundRain — just rains.lps
  - forTesting/backgroundRain2 — golps('examples/forTesting/backgroundRain2.lps',[background(ID)])
  - forTesting/backtrackingAcrossCycles — From Sam Yong's MSc thesis report, page 78 Backtracking across cycles... works although the implementation does not do that, instead
  - forTesting/badlight2
  - forTesting/ballotTest — By BK, modified by MC:
  - forTesting/bankDoubleTransfer — following commented out: all actions are serialised, producing cumulative effects IF using updates unserializable transfer(From, To, Amount).
  - forTesting/bankTransfer1
  - forTesting/bankTransfer2 — bankTransfer
  - forTesting/bank_account_realtime — %maxTime(10).
  - forTesting/bank_transferWithhappened — Uncomment this to get an experimental 2d display: display(balance(Person,V), [from:[X,0], to:[RightX,V], label:(Person:V), type:rectangle,…
  - forTesting/bobObservationBug — Adapted by RAK from the simplified loan agreement in Flood and Goodenough, 2015. Contract as automaton: the computational representation of financial…
  - forTesting/changingFluentInAntecedent
  - forTesting/compositeEventInconsistency — Adapted by RAK from the simplified loan agreement in Flood and Goodenough, 2015. Contract as automaton: the computational representation of financial…
  - forTesting/compositeEventsInPostConditions
  - forTesting/compositeInitiateBug — %%% LPS "system library":
  - forTesting/editingActions — probably not to be used in user programs, just shaking things a bit...
  - forTesting/externalPrologEvents — Exemplify external events defined as (polled) Prolog predicates TODO: We need more control over this, to specify predicates and their calling patterns
  - forTesting/external_stuff
  - forTesting/failBetter — we need to discover that the consequent is doomed to fail, given the following observations time limit 7 is detected, so the engine stops then…
  - forTesting/failBetter2 — System primitives used next
  - forTesting/fariba_sam_bug — This illustrates the need for "backtracking" accross cycles
  - forTesting/fluentAfterEvent — %fluents total_due(_). initially total_due(100).
  - forTesting/fluentInCompositeEvent
  - forTesting/futuresContractCompliant
  - forTesting/futuresContractFailing — we need to discover that the consequent is doomed to fail, given the following observations
  - forTesting/if_then
  - forTesting/if_then_else
  - forTesting/if_then_else_with_writes — A convoluted story on the effect of implicit time variables..:
  - forTesting/implicitTimeOrdering
  - forTesting/inLineTimeExpressions
  - forTesting/intensFluentBindingTime
  - forTesting/manual_minimal — Use with option 'manual', and inject event 'a'.
  - forTesting/mapColouring
  - forTesting/meta — Using an "event meta-call" in a precondition to avoid enumerating all forbidden atomic events Building an arbitrary intensional fluent out of a state…
  - forTesting/negatedFluentInConjunction — Moving not gameOver to the end of the antecedent causes different behaviour!
  - forTesting/negatedFluentShouldNotSucceed
  - forTesting/negatedIntentionslFluent — By BK, modified by MC:
  - forTesting/neverEndingEvent — "Never-ending composite event" hack.
  - forTesting/paralellConjunctions
  - forTesting/prospectiveGoat — wolf, goat, cabbage and farmer are things and are located at the south margin locations are north and south margins
  - forTesting/prospectiveGoat2 — Basd on prospectiveGoat.pl, but with RK fixes
  - forTesting/realTimeObservations — See datetime formats in http://www.swi-prolog.org/pldoc/doc_for?object=parse_time/3
  - forTesting/real_time_constants
  - forTesting/rock_scissor_paper_bug
  - forTesting/saver — Force saving at cycle 5:
  - forTesting/serializedDice — %unserializable roll(_).
  - forTesting/simulatedTime — /** <examples> ?- go(Timeline).
  - forTesting/simulatedTimeCompositeEvent
  - forTesting/simulatedTimeCompositeEvent2 — /** <examples> ?- go(Timeline).
  - forTesting/sos — if true then sos.
  - forTesting/switchingWithTimeExpression — if lightOff then switch.
  - forTesting/terminator — Demo lps_terminate action, and Prolog system "output predicate" called as an action
  - forTesting/testNLPhook — /** <examples> ?- godc(Timeline). ?- dumplps.
  - forTesting/trash_forall — % trash.lps
  - forTesting/trash_two_locked — % trash.lps
  - forTesting/two_initiate
  - forTesting/unserializedDice

Start

Open the IDE
Open the wolf, goat and cabbage — the whole language on one page

Documentation

Learning LPS
The tutorial: from a two-line program to planning, live sessions and pictures.
How a program runs
The order in which LPS does things: the cycle, which goal goes first, when an action waits, and why a run fails.
LPS for Inform users
Interactive fiction on LPS, for Inform 7 authors: what maps onto what, and two stories worked through.
Using the editor
The IDE's manual: the panes, running, why, live sessions, the menus, and how do I…
Language reference
Every construct, the operator table, and the drawing properties.
Logical English for LPS
LPS programs written in English, construct by construct.
Glossary
Every term used in these documents, defined.
Other systems
The map of the systems LPS2 reads and writes — PDDL, Drools, Inform 7, Solidity, Daml, and the others through Logical English — and what the menus do with them.
Introducing LPS2
The longer tour: what it is, what is new since LPS1, and every input language.
LPS2 in detail
The technical companion to the tour: how LPS2 was checked against LPS1, how it is arranged, and how each feature works inside.
A summary in two pages
For deciding whether to read the rest.