Logic Production Systems 2

Examples (expand all · collapse all)

• LPS2 135

  • Start here 5

    • start/blocks — blocks.lps — the example that separates the two searches (§I.7.4).
    • start/blocks3d — blocks3d.lps — the same blocks world, in three dimensions.
    • start/goat_declarative — The wolf, goat and cabbage, stated rather than solved.
    • start/lights — lights.lps — a program you can click on.
    • start/thermostat — thermostat.lps — a program that never ends, waiting for the world.
  • Logical English 18

    • 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
    • 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
    • le/life.le — Conway's Game of Life: an intensional fluent recomputed over a grid every
    • le/loan_agreement.le — A simplified loan agreement: real time, calendar dates, and a legal text
    • le/map_colouring.le — Timeless-heavy, almost no state: the constraints do the work.
    • le/prospective_goat.le — The acceptance test for this surface language (docs/user/reference/le-for-lps.md §5):
    • 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 — The first of the three LE1 specimens, re-expressed in LE2 idiom.
    • le/token.le
  • Interactive fiction 26

    • if/alice.le — alice.le — Alice's Adventures in Wonderland, chapters I and II, as a story on
    • if/alice_garden.le — alice_garden.le — the other path through alice.le: take the key first, then
    • 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
    • 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
    • if/mre.le — Inform Recipe Book, MRE (Future events), phase 0's third spike, on the
    • 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/blocks-domain.pddl — ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    • 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
    • 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
    • planning/hanoi-p2.pddl — Two discs — 3 moves optimal. Here so there is a hanoi problem that finishes
    • planning/lights-domain.pddl — Lights: a caretaker, rooms joined by doors, lamps on switches. Written for
    • 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
    • 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
  • Agents 5

    • LLM agent 2

      • agents/llm/approval — approval.lps — Appendix C's approval gate, as a running program (Part II).
      • agents/llm/approval_ide — approval_ide.lps — the Part II safety property, from the IDE alone.
    • Minecraft 3

      • agents/minecraft/craft — craft.lps — planning over crafting (Part III).
      • agents/minecraft/hungry — hungry.lps — a constraint blocking an action, and then explaining itself.
      • agents/minecraft/safety — safety.lps — the supervisory tier of a Minecraft agent (Part III, §V.4).
  • Collections 12

    • Kowalski's book 12

      • collections/kowalski-book/citizenship_time — citizenship_time.lps — Kowalski, ch. 6 §6.3: representation of time and
      • collections/kowalski-book/event_calculus — event_calculus.lps — Kowalski, ch. 13 §13.3–13.4: the simplified calculus
      • collections/kowalski-book/fox_crow — fox_crow.lps — Kowalski, ch. 3: the fox and the crow.
      • collections/kowalski-book/hunger — hunger.lps — Kowalski, ch. 8 §8.3: the time factor.
      • collections/kowalski-book/louse — louse.lps — Kowalski, ch. 7 §7.5: what it is like to be a louse.
      • collections/kowalski-book/mars_explorer — mars_explorer.lps — Kowalski, ch. 7 §7.7: what it is like to be a Mars explorer.
      • collections/kowalski-book/penalty — penalty.lps — Kowalski, ch. 1 §1.5: the penalty sentence as an inhibitor.
      • collections/kowalski-book/plan_generation — plan_generation.lps — Kowalski, ch. 13 §13.6: the event calculus for plan
      • collections/kowalski-book/trolley — trolley.lps — Kowalski, ch. 12 §12.2–12.3: the runaway trolley, and the
      • collections/kowalski-book/umbrella — umbrella.lps — Kowalski, ch. 11 §11.2: should you carry an umbrella?
      • collections/kowalski-book/underground — underground.lps — Kowalski, ch. 1: the London Underground Emergency Notice.
      • collections/kowalski-book/violations — violations.lps — Kowalski, ch. 12 §12.4: what to do about violations.
  • Migration twins 48

    • Daml twins (Phase 2g) 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 program extends).
        • 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 this program extends).
        • 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 program extends).
        • 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 program extends).
        • 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 program extends).
        • 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 program extends).
      • 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 extends).
      • 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 (quickstart.le, which this program extends).
      • 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 program extends).
        • 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 program extends).
        • 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 program extends).
    • Drools twins (Phase 2e) 11

      • Drools rule bases 5

        • migration/drools/drl/discount.drl — discount.drl — a rule base in the shape enterprise Drools actually takes:
        • migration/drools/drl/fire-alarm.drl — fire-alarm.drl — the fire/sprinkler/alarm rule base from the Drools manual,
        • migration/drools/drl/insurance.drl — insurance.drl — eligibility, the classic rule-engine subject.
        • migration/drools/drl/shipping.drl — shipping.drl — retract as well as insert.
        • migration/drools/drl/traffic-light.drl — traffic-light.drl — a state machine as production rules.
      • 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)
    • 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 contracts/FiatTokenSubset.sol), translated by the Solidity translator.
      • 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,
        • migration/solidity/vault/vault_view.le — The E12 convention in a legal-readable view: an external value the
