Agda-2.5.2: A dependently typed functional programming language and proof assistant

Safe Haskell | None
Language | Haskell2010

Agda.TypeChecking.SizedTypes

Contents

- SIZELT stuff
- Size views that `reduce`.
- Size comparison that might add constraints.
- Size constraints.
- Size constraint solving.

Synopsis

- checkSizeLtSat :: Term -> TCM ()
- checkSizeNeverZero :: Term -> TCM Bool
- checkSizeVarNeverZero :: Int -> TCM Bool
- isBounded :: MonadTCM tcm => Nat -> tcm BoundedSize
- boundedSizeMetaHook :: Term -> Telescope -> Type -> TCM ()
- trySizeUniv :: Comparison -> Type -> Term -> Term -> QName -> Elims -> QName -> Elims -> TCM ()
- deepSizeView :: Term -> TCM DeepSizeView
- sizeMaxView :: Term -> TCM SizeMaxView
- compareSizes :: Comparison -> Term -> Term -> TCM ()
- compareMaxViews :: Comparison -> SizeMaxView -> SizeMaxView -> TCM ()
- compareBelowMax :: DeepSizeView -> SizeMaxView -> TCM ()
- compareSizeViews :: Comparison -> DeepSizeView -> DeepSizeView -> TCM ()
- trivial :: Term -> Term -> TCM Bool
- isSizeProblem :: ProblemId -> TCM Bool
- isSizeConstraint :: Closure Constraint -> TCM Bool
- getSizeConstraints :: TCM [Closure Constraint]
- getSizeMetas :: Bool -> TCM [(MetaId, Type, Telescope)]
- data OldSizeExpr
  - = SizeMeta MetaId [Int]
  - | Rigid Int
- data OldSizeConstraint = Leq OldSizeExpr Int OldSizeExpr
- oldComputeSizeConstraints :: [Closure Constraint] -> TCM [OldSizeConstraint]
- oldComputeSizeConstraint :: Constraint -> TCM (Maybe OldSizeConstraint)
- oldSizeExpr :: Term -> TCM (OldSizeExpr, Int)
- flexibleVariables :: OldSizeConstraint -> [(MetaId, [Int])]
- oldCanonicalizeSizeConstraint :: OldSizeConstraint -> Maybe OldSizeConstraint
- oldSolveSizeConstraints :: TCM ()
- oldSolver :: [(MetaId, Int)] -> [OldSizeConstraint] -> TCM Bool

# SIZELT stuff

checkSizeLtSat :: Term -> TCM () #

Check whether a type is either not a SIZELT or a SIZELT that is non-empty.

checkSizeNeverZero :: Term -> TCM Bool #

Precondition: Term is reduced and not blocked. Throws a `patternViolation` if undecided

checkSizeVarNeverZero :: Int -> TCM Bool #

Checks that a size variable is ensured to be `> 0`. E.g. variable `i` cannot be zero in context `(i : Size) (j : Size< ↑ ↑ i) (k : Size< j) (k' : Size< k)`. Throws a `patternViolation` if undecided.

isBounded :: MonadTCM tcm => Nat -> tcm BoundedSize #

Check whether a variable in the context is bounded by a size expression. If `x : Size< a`, then `a` is returned.

boundedSizeMetaHook :: Term -> Telescope -> Type -> TCM () #

Whenever we create a bounded size meta, add a constraint expressing the bound. In `boundedSizeMetaHook v tel a`, `tel` includes the current context.

trySizeUniv :: Comparison -> Type -> Term -> Term -> QName -> Elims -> QName -> Elims -> TCM () #

`trySizeUniv cmp t m n x els1 y els2` is called as a last resort when conversion checking `m `cmp` n : t` failed for definitions `m = x els1` and `n = y els2`, where the heads `x` and `y` are not equal.

`trySizeUniv` accounts for subtyping between SIZELT and SIZE, like `Size< i =< Size`.

If it does not succeed it reports failure of conversion check.

# Size views that `reduce`.

deepSizeView :: Term -> TCM DeepSizeView #

Compute the deep size view of a term. Precondition: sized types are enabled.

