fun_prop environment extensions storing theorems for fun_prop

inductive Mathlib.Meta.FunProp.LambdaTheoremArgs : Type

Stores important argument indices of lambda theorems

For example

theorem Continuous_const {α β} [TopologicalSpace α] [TopologicalSpace β] (y : β) :
    Continuous fun _ : α => y

is represented by

  .const 0 4

• id: ℕ → Mathlib.Meta.FunProp.LambdaTheoremArgs
• const: ℕ → ℕ → Mathlib.Meta.FunProp.LambdaTheoremArgs
• proj: ℕ → ℕ → Mathlib.Meta.FunProp.LambdaTheoremArgs
• projDep: ℕ → ℕ → Mathlib.Meta.FunProp.LambdaTheoremArgs
• comp: ℕ → ℕ → Mathlib.Meta.FunProp.LambdaTheoremArgs
• letE: ℕ → ℕ → Mathlib.Meta.FunProp.LambdaTheoremArgs
• pi: ℕ → Mathlib.Meta.FunProp.LambdaTheoremArgs

instance Mathlib.Meta.FunProp.instInhabitedLambdaTheoremArgs : Inhabited Mathlib.Meta.FunProp.LambdaTheoremArgs

Equations

• Mathlib.Meta.FunProp.instInhabitedLambdaTheoremArgs = { default := Mathlib.Meta.FunProp.LambdaTheoremArgs.id default }

instance Mathlib.Meta.FunProp.instBEqLambdaTheoremArgs : BEq Mathlib.Meta.FunProp.LambdaTheoremArgs

Equations

• Mathlib.Meta.FunProp.instBEqLambdaTheoremArgs = { beq := Mathlib.Meta.FunProp.beqLambdaTheoremArgs✝ }

instance Mathlib.Meta.FunProp.instReprLambdaTheoremArgs : Repr Mathlib.Meta.FunProp.LambdaTheoremArgs

Equations

• Mathlib.Meta.FunProp.instReprLambdaTheoremArgs = { reprPrec := Mathlib.Meta.FunProp.reprLambdaTheoremArgs✝ }

instance Mathlib.Meta.FunProp.instHashableLambdaTheoremArgs : Hashable Mathlib.Meta.FunProp.LambdaTheoremArgs

Equations

• Mathlib.Meta.FunProp.instHashableLambdaTheoremArgs = { hash := Mathlib.Meta.FunProp.hashLambdaTheoremArgs✝ }

inductive Mathlib.Meta.FunProp.LambdaTheoremType : Type

There are 5(+1) basic lambda theorems

• id Continuous fun x => x
• const Continuous fun x => y
• proj Continuous fun (f : X → Y) => f x
• projDep Continuous fun (f : (x : X) → Y x => f x)
• comp Continuous f → Continuous g → Continuous fun x => f (g x)
• letE Continuous f → Continuous g → Continuous fun x => let y := g x; f x y
• pi ∀ y, Continuous (f · y) → Continuous fun x y => f x y

• id: Mathlib.Meta.FunProp.LambdaTheoremType
• const: Mathlib.Meta.FunProp.LambdaTheoremType
• proj: Mathlib.Meta.FunProp.LambdaTheoremType
• projDep: Mathlib.Meta.FunProp.LambdaTheoremType
• comp: Mathlib.Meta.FunProp.LambdaTheoremType
• letE: Mathlib.Meta.FunProp.LambdaTheoremType
• pi: Mathlib.Meta.FunProp.LambdaTheoremType

instance Mathlib.Meta.FunProp.instInhabitedLambdaTheoremType : Inhabited Mathlib.Meta.FunProp.LambdaTheoremType

Equations

• Mathlib.Meta.FunProp.instInhabitedLambdaTheoremType = { default := Mathlib.Meta.FunProp.LambdaTheoremType.id }

instance Mathlib.Meta.FunProp.instBEqLambdaTheoremType : BEq Mathlib.Meta.FunProp.LambdaTheoremType

Equations

• Mathlib.Meta.FunProp.instBEqLambdaTheoremType = { beq := Mathlib.Meta.FunProp.beqLambdaTheoremType✝ }

instance Mathlib.Meta.FunProp.instReprLambdaTheoremType : Repr Mathlib.Meta.FunProp.LambdaTheoremType

