Hugging Face's logo

Datasets:
phanerozoic
/
Agda-Prelude

Tasks:
Text Generation
Feature Extraction
Modalities:
Text
Formats:
parquet
Languages:
English
Size:
< 1K
Tags:
theorem-proving
formal-methods
agda
dependent-types
Libraries:
Datasets
pandas
Polars
License:
Dataset card Data Studio Files
xet
Community
Dataset Viewer
Auto-converted to Parquet Duplicate
fact
stringlengths
9
8.64k
type
stringclasses
3 values
library
stringclasses
2 values
imports
listlengths
0
30
filename
stringclasses
118 values
symbolic_name
stringlengths
1
23
docstring
stringclasses
1 value
fileIsEqual : ∀ {k} → Path k → Path k → IO Unit
function
test
[ "open import Prelude", "open import System.File", "open import System.FilePath", "open import Prelude.Equality" ]
test/Files.agda
fileIsEqual
main : IO ⊤
function
test
[ "open import Prelude", "open import System.File", "open import System.FilePath", "open import Prelude.Equality" ]
test/Files.agda
main
N : Set where z : N s : N → N unquoteDecl eqN = deriveEq eqN (quote N)
data
test
[ "import Everything", "open import Prelude", "open import Container.Traversable", "open import Container.Foldable", "open import Container.List", "open import Text.Parse", "open import Text.Lex", "open import Text.Printf.Prelude", "open import Control.Monad.State", "open import Control.Monad.Transformer", "open import Control.WellFounded", "open import Builtin.Size", "open import Builtin.Coinduction", "open import Builtin.Float", "open import Builtin.Reflection", "open import Tactic.Reflection.DeBruijn", "open import Tactic.Reflection.Equality", "open import Tactic.Reflection.Free", "open import Tactic.Reflection.Quote", "open import Tactic.Reflection.Telescope", "open import Tactic.Deriving.Eq", "open import Tactic.Nat", "open import Numeric.Nat.DivMod", "open import Numeric.Nat.Divide", "open import Numeric.Nat.GCD", "open import Numeric.Nat.Prime", "open import Numeric.Rational", "open import Numeric.Nat.Modulo", "open import Numeric.Nat.Pow", "open import MonoidTactic" ]
test/Main.agda
N
putStrI : String → StateT Nat IO Unit
function
test
[ "import Everything", "open import Prelude", "open import Container.Traversable", "open import Container.Foldable", "open import Container.List", "open import Text.Parse", "open import Text.Lex", "open import Text.Printf.Prelude", "open import Control.Monad.State", "open import Control.Monad.Transformer", "open import Control.WellFounded", "open import Builtin.Size", "open import Builtin.Coinduction", "open import Builtin.Float", "open import Builtin.Reflection", "open import Tactic.Reflection.DeBruijn", "open import Tactic.Reflection.Equality", "open import Tactic.Reflection.Free", "open import Tactic.Reflection.Quote", "open import Tactic.Reflection.Telescope", "open import Tactic.Deriving.Eq", "open import Tactic.Nat", "open import Numeric.Nat.DivMod", "open import Numeric.Nat.Divide", "open import Numeric.Nat.GCD", "open import Numeric.Nat.Prime", "open import Numeric.Rational", "open import Numeric.Nat.Modulo", "open import Numeric.Nat.Pow", "open import MonoidTactic" ]
test/Main.agda
putStrI
main : IO ⊤
function
test
[ "import Everything", "open import Prelude", "open import Container.Traversable", "open import Container.Foldable", "open import Container.List", "open import Text.Parse", "open import Text.Lex", "open import Text.Printf.Prelude", "open import Control.Monad.State", "open import Control.Monad.Transformer", "open import Control.WellFounded", "open import Builtin.Size", "open import Builtin.Coinduction", "open import Builtin.Float", "open import Builtin.Reflection", "open import Tactic.Reflection.DeBruijn", "open import Tactic.Reflection.Equality", "open import Tactic.Reflection.Free", "open import Tactic.Reflection.Quote", "open import Tactic.Reflection.Telescope", "open import Tactic.Deriving.Eq", "open import Tactic.Nat", "open import Numeric.Nat.DivMod", "open import Numeric.Nat.Divide", "open import Numeric.Nat.GCD", "open import Numeric.Nat.Prime", "open import Numeric.Rational", "open import Numeric.Nat.Modulo", "open import Numeric.Nat.Pow", "open import MonoidTactic" ]
test/Main.agda
main
downFrom : Nat → List Nat
function
test
[ "import Everything", "open import Prelude", "open import Container.Traversable", "open import Container.Foldable", "open import Container.List", "open import Text.Parse", "open import Text.Lex", "open import Text.Printf.Prelude", "open import Control.Monad.State", "open import Control.Monad.Transformer", "open import Control.WellFounded", "open import Builtin.Size", "open import Builtin.Coinduction", "open import Builtin.Float", "open import Builtin.Reflection", "open import Tactic.Reflection.DeBruijn", "open import Tactic.Reflection.Equality", "open import Tactic.Reflection.Free", "open import Tactic.Reflection.Quote", "open import Tactic.Reflection.Telescope", "open import Tactic.Deriving.Eq", "open import Tactic.Nat", "open import Numeric.Nat.DivMod", "open import Numeric.Nat.Divide", "open import Numeric.Nat.GCD", "open import Numeric.Nat.Prime", "open import Numeric.Rational", "open import Numeric.Nat.Modulo", "open import Numeric.Nat.Pow", "open import MonoidTactic" ]
test/Main.agda
downFrom
thm : ∀ n → 6 * sumR (map (_^ 2) (downFrom n)) ≡ n * (n + 1) * (2 * n + 1)
function
test
[ "import Everything", "open import Prelude", "open import Container.Traversable", "open import Container.Foldable", "open import Container.List", "open import Text.Parse", "open import Text.Lex", "open import Text.Printf.Prelude", "open import Control.Monad.State", "open import Control.Monad.Transformer", "open import Control.WellFounded", "open import Builtin.Size", "open import Builtin.Coinduction", "open import Builtin.Float", "open import Builtin.Reflection", "open import Tactic.Reflection.DeBruijn", "open import Tactic.Reflection.Equality", "open import Tactic.Reflection.Free", "open import Tactic.Reflection.Quote", "open import Tactic.Reflection.Telescope", "open import Tactic.Deriving.Eq", "open import Tactic.Nat", "open import Numeric.Nat.DivMod", "open import Numeric.Nat.Divide", "open import Numeric.Nat.GCD", "open import Numeric.Nat.Prime", "open import Numeric.Rational", "open import Numeric.Nat.Modulo", "open import Numeric.Nat.Pow", "open import MonoidTactic" ]
test/Main.agda
thm
thm₂ : (a b : Nat) → (a - b) * (a + b) ≡ a ^ 2 - b ^ 2
function
test
[ "import Everything", "open import Prelude", "open import Container.Traversable", "open import Container.Foldable", "open import Container.List", "open import Text.Parse", "open import Text.Lex", "open import Text.Printf.Prelude", "open import Control.Monad.State", "open import Control.Monad.Transformer", "open import Control.WellFounded", "open import Builtin.Size", "open import Builtin.Coinduction", "open import Builtin.Float", "open import Builtin.Reflection", "open import Tactic.Reflection.DeBruijn", "open import Tactic.Reflection.Equality", "open import Tactic.Reflection.Free", "open import Tactic.Reflection.Quote", "open import Tactic.Reflection.Telescope", "open import Tactic.Deriving.Eq", "open import Tactic.Nat", "open import Numeric.Nat.DivMod", "open import Numeric.Nat.Divide", "open import Numeric.Nat.GCD", "open import Numeric.Nat.Prime", "open import Numeric.Rational", "open import Numeric.Nat.Modulo", "open import Numeric.Nat.Pow", "open import MonoidTactic" ]
test/Main.agda
thm₂
SemigroupAnd : Semigroup Bool
function
test
[ "open import Prelude", "open import Container.Traversable", "open import Tactic.Monoid", "open import Tactic.Reflection" ]
test/MonoidTactic.agda
SemigroupAnd
MonoidAnd : Monoid Bool
function
test
[ "open import Prelude", "open import Container.Traversable", "open import Tactic.Monoid", "open import Tactic.Reflection" ]
test/MonoidTactic.agda
MonoidAnd
test₁ : (a b : Bool) → (a && (b && a && true)) ≡ ((a && b) && a)
function
test
[ "open import Prelude", "open import Container.Traversable", "open import Tactic.Monoid", "open import Tactic.Reflection" ]
test/MonoidTactic.agda
test₁
test₃ : ∀ {a} {A : Set a} (xs ys zs : List A) → xs ++ ys ++ zs ≡ (xs ++ []) ++ (ys ++ []) ++ zs
function
test
[ "open import Prelude", "open import Container.Traversable", "open import Tactic.Monoid", "open import Tactic.Reflection" ]
test/MonoidTactic.agda
test₃
main : IO ⊤
function
test
[ "open import Prelude", "open import Numeric.Nat.Prime" ]
test/PrimeTest.agda
main
LessFloat (x y : Float) : Set where less-float : primFloatLess x y ≡ true → LessFloat x y instance OrdFloat : Ord Float OrdFloat = defaultOrd cmpFloat where cmpFloat : ∀ x y → Comparison LessFloat x y cmpFloat x y with inspect (primFloatLess x y) ... | true with≡ eq = less (less-float eq) ... | false with≡ _ with inspect (primFloatLess y x) ... | true with≡ eq = greater (less-float eq) ... | false with≡ _ = equal unsafeEqual OrdLawsFloat : Ord/Laws Float Ord/Laws.super OrdLawsFloat = it less-antirefl {{OrdLawsFloat}} (less-float eq) = unsafeNotEqual eq less-trans {{OrdLawsFloat}} (less-float _) (less-float _) = less-float unsafeEqual instance ShowFloat : Show Float ShowFloat = simpleShowInstance primShowFloat instance NumFloat : Number Float Number.Constraint NumFloat _ = ⊤ Number.fromNat NumFloat x = primNatToFloat x SemiringFloat : Semiring Float Semiring.zro SemiringFloat = 0.0 Semiring.one SemiringFloat = 1.0 Semiring._+_ SemiringFloat = primFloatPlus Semiring._*_ SemiringFloat = primFloatTimes SubFloat : Subtractive Float Subtractive._-_ SubFloat = primFloatMinus Subtractive.negate SubFloat = primFloatNegate NegFloat : Negative Float Negative.Constraint NegFloat _ = ⊤ Negative.fromNeg NegFloat x = negate (primNatToFloat x) FracFloat : Fractional Float Fractional.Constraint FracFloat _ _ = ⊤ Fractional._/_ FracFloat x y = primFloatDiv x y floor = primFloatFloor round = primFloatRound ceiling = primFloatCeiling exp = primFloatExp ln = primFloatLog sin = primFloatSin sqrt = primFloatSqrt isNaN = primFloatIsNaN isInfinite = primFloatIsInfinite isFinite : Float → Bool isFinite x = not (isNaN x || isInfinite x) -- Non-maybe rounding, that returns 0 for ±Inf and NaN round! : Float → Int round! = fromMaybe 0 ∘ round floor! : Float → Int floor! = fromMaybe 0 ∘ floor ceiling! : Float → Int ceiling! = fromMaybe 0 ∘ ceiling π : Float π = 3.141592653589793 cos : Float → Float cos x = sin (π / 2.0 - x) tan : Float → Float tan x = sin x / cos x log : Float → Float → Float log base x = ln x / ln base _**_ : Float → Float → Float a ** x = exp (x * ln a) NaN : Float NaN = 0.0 / 0.0 Inf : Float Inf = 1.0 / 0.0 -Inf : Float -Inf = -1.0 / 0.0
data
src
[ "open import Prelude", "open import Prelude.Equality.Unsafe", "open import Agda.Builtin.Float" ]
src/Builtin/Float.agda
LessFloat
natToFloat : Nat → Float
function
src
[ "open import Prelude", "open import Prelude.Equality.Unsafe", "open import Agda.Builtin.Float" ]
src/Builtin/Float.agda
natToFloat
intToFloat : Int → Float
function
src
[ "open import Prelude", "open import Prelude.Equality.Unsafe", "open import Agda.Builtin.Float" ]
src/Builtin/Float.agda
intToFloat
isFinite : Float → Bool
function
src
[ "open import Prelude", "open import Prelude.Equality.Unsafe", "open import Agda.Builtin.Float" ]
src/Builtin/Float.agda
isFinite
π : Float
function
src
[ "open import Prelude", "open import Prelude.Equality.Unsafe", "open import Agda.Builtin.Float" ]
src/Builtin/Float.agda
π
cos : Float → Float
function
src
[ "open import Prelude", "open import Prelude.Equality.Unsafe", "open import Agda.Builtin.Float" ]
src/Builtin/Float.agda
cos
tan : Float → Float
function
src
[ "open import Prelude", "open import Prelude.Equality.Unsafe", "open import Agda.Builtin.Float" ]
src/Builtin/Float.agda
tan
log : Float → Float → Float
function
src
[ "open import Prelude", "open import Prelude.Equality.Unsafe", "open import Agda.Builtin.Float" ]
src/Builtin/Float.agda
log
NaN : Float
function
src
[ "open import Prelude", "open import Prelude.Equality.Unsafe", "open import Agda.Builtin.Float" ]
src/Builtin/Float.agda
NaN
Inf : Float
function
src
[ "open import Prelude", "open import Prelude.Equality.Unsafe", "open import Agda.Builtin.Float" ]
src/Builtin/Float.agda
Inf
-Inf : Float
function
src
[ "open import Prelude", "open import Prelude.Equality.Unsafe", "open import Agda.Builtin.Float" ]
src/Builtin/Float.agda
-Inf
LessName (x y : Name) : Set where less-name : primQNameLess x y ≡ true → LessName x y private cmpName : ∀ x y → Comparison LessName x y cmpName x y with inspect (primQNameLess x y) ... | true with≡ eq = less (less-name eq) ... | false with≡ _ with inspect (primQNameLess y x) ... | true with≡ eq = greater (less-name eq) ... | false with≡ _ = equal unsafeEqual instance OrdName : Ord Name OrdName = defaultOrd cmpName OrdLawsName : Ord/Laws Name Ord/Laws.super OrdLawsName = it less-antirefl {{OrdLawsName}} (less-name eq) = unsafeNotEqual eq less-trans {{OrdLawsName}} (less-name _) (less-name _) = less-name unsafeEqual --- Meta variables --- instance ShowMeta : Show Meta showsPrec {{ShowMeta}} _ x = showString (primShowMeta x) instance EqMeta : Eq Meta _==_ {{EqMeta}} x y with primMetaEquality x y ... | true = yes unsafeEqual ... | false = no unsafeNotEqual
data
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
LessName
LessMeta (x y : Meta) : Set where less-meta : primMetaLess x y ≡ true → LessMeta x y private cmpMeta : ∀ x y → Comparison LessMeta x y cmpMeta x y with inspect (primMetaLess x y) ... | true with≡ eq = less (less-meta eq) ... | false with≡ _ with inspect (primMetaLess y x) ... | true with≡ eq = greater (less-meta eq) ... | false with≡ _ = equal unsafeEqual instance OrdMeta : Ord Meta OrdMeta = defaultOrd cmpMeta OrdLawsMeta : Ord/Laws Meta Ord/Laws.super OrdLawsMeta = it less-antirefl {{OrdLawsMeta}} (less-meta eq) = unsafeNotEqual eq less-trans {{OrdLawsMeta}} (less-meta _) (less-meta _) = less-meta unsafeEqual --- Literals --- instance ShowLiteral : Show Literal showsPrec {{ShowLiteral}} _ (nat n) = shows n showsPrec {{ShowLiteral}} _ (word64 n) = shows n showsPrec {{ShowLiteral}} _ (float x) = shows x showsPrec {{ShowLiteral}} _ (char c) = shows c showsPrec {{ShowLiteral}} _ (string s) = shows s showsPrec {{ShowLiteral}} _ (name x) = shows x showsPrec {{ShowLiteral}} _ (meta x) = shows x --- Terms --- pattern default-modality = modality relevant quantity-ω pattern vArg x = arg (arg-info visible default-modality) x pattern hArg x = arg (arg-info hidden default-modality) x pattern iArg x = arg (arg-info instance′ default-modality) x unArg : Arg A → A unArg (arg _ x) = x getArgInfo : Arg A → ArgInfo getArgInfo (arg i _) = i getVisibility : Arg A → Visibility getVisibility (arg (arg-info v _) _) = v getModality : Arg A → Modality getModality (arg (arg-info _ m) _) = m getRelevance : Arg A → Relevance getRelevance (arg (arg-info _ (modality r _)) _) = r getQuantity : Arg A → Quantity getQuantity (arg (arg-info _ (modality _ q)) _) = q isVisible : Arg A → Bool isVisible (arg (arg-info visible _) _) = true isVisible _ = false instance FunctorArg : Functor {a = ℓ} Arg fmap {{FunctorArg}} f (arg i x) = arg i (f x) TraversableArg : Traversable {a = ℓ} Arg traverse {{TraversableArg}} f (arg i x) = ⦇ (arg i) (f x) ⦈ unAbs : Abs A → A unAbs (abs _ x) = x instance FunctorAbs : Functor {a = ℓ} Abs fmap {{FunctorAbs}} f (abs s x) = abs s (f x) TraversableAbs : Traversable {a = ℓ} Abs traverse {{TraversableAbs}} f (abs s x) = ⦇ (abs s) (f x) ⦈ absurd-lam : Term absurd-lam = pat-lam (absurd-clause (("()" , vArg unknown) ∷ []) (vArg (absurd 0) ∷ []) ∷ []) [] --- TC monad --- mapTC : (A → B) → TC A → TC B mapTC f m = bindTC m λ x → returnTC (f x) instance FunctorTC : Functor {ℓ} TC fmap {{FunctorTC}} = mapTC ApplicativeTC : Applicative {ℓ} TC pure {{ApplicativeTC}} = returnTC _<*>_ {{ApplicativeTC}} = monadAp bindTC MonadTC : Monad {ℓ} TC _>>=_ {{MonadTC}} = bindTC FunctorTC′ : Functor′ {ℓ₁} {ℓ₂} TC fmap′ {{FunctorTC′}} = mapTC ApplicativeTC′ : Applicative′ {ℓ₁} {ℓ₂} TC _<*>′_ {{ApplicativeTC′}} = monadAp′ bindTC MonadTC′ : Monad′ {ℓ₁} {ℓ₂} TC _>>=′_ {{MonadTC′}} = bindTC FunctorZeroTC : FunctorZero {ℓ} TC empty {{FunctorZeroTC}} = typeError [] AlternativeTC : Alternative {ℓ} TC _<|>_ {{AlternativeTC}} = catchTC Tactic = Term → TC ⊤ give : Term → Tactic give v = λ hole → unify hole v define : Arg Name → Type → List Clause → TC ⊤ define f a cs = declareDef f a >> defineFun (unArg f) cs newMeta : Type → TC Term newMeta = checkType unknown newMeta! : TC Term newMeta! = newMeta unknown typeErrorS : ∀ {a} {A : Set a} → String → TC A typeErrorS s = typeError (strErr s ∷ []) blockOnMeta! : ∀ {a} {A : Set a} → Meta → TC A blockOnMeta! x = commitTC >>=′ λ _ → blockOnMeta x inferNormalisedType : Term → TC Type inferNormalisedType t = withNormalisation true (inferType t) --- Convenient wrappers --- -- Zero for non-datatypes getParameters : Name → TC Nat getParameters d = caseM getDefinition d of λ { (data-type n _) → pure n ; _ → pure 0 } getConstructors : Name → TC (List Name) getConstructors d = caseM getDefinition d of λ { (data-type _ cs) → pure cs ; (record-type c _) → pure (c ∷ []) ; _ → typeError (strErr "Cannot get constructors of non-data or record type" ∷ nameErr d ∷ []) } getClauses : Name → TC (List Clause) getClauses d = caseM getDefinition d of λ { (function cs) → pure cs ; _ → typeError (strErr "Cannot get constructors of non-function type" ∷ nameErr d ∷ []) } -- Get the constructor of a record type (or single-constructor data type) recordConstructor : Name → TC Name recordConstructor r = caseM getConstructors r of λ { (c ∷ []) → pure c ; _ → typeError $ strErr "Cannot get constructor of non-record type" ∷ nameErr r ∷ [] } -- Injectivity of constructors arg-inj₁ : ∀ {i i′} {x x′ : A} → arg i x ≡ arg i′ x′ → i ≡ i′ arg-inj₁ refl = refl arg-inj₂ : ∀ {i i′} {x x′ : A} → arg i x ≡ arg i′ x′ → x ≡ x′ arg-inj₂ refl = refl arg-info-inj₁ : ∀ {v v′ r r′} → arg-info v r ≡ arg-info v′ r′ → v ≡ v′ arg-info-inj₁ refl = refl arg-info-inj₂ : ∀ {v v′ r r′} → arg-info v r ≡ arg-info v′ r′ → r ≡ r′ arg-info-inj₂ refl = refl modality-inj₁ : ∀ {r r′ q q′} → modality r q ≡ modality r′ q′ → r ≡ r′ modality-inj₁ refl = refl modality-inj₂ : ∀ {r r′ q q′} → modality r q ≡ modality r′ q′ → q ≡ q′ modality-inj₂ refl = refl abs-inj₁ : ∀ {s s′} {x x′ : A} → abs s x ≡ abs s′ x′ → s ≡ s′ abs-inj₁ refl = refl abs-inj₂ : ∀ {s s′} {x x′ : A} → abs s x ≡ abs s′ x′ → x ≡ x′ abs-inj₂ refl = refl --- Terms --- var-inj₁ : ∀ {x x′ args args′} → Term.var x args ≡ var x′ args′ → x ≡ x′ var-inj₁ refl = refl var-inj₂ : ∀ {x x′ args args′} → Term.var x args ≡ var x′ args′ → args ≡ args′ var-inj₂ refl = refl con-inj₁ : ∀ {c c′ args args′} → Term.con c args ≡ con c′ args′ → c ≡ c′ con-inj₁ refl = refl con-inj₂ : ∀ {c c′ args args′} → Term.con c args ≡ con c′ args′ → args ≡ args′ con-inj₂ refl = refl def-inj₁ : ∀ {f f′ args args′} → def f args ≡ def f′ args′ → f ≡ f′ def-inj₁ refl = refl def-inj₂ : ∀ {f f′ args args′} → def f args ≡ def f′ args′ → args ≡ args′ def-inj₂ refl = refl meta-inj₁ : ∀ {f f′ args args′} → Term.meta f args ≡ meta f′ args′ → f ≡ f′ meta-inj₁ refl = refl meta-inj₂ : ∀ {f f′ args args′} → Term.meta f args ≡ meta f′ args′ → args ≡ args′ meta-inj₂ refl = refl lam-inj₁ : ∀ {v v′ t t′} → lam v t ≡ lam v′ t′ → v ≡ v′ lam-inj₁ refl = refl lam-inj₂ : ∀ {v v′ t t′} → lam v t ≡ lam v′ t′ → t ≡ t′ lam-inj₂ refl = refl pat-lam-inj₁ : ∀ {v v′ t t′} → pat-lam v t ≡ pat-lam v′ t′ → v ≡ v′ pat-lam-inj₁ refl = refl pat-lam-inj₂ : ∀ {v v′ t t′} → pat-lam v t ≡ pat-lam v′ t′ → t ≡ t′ pat-lam-inj₂ refl = refl pi-inj₁ : ∀ {t₁ t₁′ t₂ t₂′} → pi t₁ t₂ ≡ pi t₁′ t₂′ → t₁ ≡ t₁′ pi-inj₁ refl = refl pi-inj₂ : ∀ {t₁ t₁′ t₂ t₂′} → pi t₁ t₂ ≡ pi t₁′ t₂′ → t₂ ≡ t₂′ pi-inj₂ refl = refl sort-inj : ∀ {x y} → agda-sort x ≡ agda-sort y → x ≡ y sort-inj refl = refl lit-inj : ∀ {x y} → Term.lit x ≡ lit y → x ≡ y lit-inj refl = refl --- Sorts --- set-inj : ∀ {x y} → set x ≡ set y → x ≡ y set-inj refl = refl prop-inj : ∀ {x y} → prop x ≡ prop y → x ≡ y prop-inj refl = refl slit-inj : ∀ {x y} → Sort.lit x ≡ lit y → x ≡ y slit-inj refl = refl spropLit-inj : ∀ {x y} → Sort.propLit x ≡ propLit y → x ≡ y spropLit-inj refl = refl sinf-inj : ∀ {x y} → Sort.inf x ≡ inf y → x ≡ y sinf-inj refl = refl --- Patterns --- pcon-inj₁ : ∀ {x y z w} → Pattern.con x y ≡ con z w → x ≡ z pcon-inj₁ refl = refl pcon-inj₂ : ∀ {x y z w} → Pattern.con x y ≡ con z w → y ≡ w pcon-inj₂ refl = refl pvar-inj : ∀ {x y} → Pattern.var x ≡ var y → x ≡ y pvar-inj refl = refl pdot-inj : ∀ {x y} → Pattern.dot x ≡ dot y → x ≡ y pdot-inj refl = refl plit-inj : ∀ {x y} → Pattern.lit x ≡ lit y → x ≡ y plit-inj refl = refl proj-inj : ∀ {x y} → Pattern.proj x ≡ proj y → x ≡ y proj-inj refl = refl absurd-inj : ∀ {x y} → absurd x ≡ absurd y → x ≡ y absurd-inj refl = refl --- Clauses --- clause-inj₁ : ∀ {x y z u v w} → clause x y z ≡ clause u v w → x ≡ u clause-inj₁ refl = refl clause-inj₂ : ∀ {x y z u v w} → clause x y z ≡ clause u v w → y ≡ v clause-inj₂ refl = refl clause-inj₃ : ∀ {x y z u v w} → clause x y z ≡ clause u v w → z ≡ w clause-inj₃ refl = refl absurd-clause-inj₁ : ∀ {x y z w} → absurd-clause x y ≡ absurd-clause z w → x ≡ z absurd-clause-inj₁ refl = refl absurd-clause-inj₂ : ∀ {x y z w} → absurd-clause x y ≡ absurd-clause z w → y ≡ w absurd-clause-inj₂ refl = refl --- Literals --- nat-inj : ∀ {x y} → nat x ≡ nat y → x ≡ y nat-inj refl = refl word64-inj : ∀ {x y} → word64 x ≡ word64 y → x ≡ y word64-inj refl = refl float-inj : ∀ {x y} → float x ≡ float y → x ≡ y float-inj refl = refl char-inj : ∀ {x y} → char x ≡ char y → x ≡ y char-inj refl = refl string-inj : ∀ {x y} → string x ≡ string y → x ≡ y string-inj refl = refl name-inj : ∀ {x y} → name x ≡ name y → x ≡ y name-inj refl = refl meta-inj : ∀ {x y} → Literal.meta x ≡ meta y → x ≡ y meta-inj refl = refl
data
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
LessMeta
unArg : Arg A → A
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
unArg
getArgInfo : Arg A → ArgInfo
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
getArgInfo
getVisibility : Arg A → Visibility
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
getVisibility
getModality : Arg A → Modality
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
getModality
getRelevance : Arg A → Relevance
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
getRelevance
getQuantity : Arg A → Quantity
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
getQuantity
isVisible : Arg A → Bool
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
isVisible
unAbs : Abs A → A
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
unAbs
absurd-lam : Term
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
absurd-lam
mapTC : (A → B) → TC A → TC B
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
mapTC
give : Term → Tactic
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
give
define : Arg Name → Type → List Clause → TC ⊤
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
define
newMeta : Type → TC Term
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
newMeta
typeErrorS : ∀ {a} {A : Set a} → String → TC A
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
typeErrorS
inferNormalisedType : Term → TC Type
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
inferNormalisedType
getParameters : Name → TC Nat
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
getParameters
getConstructors : Name → TC (List Name)
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
getConstructors
getClauses : Name → TC (List Clause)
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
getClauses
recordConstructor : Name → TC Name
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
recordConstructor
arg-inj₁ : ∀ {i i′} {x x′ : A} → arg i x ≡ arg i′ x′ → i ≡ i′
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
arg-inj₁
arg-inj₂ : ∀ {i i′} {x x′ : A} → arg i x ≡ arg i′ x′ → x ≡ x′
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
arg-inj₂
arg-info-inj₁ : ∀ {v v′ r r′} → arg-info v r ≡ arg-info v′ r′ → v ≡ v′
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
arg-info-inj₁
arg-info-inj₂ : ∀ {v v′ r r′} → arg-info v r ≡ arg-info v′ r′ → r ≡ r′
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
arg-info-inj₂
modality-inj₁ : ∀ {r r′ q q′} → modality r q ≡ modality r′ q′ → r ≡ r′
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
modality-inj₁
modality-inj₂ : ∀ {r r′ q q′} → modality r q ≡ modality r′ q′ → q ≡ q′
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
modality-inj₂
abs-inj₁ : ∀ {s s′} {x x′ : A} → abs s x ≡ abs s′ x′ → s ≡ s′
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
abs-inj₁
abs-inj₂ : ∀ {s s′} {x x′ : A} → abs s x ≡ abs s′ x′ → x ≡ x′
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
abs-inj₂
var-inj₁ : ∀ {x x′ args args′} → Term.var x args ≡ var x′ args′ → x ≡ x′
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
var-inj₁
var-inj₂ : ∀ {x x′ args args′} → Term.var x args ≡ var x′ args′ → args ≡ args′
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
var-inj₂
con-inj₁ : ∀ {c c′ args args′} → Term.con c args ≡ con c′ args′ → c ≡ c′
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
con-inj₁
con-inj₂ : ∀ {c c′ args args′} → Term.con c args ≡ con c′ args′ → args ≡ args′
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
con-inj₂
def-inj₁ : ∀ {f f′ args args′} → def f args ≡ def f′ args′ → f ≡ f′
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
def-inj₁
def-inj₂ : ∀ {f f′ args args′} → def f args ≡ def f′ args′ → args ≡ args′
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
def-inj₂
meta-inj₁ : ∀ {f f′ args args′} → Term.meta f args ≡ meta f′ args′ → f ≡ f′
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
meta-inj₁
meta-inj₂ : ∀ {f f′ args args′} → Term.meta f args ≡ meta f′ args′ → args ≡ args′
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
meta-inj₂
lam-inj₁ : ∀ {v v′ t t′} → lam v t ≡ lam v′ t′ → v ≡ v′
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
lam-inj₁
lam-inj₂ : ∀ {v v′ t t′} → lam v t ≡ lam v′ t′ → t ≡ t′
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
lam-inj₂
pat-lam-inj₁ : ∀ {v v′ t t′} → pat-lam v t ≡ pat-lam v′ t′ → v ≡ v′
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
pat-lam-inj₁
pat-lam-inj₂ : ∀ {v v′ t t′} → pat-lam v t ≡ pat-lam v′ t′ → t ≡ t′
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
pat-lam-inj₂
pi-inj₁ : ∀ {t₁ t₁′ t₂ t₂′} → pi t₁ t₂ ≡ pi t₁′ t₂′ → t₁ ≡ t₁′
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
pi-inj₁
pi-inj₂ : ∀ {t₁ t₁′ t₂ t₂′} → pi t₁ t₂ ≡ pi t₁′ t₂′ → t₂ ≡ t₂′
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
pi-inj₂
sort-inj : ∀ {x y} → agda-sort x ≡ agda-sort y → x ≡ y
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
sort-inj
lit-inj : ∀ {x y} → Term.lit x ≡ lit y → x ≡ y
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
lit-inj
set-inj : ∀ {x y} → set x ≡ set y → x ≡ y
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
set-inj
prop-inj : ∀ {x y} → prop x ≡ prop y → x ≡ y
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
prop-inj
slit-inj : ∀ {x y} → Sort.lit x ≡ lit y → x ≡ y
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
slit-inj
spropLit-inj : ∀ {x y} → Sort.propLit x ≡ propLit y → x ≡ y
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
spropLit-inj
sinf-inj : ∀ {x y} → Sort.inf x ≡ inf y → x ≡ y
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
sinf-inj
pcon-inj₁ : ∀ {x y z w} → Pattern.con x y ≡ con z w → x ≡ z
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
pcon-inj₁
pcon-inj₂ : ∀ {x y z w} → Pattern.con x y ≡ con z w → y ≡ w
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
pcon-inj₂
pvar-inj : ∀ {x y} → Pattern.var x ≡ var y → x ≡ y
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
pvar-inj
pdot-inj : ∀ {x y} → Pattern.dot x ≡ dot y → x ≡ y
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
pdot-inj
plit-inj : ∀ {x y} → Pattern.lit x ≡ lit y → x ≡ y
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
plit-inj
proj-inj : ∀ {x y} → Pattern.proj x ≡ proj y → x ≡ y
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
proj-inj
absurd-inj : ∀ {x y} → absurd x ≡ absurd y → x ≡ y
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
absurd-inj
clause-inj₁ : ∀ {x y z u v w} → clause x y z ≡ clause u v w → x ≡ u
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
clause-inj₁
clause-inj₂ : ∀ {x y z u v w} → clause x y z ≡ clause u v w → y ≡ v
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
clause-inj₂
clause-inj₃ : ∀ {x y z u v w} → clause x y z ≡ clause u v w → z ≡ w
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
clause-inj₃
absurd-clause-inj₁ : ∀ {x y z w} → absurd-clause x y ≡ absurd-clause z w → x ≡ z
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
absurd-clause-inj₁
absurd-clause-inj₂ : ∀ {x y z w} → absurd-clause x y ≡ absurd-clause z w → y ≡ w
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
absurd-clause-inj₂
nat-inj : ∀ {x y} → nat x ≡ nat y → x ≡ y
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
nat-inj
word64-inj : ∀ {x y} → word64 x ≡ word64 y → x ≡ y
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
word64-inj
float-inj : ∀ {x y} → float x ≡ float y → x ≡ y
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
float-inj
char-inj : ∀ {x y} → char x ≡ char y → x ≡ y
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
char-inj
string-inj : ∀ {x y} → string x ≡ string y → x ≡ y
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
string-inj
name-inj : ∀ {x y} → name x ≡ name y → x ≡ y
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
name-inj
meta-inj : ∀ {x y} → Literal.meta x ≡ meta y → x ≡ y
function
src
[ "open import Prelude hiding (abs)", "open import Prelude.Equality.Unsafe", "open import Builtin.Float", "open import Container.Traversable", "open import Control.Monad.Zero", "open import Prelude.Variables", "open import Agda.Builtin.Reflection as Builtin" ]
src/Builtin/Reflection.agda
meta-inj
Bag : Set → Set
function
src
[ "open import Prelude" ]
src/Container/Bag.agda
Bag
FunctorBag : Functor Bag
function
src
[ "open import Prelude" ]
src/Container/Bag.agda
FunctorBag
union : {A : Set} {{OrdA : Ord A}} → Bag A → Bag A → Bag A
function
src
[ "open import Prelude" ]
src/Container/Bag.agda
union
Foldable {a b w} (F : Set a → Set b) : Set (lsuc w ⊔ lsuc a ⊔ b) where field foldMap : ∀ {A}{W : Set w} {{MonW : Monoid W}} → (A → W) → F A → W overlap {{super}} : Functor F
record
src
[ "open import Prelude" ]
src/Container/Foldable.agda
Foldable
fold : ∀ {a w} {W : Set w} {F : Set w → Set a} {{FoldF : Foldable F}} {{MonW : Monoid W}} → F W → W
function
src
[ "open import Prelude" ]
src/Container/Foldable.agda
fold
minimum : ∀ {a w} {W : Set w} {F : Set w → Set a} {{FoldF : Foldable F}} {{OrdW : Ord W}} → F W → Maybe W
function
src
[ "open import Prelude" ]
src/Container/Foldable.agda
minimum
maximum : ∀ {a w} {W : Set w} {F : Set w → Set a} {{FoldF : Foldable F}} {{OrdW : Ord W}} → F W → Maybe W
function
src
[ "open import Prelude" ]
src/Container/Foldable.agda
maximum
End of preview. Expand in Data Studio

Agda-Prelude

Structured dataset from agda-prelude — Programming utilities by Ulf Norell.

735 declarations extracted from Agda source files.

Applications

  • Training language models on formal proofs
  • Fine-tuning theorem provers
  • Retrieval-augmented generation for proof assistants
  • Learning proof embeddings and representations

Source

Schema

Column Type Description
fact string Declaration body
type string data, record, function
library string Source module
imports list Required imports
filename string Source file path
symbolic_name string Identifier
Downloads last month
24
Size of downloaded dataset files:
73.7 kB
Size of the auto-converted Parquet files:
73.7 kB
Number of rows:
735

Collection including phanerozoic/Agda-Prelude