Kilian Sprotte kisp

Stop Asking the World: a Local-Admissibility Architecture for Scheduling Constraints

A from-scratch redesign of constraints in Mindful Routine Planner.

1. What we actually want

The planner places recurring routine tasks onto dates. Constraints exist to shape where a task is allowed (or preferred) to land. From the real usage we have, the wishes are small and concrete:

grep for complements

Imagine you have a CLI command cat myfile | ./my-filter, and now you want to see all the lines not selected, essentially negating my-filter. Here is a way to achieve that.

The "grep for complements" command is a useful tool for filtering out lines from a file that have not been selected by a custom filter. This can be achieved using a combination of cat, your custom filter (./my-filter), and grep.

Usage

To use "grep for complements", follow these steps:

	;; MithrilJS/ospec: Noiseless testing framework
	;; https://github.com/MithrilJS/ospec

	;; {
	;; "devDependencies": {
	;; "ospec": "^4.2.0"
	;; }
	;; }

	;; Parenscript

	// app/javascript/application.js

	// Configure your import map in config/importmap.rb. Read more: https://github.com/rails/importmap-rails
	import "@hotwired/turbo-rails"
	import "controllers"

	// Add this line
	Turbo.session.linkPrefetchObserver.stop()

	/*
	You can run this file with

	maxima -b cosine-rule.mac

	or maybe also using M-x quickrun
	*/

	/*

	;; Note: This is a work in progress
	;;
	;; A function (cart-prod a b) is developed here that computes the cartesian
	;; product of two lists.
	;;
	;; For example:
	;;
	;; (cart-prod '(1 2 3) '(a b)) => ((1 a) (1 b) (2 a) (2 b) (3 a) (3 b))
	;;
	;; The function cart-prod is proven sound and complete by the theorems

	;; -- mode: lisp; -- ;; (ql:quickload "screamer")

	(in-package :screamer-user)

	;; SmallCheck and Lazy SmallCheck - automatic exhaustive testing for small values
	;; https://www.cs.york.ac.uk/fp/smallcheck/smallcheck.pdf

	(defun an-integer-upto-depth (depth)
	(either
	0

	;;; The following code implements the conversion of a natural number
	;;; to a list of digits and back.

	;;; ACL2 Version 8.5
	;;; https://www.cs.utexas.edu/users/moore/acl2/

	;;; ACL2 is used to prove that one conversion followed by the other
	;;; leads back to the initial value (roundtrip). This is proved in
	;;; both directions:
	;;; starting from a natural number (see main/base10-representation-1

	(in-package :cl-user)

	;;; destructuring-match
	;;;
	;;; Really simple implementation of pattern matching with multiple
	;;; clauses for Common Lisp (using one implementation detail of SBCL
	;;; here, namely sb-kernel::defmacro-lambda-list-bind-error).
	;;;
	;;; Like a combination of destructuring-bind and case.
	;;;

	(in-package :cl-user)

	;; (ql:quickload '("alexandria" "trivia"))

	;; Let's define maybe as an algebraic data type.
	(defstruct (nothing (:constructor nothing ())))
	(defstruct (just (:constructor just (value))) value)
	(deftype maybe () '(or nothing just))

	;; (>>=) :: Monad m => m a -> (a -> m b) -> m b