Equations

• Mathlib.Meta.FunProp.instReprLambdaTheoremType = { reprPrec := Mathlib.Meta.FunProp.reprLambdaTheoremType✝ }

instance Mathlib.Meta.FunProp.instHashableLambdaTheoremType : Hashable Mathlib.Meta.FunProp.LambdaTheoremType

Equations

• Mathlib.Meta.FunProp.instHashableLambdaTheoremType = { hash := Mathlib.Meta.FunProp.hashLambdaTheoremType✝ }

def Mathlib.Meta.FunProp.LambdaTheoremArgs.type (t : Mathlib.Meta.FunProp.LambdaTheoremArgs) : Mathlib.Meta.FunProp.LambdaTheoremType

Equations

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

def Mathlib.Meta.FunProp.detectLambdaTheoremArgs (f : Lean.Expr) (ctxVars : Array Lean.Expr) : Lean.MetaM (Option Mathlib.Meta.FunProp.LambdaTheoremArgs)

Equations

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

structure Mathlib.Meta.FunProp.LambdaTheorem : Type

• funPropName : Lean.Name

  Name of function property

• thmName : Lean.Name

  Name of lambda theorem

• thmArgs : Mathlib.Meta.FunProp.LambdaTheoremArgs

  Type and important argument of the theorem.

instance Mathlib.Meta.FunProp.instInhabitedLambdaTheorem : Inhabited Mathlib.Meta.FunProp.LambdaTheorem

Equations

• Mathlib.Meta.FunProp.instInhabitedLambdaTheorem = { default := { funPropName := default, thmName := default, thmArgs := default } }

instance Mathlib.Meta.FunProp.instBEqLambdaTheorem : BEq Mathlib.Meta.FunProp.LambdaTheorem

Equations

• Mathlib.Meta.FunProp.instBEqLambdaTheorem = { beq := Mathlib.Meta.FunProp.beqLambdaTheorem✝ }

structure Mathlib.Meta.FunProp.LambdaTheorems : Type

• theorems : Lean.HashMap (Lean.Name × Mathlib.Meta.FunProp.LambdaTheoremType) Mathlib.Meta.FunProp.LambdaTheorem

  map: function property name × theorem type → lambda theorem

instance Mathlib.Meta.FunProp.instInhabitedLambdaTheorems : Inhabited Mathlib.Meta.FunProp.LambdaTheorems

Equations

• Mathlib.Meta.FunProp.instInhabitedLambdaTheorems = { default := { theorems := default } }

def Mathlib.Meta.FunProp.LambdaTheorem.getProof (thm : Mathlib.Meta.FunProp.LambdaTheorem) : Lean.MetaM Lean.Expr

return proof of lambda theorem

Equations

• thm.getProof = Lean.Meta.mkConstWithFreshMVarLevels thm.thmName

@[reducible, inline]

abbrev Mathlib.Meta.FunProp.LambdaTheoremsExt : Type

Equations

• Mathlib.Meta.FunProp.LambdaTheoremsExt = Lean.SimpleScopedEnvExtension Mathlib.Meta.FunProp.LambdaTheorem Mathlib.Meta.FunProp.LambdaTheorems

opaque Mathlib.Meta.FunProp.lambdaTheoremsExt : Mathlib.Meta.FunProp.LambdaTheoremsExt

Extension storing all lambda theorems.

def Mathlib.Meta.FunProp.getLambdaTheorem (funPropName : Lean.Name) (type : Mathlib.Meta.FunProp.LambdaTheoremType) : Lean.CoreM (Option Mathlib.Meta.FunProp.LambdaTheorem)

Equations

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

inductive Mathlib.Meta.FunProp.TheoremForm : Type

Function theorems are stated in uncurried or compositional form.

uncurried

theorem Continuous_add : Continuous (fun x => x.1 + x.2)

compositional

theorem Continuous_add (hf : Continuous f) (hg : Continuous g) : Continuous (fun x => (f x) + (g x))

• uncurried: Mathlib.Meta.FunProp.TheoremForm
• comp: Mathlib.Meta.FunProp.TheoremForm

instance Mathlib.Meta.FunProp.instInhabitedTheoremForm : Inhabited Mathlib.Meta.FunProp.TheoremForm

