blob: 4c20c8fb86e2943b9073bdbde4ad85bfade336a0 [file]
/-
Copyright (c) 2025 Lean FRO, LLC. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Wojciech Różowski, Joachim Breitner
-/
module
prelude
public import Lean.Meta.PProdN
public import Lean.Meta.AppBuilder
public import Init.Internal.Order.Basic
public section
/-!
This module has meta-functions for constructions expressions related to `Lean.Order`.
In particular some of these functions can handle the `CCPO` and `CompleteLattice`
structures conveniently uniformly, picking the right one based on the type of the arguments.
-/
namespace Lean.Meta
open Order
/--
Given `inst : CCPO (t[x])` for some FVar `x`, constructs an instance
of the type `CCPO (∀ x, t[x])`.
Can handle `CompleteLattice` as well.
--/
def mkInstPiOfInstForall (x : Expr) (inst : Expr) : MetaM Expr := do
if (←inferType inst).isAppOf ``CCPO then
mkAppOptM ``instCCPOPi #[(← inferType x), none, (← mkLambdaFVars #[x] inst)]
else if (←inferType inst).isAppOf ``CompleteLattice then
mkAppOptM ``instCompleteLatticePi #[(← inferType x), none, (← mkLambdaFVars #[x] inst)]
else
throwError "mkInstPiOfInstForall: unexpected type of {inst}"
/-- An n-ary version of `mkInstPiOfInstForall`. Takes an array of arguments instead.
--/
def mkInstPiOfInstsForall (xs : Array Expr) (inst : Expr) : MetaM Expr := do
let mut inst := inst
for x in xs.reverse do
inst ← mkInstPiOfInstForall x inst
pure inst
/--
Given a function `f : α → α`, an instance `inst : CCPO α`
and a monotonicity proof `hmono : monotone f`, constructs a least fixpoint of `f`
with respect to the instance `inst`. The `packedType` is assumed to contain the type `α`.
Can handle `CompleteLattice` as well.
-/
def mkFixOfMonFun (packedType : Expr) (packedInst : Expr) (hmono : Expr) : MetaM Expr := do
if (←inferType packedInst).isAppOf ``CCPO then
mkAppOptM ``fix #[packedType, packedInst, none, hmono]
else if (←inferType packedInst).isAppOf ``CompleteLattice then
mkAppOptM ``lfp_monotone #[packedType, packedInst, none, hmono]
else
throwError "mkFixOfMonFun: unexpected type of {packedInst}"
/--
Given `packedInst : CCPO α `, returns an underlying instance of the type
`PartialOrder α`. Can handle `CompleteLattice` as well.
Takes an optional argument with the type `α`. If the optional argument is `none`,
it is treated implicitly.
-/
def toPartialOrder (packedInst : Expr) (type : Option Expr := .none) := do
if (←inferType packedInst).isAppOf ``CCPO then
mkAppOptM ``CCPO.toPartialOrder #[type, packedInst]
else if (←inferType packedInst).isAppOf ``CompleteLattice then
mkAppOptM ``CompleteLattice.toPartialOrder #[type, packedInst]
else
throwError "getUnderlyingOrder: unexpected type of {packedInst}"
/--
Given CCPO instances `inst₁ : CCPO α₁` and `inst₂ : CCPO α₂`,
constructs an instance of the type `CCPO (α₁ × α₂)`.
-/
def mkInstCCPOPProd (inst₁ inst₂ : Expr) : MetaM Expr := do
mkAppOptM ``instCCPOPProd #[none, none, inst₁, inst₂]
/--
Given CCPO instances `inst₁ : CompleteLattice α₁` and `inst₂ : CompleteLattice α₂`,
constructs an instance of the type `CompleteLattice (α₁ × α₂)`.
-/
def mkInstCompleteLatticePProd (inst₁ inst₂ : Expr) : MetaM Expr := do
mkAppOptM ``instCompleteLatticePProd #[none, none, inst₁, inst₂]
/--
Given an array of CCPO instances `insts = #[CCPO α₁, ..., CCPO αₙ]`, constructs an instance
of the type `CCPO (α₁ × ... × αₙ)`.
Can handle `CompleteLattice` as well.
-/
def mkPackedPPRodInstance (insts : Array Expr) : MetaM Expr := do
let types ← insts.mapM inferType
if (types.all (fun t => t.isAppOf ``CCPO)) then
PProdN.genMk mkInstCCPOPProd insts
else if (types.all (fun t => t.isAppOf ``CompleteLattice)) then
PProdN.genMk mkInstCompleteLatticePProd insts
else
throwError "mkPackedPPRoodInstance: unexpected types {types} of {insts}"