A monad for tracking and deduplicating atoms

This monad is used by tactics like ring and abel to keep uninterpreted atoms in a consistent order, and also to allow unifying atoms up to a specified transparency mode.

Note: this can become very expensive because it is using isDefEq. For performance reasons, consider whether Lean.Meta.Canonicalizer.canon can be used instead. After canonicalizing, a HashMap Expr Nat suffices to keep track of previously seen atoms, and is much faster as it uses Expr equality rather than isDefEq.

structure Mathlib.Tactic.AtomM.Context : Type

The context (read-only state) of the AtomM monad.

• red : Lean.Meta.TransparencyMode

  The reducibility setting for definitional equality of atoms

• evalAtom : Lean.Expr → Lean.MetaM Lean.Meta.Simp.Result

  A simplification to apply to atomic expressions when they are encountered, before interning them in the atom list.

def Mathlib.Tactic.AtomM.instInhabitedContext.default : Context

Equations

• Mathlib.Tactic.AtomM.instInhabitedContext.default = { red := default, evalAtom := default }

instance Mathlib.Tactic.AtomM.instInhabitedContext : Inhabited Context

Equations

• Mathlib.Tactic.AtomM.instInhabitedContext = { default := Mathlib.Tactic.AtomM.instInhabitedContext.default }

structure Mathlib.Tactic.AtomM.State : Type

The mutable state of the AtomM monad.

• atoms : Array Lean.Expr

  The list of atoms-up-to-defeq encountered thus far, used for atom sorting.

@[reducible, inline]

abbrev Mathlib.Tactic.AtomM (α : Type) : Type

The monad that ring works in. This is only used for collecting atoms.

Equations

• Mathlib.Tactic.AtomM = ReaderT Mathlib.Tactic.AtomM.Context (StateRefT' IO.RealWorld Mathlib.Tactic.AtomM.State Lean.MetaM)

def Mathlib.Tactic.AtomM.run {α : Type} (red : Lean.Meta.TransparencyMode) (m : AtomM α) (evalAtom : Lean.Expr → Lean.MetaM Lean.Meta.Simp.Result := fun (e : Lean.Expr) => pure { expr := e }) : Lean.MetaM α

Run a computation in the AtomM monad.

Equations

• Mathlib.Tactic.AtomM.run red m evalAtom = (m { red := red, evalAtom := evalAtom }).run' { }

def Mathlib.Tactic.isDefEqSafe (a b : Lean.Expr) : Lean.MetaM Bool

A safe version of isDefEq that doesn't throw errors. We use it to avoid "unknown free variable '_fvar.102937'" errors when there may be out-of-scope free variables.

TODO: don't catch any other errors

Equations

• Mathlib.Tactic.isDefEqSafe a b = tryCatch (Lean.Meta.isDefEq a b) fun (x : Lean.Exception) => pure false

def Mathlib.Tactic.AtomM.addAtom (e : Lean.Expr) : AtomM (Nat × Lean.Expr)

If an atomic expression has already been encountered, get the index and the stored form of the atom (which will be defeq at the specified transparency, but not necessarily syntactically equal). If the atomic expression has not already been encountered, store it in the list of atoms, and return the new index (and the stored form of the atom, which will be itself).

In a normalizing tactic, the expression returned by addAtom should be considered the normal form.

Equations

• One or more equations did not get rendered due to their size.

def Mathlib.Tactic.AtomM.addAtomQ {u : Lean.Level} {α : Q(Type u)} (e : Q(«$α»)) : AtomM (Nat × { e' : Q(«$α») // «$e» =Q «$e'» })

If an atomic expression has already been encountered, get the index and the stored form of the atom (which will be defeq at the specified transparency, but not necessarily syntactically equal). If the atomic expression has not already been encountered, store it in the list of atoms, and return the new index (and the stored form of the atom, which will be itself).

In a normalizing tactic, the expression returned by addAtomQ should be considered the normal form.

This is a strongly-typed version of AtomM.addAtom for code using Qq.

Equations

• Mathlib.Tactic.AtomM.addAtomQ e = do let __discr ← Mathlib.Tactic.AtomM.addAtom e match __discr with | (n, e') => pure (n, ⟨e', ⋯⟩)