Equations

• Mathlib.Meta.FunProp.instInhabitedTheoremForm = { default := Mathlib.Meta.FunProp.TheoremForm.uncurried }

instance Mathlib.Meta.FunProp.instBEqTheoremForm : BEq Mathlib.Meta.FunProp.TheoremForm

Equations

• Mathlib.Meta.FunProp.instBEqTheoremForm = { beq := Mathlib.Meta.FunProp.beqTheoremForm✝ }

instance Mathlib.Meta.FunProp.instReprTheoremForm : Repr Mathlib.Meta.FunProp.TheoremForm

Equations

• Mathlib.Meta.FunProp.instReprTheoremForm = { reprPrec := Mathlib.Meta.FunProp.reprTheoremForm✝ }

structure Mathlib.Meta.FunProp.FunctionTheorem : Type

theorem about specific function (either declared constant or free variable)

• funPropName : Lean.Name

  function property name

• thmOrigin : Mathlib.Meta.FunProp.Origin

  theorem name

• funOrigin : Mathlib.Meta.FunProp.Origin

  function name

• mainArgs : Array ℕ

  array of argument indices about which this theorem is about

• appliedArgs : ℕ

  total number of arguments applied to the function

• priority : ℕ

  priority

• form : Mathlib.Meta.FunProp.TheoremForm

  form of the theorem, see documentation of TheoremForm

instance Mathlib.Meta.FunProp.instInhabitedFunctionTheorem : Inhabited Mathlib.Meta.FunProp.FunctionTheorem

Equations

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

instance Mathlib.Meta.FunProp.instBEqFunctionTheorem : BEq Mathlib.Meta.FunProp.FunctionTheorem

Equations

• Mathlib.Meta.FunProp.instBEqFunctionTheorem = { beq := Mathlib.Meta.FunProp.beqFunctionTheorem✝ }

structure Mathlib.Meta.FunProp.FunctionTheorems : Type

• theorems : Batteries.RBMap Lean.Name (Batteries.RBMap Lean.Name (Array Mathlib.Meta.FunProp.FunctionTheorem) compare) compare

  map: function name → function property → function theorem

instance Mathlib.Meta.FunProp.instInhabitedFunctionTheorems : Inhabited Mathlib.Meta.FunProp.FunctionTheorems

Equations

• Mathlib.Meta.FunProp.instInhabitedFunctionTheorems = { default := { theorems := default } }

def Mathlib.Meta.FunProp.FunctionTheorem.getProof (thm : Mathlib.Meta.FunProp.FunctionTheorem) : Lean.MetaM Lean.Expr

return proof of function theorem

Equations

• thm.getProof = match thm.thmOrigin with | Mathlib.Meta.FunProp.Origin.decl name => Lean.Meta.mkConstWithFreshMVarLevels name | Mathlib.Meta.FunProp.Origin.fvar id => pure (Lean.Expr.fvar id)

@[reducible, inline]

abbrev Mathlib.Meta.FunProp.FunctionTheoremsExt : Type

Equations

• Mathlib.Meta.FunProp.FunctionTheoremsExt = Lean.SimpleScopedEnvExtension Mathlib.Meta.FunProp.FunctionTheorem Mathlib.Meta.FunProp.FunctionTheorems

opaque Mathlib.Meta.FunProp.functionTheoremsExt : Mathlib.Meta.FunProp.FunctionTheoremsExt

Extension storing all function theorems.

def Mathlib.Meta.FunProp.getTheoremsForFunction (funName : Lean.Name) (funPropName : Lean.Name) : Lean.CoreM (Array Mathlib.Meta.FunProp.FunctionTheorem)

Equations

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

structure Mathlib.Meta.FunProp.GeneralTheorem : Type

General theorem about function property used for transition and morphism theorems

• funPropName : Lean.Name

  function property name

• thmName : Lean.Name

  theorem name

• keys : List Mathlib.Meta.FunProp.RefinedDiscrTree.DTExpr

  discrimination tree keys used to index this theorem

• priority : ℕ

  priority

instance Mathlib.Meta.FunProp.instInhabitedGeneralTheorem : Inhabited Mathlib.Meta.FunProp.GeneralTheorem