• corpus 158

  • Ballot — By BK, modified by MC:
  • bank account_terse — /** <examples>
  • 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
  • oneprisoner — oneprisoner.lps
  • 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
  • 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 :
    • CLOUT_workshop/GameWithOracle — Based on http://www.liquidity-lang.org/doc/tutorial/game.html, a single player game
    • CLOUT_workshop/GameWithOracleSimpler — Inspired on http://www.liquidity-lang.org/doc/tutorial/game.html, a single player game
    • CLOUT_workshop/RockPaperScissors — From "Step by Step Towards Creating a Safe Smart Contract: Lessons and Insights from a Cryptocurrency Lab",
    • 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>
    • CLOUT_workshop/RockPaperScissorsServer — From "Step by Step Towards Creating a Safe Smart Contract: Lessons and Insights from a Cryptocurrency Lab",
    • CLOUT_workshop/RockPaperScissorsServer-noProspectivePCs — From "Step by Step Towards Creating a Safe Smart Contract: Lessons and Insights from a Cryptocurrency Lab",
    • CLOUT_workshop/SzaboLanguage_futures — /*
    • CLOUT_workshop/SzaboLanguage_futures_failing — First example from https://nakamotoinstitute.org/contract-language/
    • CLOUT_workshop/SzaboLanguage_insurance_base — Original:
    • CLOUT_workshop/SzaboLanguage_insurance_eternal — would never end, because the lawyer allowed foreclosing in any later future... but
    • CLOUT_workshop/SzaboLanguage_insurance_foreclosing — should succeed because of foreclosing
    • 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
    • CLOUT_workshop/SzaboLanguage_insurance_normal_claim — succeeds correctly, claim being paid
    • CLOUT_workshop/SzaboLanguage_insurance_tricky_claim — can't claim when it arrives
    • CLOUT_workshop/badlight — /** <examples>
    • 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
    • CLOUT_workshop/bankTransfer — Uncomment this to get an experimental 2d display:
    • CLOUT_workshop/bankTransfer_lazy2d — /** <examples>
    • CLOUT_workshop/bubbleSort — bubble sort with relational data structure .
    • CLOUT_workshop/burning — /*
    • CLOUT_workshop/concurrentTowers — Note the execution of this program is very sensitive to the order
    • CLOUT_workshop/concurrent_towers — Note the execution of this program is very sensitive to the order
    • CLOUT_workshop/consolidatedLoan — consolidated loan example.
    • CLOUT_workshop/d_test — A few examples of display specifications
    • CLOUT_workshop/deliveryDelay — Example from Accord Project:
    • CLOUT_workshop/derivative_contract — contract for derivative of UCITS ETF FTSE MIB
    • CLOUT_workshop/diningPhilosophers — /** <examples>
    • CLOUT_workshop/diningPhilosophers-client — Dining philosophers, detaching the dining table and cutlery from the guests and their seating arrangements
    • CLOUT_workshop/diningPhilosophers-table — see diningPhilosphers-client.pl
    • CLOUT_workshop/email — /** <examples>
    • CLOUT_workshop/employment_contract — Originally at http://demo.logicalcontracts.com/example/employment_contract.pl
    • CLOUT_workshop/employment_contract_base — Originally at http://demo.logicalcontracts.com/example/employment_contract.pl
    • CLOUT_workshop/fireRecurrent — fire2
    • CLOUT_workshop/fireSimple — /** <examples>
    • 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:
    • CLOUT_workshop/helloemail — /** <examples>
    • 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.
    • CLOUT_workshop/loanAgreementPostConditionsRT — Adapted by RAK from the simplified loan agreement in Flood and Goodenough, March 2017.
    • CLOUT_workshop/loanAgreementPostConditionsRTbase — Adapted by RAK from the simplified loan agreement in Flood and Goodenough, March 2017.
    • 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,
    • 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.
    • CLOUT_workshop/mapColouring — What happens if we add the following commented out constraint?.
    • CLOUT_workshop/negatedEvents — Masochistic agent
    • CLOUT_workshop/negatedEvents-FS — /** <examples>
    • CLOUT_workshop/prisoners — /** <examples>
    • CLOUT_workshop/quicksort — Prolog programs can be called from LPS.
    • CLOUT_workshop/redis_toggler — Minimal example to toggle a Redis binary tag value
    • CLOUT_workshop/rstapi_test — /*
    • CLOUT_workshop/simulateExternalEvent — Technique to simulate an "outside world" event new_lustrum(_) every 5 cycles
    • CLOUT_workshop/smartHomePrimitives — /*
    • CLOUT_workshop/sortWithTime — Shortest sorting algorithm:-) A single logical implication, universally quantified on the antecedent.
    • 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,
    • 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
      • 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
    • forTesting/RockPaperScissors-3players — From "Step by Step Towards Creating a Safe Smart Contract: Lessons and Insights from a Cryptocurrency Lab",
    • forTesting/RockPaperScissors-3players-badFluent — From "Step by Step Towards Creating a Safe Smart Contract: Lessons and Insights from a Cryptocurrency Lab",
    • 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
    • forTesting/badlight2
    • forTesting/ballotTest — By BK, modified by MC:
    • forTesting/bankDoubleTransfer — following commented out: all actions are serialised, producing cumulative effects IF using updates
    • forTesting/bankTransfer1
    • forTesting/bankTransfer2 — bankTransfer
    • forTesting/bank_account_realtime — %maxTime(10).
    • forTesting/bank_transferWithhappened — Uncomment this to get an experimental 2d display:
    • forTesting/bobObservationBug — Adapted by RAK from the simplified loan agreement in Flood and Goodenough, 2015.
    • forTesting/changingFluentInAntecedent
    • forTesting/compositeEventInconsistency — Adapted by RAK from the simplified loan agreement in Flood and Goodenough, 2015.
    • 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
    • forTesting/external_stuff
    • forTesting/failBetter — we need to discover that the consequent is doomed to fail, given the following observations
    • 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
    • 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
    • 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>
    • forTesting/simulatedTimeCompositeEvent
    • forTesting/simulatedTimeCompositeEvent2 — /** <examples>
    • 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>
    • 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.
• 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.
• A summary in two pages
  For deciding whether to read the rest.