sizeMaxView :: Term -> TCM SizeMaxView #

# Size comparison that might add constraints.

compareSizes :: Comparison -> Term -> Term -> TCM () #

Compare two sizes.

compareMaxViews :: Comparison -> SizeMaxView -> SizeMaxView -> TCM () #

Compare two sizes in max view.

compareBelowMax :: DeepSizeView -> SizeMaxView -> TCM () #

`compareBelowMax u vs` checks `u <= max vs`. Precondition: `size vs >= 2`

compareSizeViews :: Comparison -> DeepSizeView -> DeepSizeView -> TCM () #

trivial :: Term -> Term -> TCM Bool #

Checked whether a size constraint is trivial (like `X <= X+1`).

# Size constraints.

isSizeProblem :: ProblemId -> TCM Bool #

Test whether a problem consists only of size constraints.

isSizeConstraint :: Closure Constraint -> TCM Bool #

Test is a constraint speaks about sizes.

getSizeConstraints :: TCM [Closure Constraint] #

Find the size constraints.

getSizeMetas :: Bool -> TCM [(MetaId, Type, Telescope)] #

Return a list of size metas and their context.

# Size constraint solving.

data OldSizeExpr #

Atomic size expressions.

Constructors

SizeMeta MetaId [Int] | A size meta applied to de Bruijn indices.
Rigid Int | A de Bruijn index.

Instances

Eq OldSizeExpr # |
Methods (==) :: OldSizeExpr -> OldSizeExpr -> Bool # (/=) :: OldSizeExpr -> OldSizeExpr -> Bool #
Show OldSizeExpr # |
Methods showsPrec :: Int -> OldSizeExpr -> ShowS # show :: OldSizeExpr -> String # showList :: [OldSizeExpr] -> ShowS #

data OldSizeConstraint #

Size constraints we can solve.

Constructors

Leq OldSizeExpr Int OldSizeExpr | `Leq a +n b` represents `a =< b + n`. `Leq a -n b` represents `a + n =< b`.

Instances

Show OldSizeConstraint # |
Methods showsPrec :: Int -> OldSizeConstraint -> ShowS # show :: OldSizeConstraint -> String # showList :: [OldSizeConstraint] -> ShowS #

oldComputeSizeConstraints :: [Closure Constraint] -> TCM [OldSizeConstraint] #

Compute a set of size constraints that all live in the same context from constraints over terms of type size that may live in different contexts.

cf. `simplifyLevelConstraint`

oldComputeSizeConstraint :: Constraint -> TCM (Maybe OldSizeConstraint) #

Turn a constraint over de Bruijn indices into a size constraint.

oldSizeExpr :: Term -> TCM (OldSizeExpr, Int) #

Turn a term with de Bruijn indices into a size expression with offset.

Throws a `patternViolation` if the term isn't a proper size expression.

flexibleVariables :: OldSizeConstraint -> [(MetaId, [Int])] #

Compute list of size metavariables with their arguments appearing in a constraint.

oldCanonicalizeSizeConstraint :: OldSizeConstraint -> Maybe OldSizeConstraint #

Convert size constraint into form where each meta is applied to indices `0,1,..,n-1` where `n` is the arity of that meta.

`X[σ] <= t` becomes `X[id] <= t[σ^-1]`

`X[σ] ≤ Y[τ]` becomes `X[id] ≤ Y[τ[σ^-1]]` or `X[σ[τ^1]] ≤ Y[id]` whichever is defined. If none is defined, we give up.

oldSolveSizeConstraints :: TCM () #

Main function. Uses the old solver for size constraints using Agda.Utils.Warshall. This solver does not smartly use size hypotheses `j : Size< i`. It only checks that its computed solution is compatible

oldSolver #

Arguments

:: [(MetaId, Int)] | Size metas and their arity.
-> [OldSizeConstraint] | Size constraints (in preprocessed form).
-> TCM Bool | Returns `False` if solver fails.

Old solver for size constraints using Agda.Utils.Warshall. This solver does not smartly use size hypotheses `j : Size< i`.