Equations

• Mathlib.Meta.FunProp.instInhabitedGeneralTheorem = { default := { funPropName := default, thmName := default, keys := default, priority := default } }

instance Mathlib.Meta.FunProp.instBEqGeneralTheorem : BEq Mathlib.Meta.FunProp.GeneralTheorem

Equations

• Mathlib.Meta.FunProp.instBEqGeneralTheorem = { beq := Mathlib.Meta.FunProp.beqGeneralTheorem✝ }

def Mathlib.Meta.FunProp.GeneralTheorem.getProof (thm : Mathlib.Meta.FunProp.GeneralTheorem) : Lean.MetaM Lean.Expr

Get proof of a theorem.

Equations

• thm.getProof = Lean.Meta.mkConstWithFreshMVarLevels thm.thmName

structure Mathlib.Meta.FunProp.GeneralTheorems : Type

• theorems : Mathlib.Meta.FunProp.RefinedDiscrTree Mathlib.Meta.FunProp.GeneralTheorem

instance Mathlib.Meta.FunProp.instInhabitedGeneralTheorems : Inhabited Mathlib.Meta.FunProp.GeneralTheorems

Equations

• Mathlib.Meta.FunProp.instInhabitedGeneralTheorems = { default := { theorems := default } }

@[reducible, inline]

abbrev Mathlib.Meta.FunProp.GeneralTheoremsExt : Type

Equations

• Mathlib.Meta.FunProp.GeneralTheoremsExt = Lean.SimpleScopedEnvExtension Mathlib.Meta.FunProp.GeneralTheorem Mathlib.Meta.FunProp.GeneralTheorems

opaque Mathlib.Meta.FunProp.transitionTheoremsExt : Mathlib.Meta.FunProp.GeneralTheoremsExt

opaque Mathlib.Meta.FunProp.morTheoremsExt : Mathlib.Meta.FunProp.GeneralTheoremsExt

inductive Mathlib.Meta.FunProp.Theorem : Type

There are four types of theorems:

• lam - theorem about basic lambda calculus terms
• function - theorem about a specific function(declared or free variable) in specific arguments
• mor - special theorems talking about bundled morphisms/DFunLike.coe
• transition - theorems inferring one function property from another

Examples:

• lam

  theorem Continuous_id : Continuous fun x => x
  theorem Continuous_comp (hf : Continuous f) (hg : Continuous g) : Continuous fun x => f (g x)

• function

  theorem Continuous_add : Continuous (fun x => x.1 + x.2)
  theorem Continuous_add (hf : Continuous f) (hg : Continuous g) :
      Continuous (fun x => (f x) + (g x))

• mor - the head of function body has to be ``DFunLike.code

  theorem ContDiff.clm_apply {f : E → F →L[𝕜] G} {g : E → F}
      (hf : ContDiff 𝕜 n f) (hg : ContDiff 𝕜 n g) :
      ContDiff 𝕜 n fun x => (f x) (g x)
  theorem clm_linear {f : E →L[𝕜] F} : IsLinearMap 𝕜 f

• transition - the conclusion has to be in the form P f where f is a free variable

  theorem linear_is_continuous [FiniteDimensional ℝ E] {f : E → F} (hf : IsLinearMap 𝕜 f) :
      Continuous f

• lam: Mathlib.Meta.FunProp.LambdaTheorem → Mathlib.Meta.FunProp.Theorem
• function: Mathlib.Meta.FunProp.FunctionTheorem → Mathlib.Meta.FunProp.Theorem
• mor: Mathlib.Meta.FunProp.GeneralTheorem → Mathlib.Meta.FunProp.Theorem
• transition: Mathlib.Meta.FunProp.GeneralTheorem → Mathlib.Meta.FunProp.Theorem

def Mathlib.Meta.FunProp.getTheoremFromConst (declName : Lean.Name) (prio : optParam ℕ 1000) : Lean.MetaM Mathlib.Meta.FunProp.Theorem

Equations

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

def Mathlib.Meta.FunProp.addTheorem (declName : Lean.Name) (attrKind : optParam Lean.AttributeKind Lean.AttributeKind.global) (prio : optParam ℕ 1000) : Lean.MetaM Unit

Equations

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