name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CompleteSublattice.ext_iff | Mathlib.Order.CompleteLattice.SetLike | ∀ {X : Type u_1} {L : CompleteSublattice (Set X)} {S T : ↥L}, S = T ↔ ∀ (x : X), x ∈ S ↔ x ∈ T | null | true |
CategoryTheory.Limits.ι_comp_colimitLeftOpIsoUnopLimit_hom | Mathlib.CategoryTheory.Limits.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} J]
(F : CategoryTheory.Functor J Cᵒᵖ) [inst_2 : CategoryTheory.Limits.HasLimit F] (j : Jᵒᵖ),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimit.ι F.leftOp j)
(CategoryTheory.Limi... | null | true |
sSupHom.rec | Mathlib.Order.Hom.CompleteLattice | {α : Type u_8} →
{β : Type u_9} →
[inst : SupSet α] →
[inst_1 : SupSet β] →
{motive : sSupHom α β → Sort u} →
((toFun : α → β) →
(map_sSup' : ∀ (s : Set α), toFun (sSup s) = sSup (toFun '' s)) →
motive { toFun := toFun, map_sSup' := map_sSup' }) →
... | null | false |
_private.Mathlib.GroupTheory.SpecificGroups.Alternating.Simple.0.alternatingGroup.normal_subgroup_eq_bot_or_eq_top_of_card_ne_eight._proof_1_3 | Mathlib.GroupTheory.SpecificGroups.Alternating.Simple | ∀ {α : Type u_1}, SubmonoidClass (Subgroup (α ≃ α)) (α ≃ α) | null | false |
Quaternion.imJ_fst_dualNumberEquiv | Mathlib.Algebra.DualQuaternion | ∀ {R : Type u_1} [inst : CommRing R] (q : Quaternion (DualNumber R)),
(TrivSqZeroExt.fst (Quaternion.dualNumberEquiv q)).imJ = TrivSqZeroExt.fst q.imJ | null | true |
FiberPrebundle.totalSpaceMk_preimage_source | Mathlib.Topology.FiberBundle.Basic | ∀ {B : Type u_2} {F : Type u_3} {E : B → Type u_5} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
[inst_2 : (x : B) → TopologicalSpace (E x)] (a : FiberPrebundle F E) (b : B),
Bundle.TotalSpace.mk b ⁻¹' (a.pretrivializationAt b).source = Set.univ | null | true |
derivWithin_ofNat | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] (s : Set 𝕜) (n : ℕ) [inst_3 : OfNat F n], derivWithin (OfNat.ofNat n) s = 0 | null | true |
_private.Mathlib.RingTheory.KrullDimension.Basic.0.Ring.krullDimLE_one_iff._simp_1_1 | Mathlib.RingTheory.KrullDimension.Basic | ∀ (n : ℕ) (α : Type u_1) [inst : Preorder α], Order.KrullDimLE n α = (Order.krullDim α ≤ ↑n) | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey?_inter_of_contains_eq_false_right._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
Lean.«_aux_Init_BinderPredicates___macroRules_Lean_term∃__,__1» | Init.BinderPredicates | Lean.Macro | null | false |
_private.Mathlib.FieldTheory.Normal.Closure.0.IntermediateField.normalClosure_def'.match_1_3 | Mathlib.FieldTheory.Normal.Closure | ∀ {F : Type u_2} {L : Type u_1} [inst : Field F] [inst_1 : Field L] [inst_2 : Algebra F L] (K : IntermediateField F L)
(f : L →ₐ[F] L) (b : L) (motive : b ∈ IntermediateField.map f K → Prop) (x : b ∈ IntermediateField.map f K),
(∀ (a : L) (h : a ∈ ↑K.toSubsemiring ∧ ↑f a = b), motive ⋯) → motive x | null | false |
Polynomial.splits_mul_X | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : CommRing R] {f : Polynomial R} [IsDomain R], (f * Polynomial.X).Splits ↔ f.Splits | null | true |
_private.Mathlib.NumberTheory.ModularForms.CongruenceSubgroups.0.CongruenceSubgroup.exists_Gamma_le_conj._simp_1_1 | Mathlib.NumberTheory.ModularForms.CongruenceSubgroups | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] (A B : GL n R),
↑A * ↑B = ↑(A * B) | null | false |
Lean.AttributeExtensionState.ctorIdx | Lean.Attributes | Lean.AttributeExtensionState → ℕ | null | false |
Mathlib.Tactic.ITauto.prove._unsafe_rec | Mathlib.Tactic.ITauto | Mathlib.Tactic.ITauto.Context → Mathlib.Tactic.ITauto.IProp → StateM ℕ (Bool × Mathlib.Tactic.ITauto.Proof) | null | false |
Lean.Lsp.instFileSourceTextDocumentPositionParams | Lean.Server.FileSource | Lean.Lsp.FileSource Lean.Lsp.TextDocumentPositionParams | null | true |
Lean.Parser.instBEqCacheableParserContext._proof_1 | Lean.Parser.Types | ∀ (a b : Lean.Parser.CacheableParserContext),
a.forbiddenTks = b.forbiddenTks → (a.forbiddenTks == b.forbiddenTks) = true | null | false |
LightCondSet | Mathlib.Condensed.Light.Basic | Type (u + 1) | Light condensed sets. Because `LightProfinite` is an essentially small category, we don't need the
same universe bump as in `CondensedSet`.
| true |
CategoryTheory.Linear | Mathlib.CategoryTheory.Linear.Basic | (R : Type w) →
[Semiring R] →
(C : Type u) → [inst : CategoryTheory.Category.{v, u} C] → [CategoryTheory.Preadditive C] → Type (max (max u v) w) | A category is called `R`-linear if `P ⟶ Q` is an `R`-module such that composition is
`R`-linear in both variables. | true |
CategoryTheory.GrothendieckTopology.Point.presheafFiberDesc | Mathlib.CategoryTheory.Sites.Point.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
(Φ : J.Point) →
{A : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} A] →
[inst_2 : CategoryTheory.Limits.HasColimitsOfSize.{w, w, v', u'} A] →
{P : Cate... | Constructor for morphisms from the fiber of a presheaf. | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.cons_append._proof_1 | Init.Data.BitVec.Lemmas | ∀ {w₁ w₂ : ℕ}, ¬w₁ + w₂ + 1 = w₁ + 1 + w₂ → False | null | false |
Filter.instInf._proof_2 | Mathlib.Order.Filter.Defs | ∀ {α : Type u_1} (f g : Filter α) {x y : Set α},
x ∈ {s | ∃ a ∈ f, ∃ b ∈ g, s = a ∩ b} → x ⊆ y → y ∈ {s | ∃ a ∈ f, ∃ b ∈ g, s = a ∩ b} | null | false |
LocallyConstant.coeFnAlgHom._proof_1 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] (R : Type u_3) [inst_1 : CommSemiring R]
[inst_2 : Semiring Y] [inst_3 : Algebra R Y] (x : R),
(↑↑LocallyConstant.coeFnRingHom).toFun ((algebraMap R (LocallyConstant X Y)) x) =
(↑↑LocallyConstant.coeFnRingHom).toFun ((algebraMap R (LocallyConstant X Y)... | null | false |
_private.Lean.Compiler.LCNF.Simp.ConstantFold.0.Lean.Compiler.LCNF.Simp.ConstantFold.arithmeticFolders._proof_14 | Lean.Compiler.LCNF.Simp.ConstantFold | ∀ (a : ℕ), a * 1 = a | null | false |
Std.DTreeMap.Internal.RcoSliceData.casesOn | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
{motive : Std.DTreeMap.Internal.RcoSliceData α β → Sort u_1} →
(t : Std.DTreeMap.Internal.RcoSliceData α β) →
((treeMap : Std.DTreeMap.Internal.Impl α β) →
(range : Std.Rco α) → motive { treeMap := treeMap, range := range }) ... | null | false |
SimplexCategory.skeletalEquivalence | Mathlib.AlgebraicTopology.SimplexCategory.Basic | SimplexCategory ≌ NonemptyFinLinOrd | The equivalence that exhibits `SimplexCategory` as skeleton
of `NonemptyFinLinOrd` | true |
_private.Mathlib.LinearAlgebra.Dimension.Finite.0.Module.finite_finsupp_iff._simp_1_3 | Mathlib.LinearAlgebra.Dimension.Finite | ∀ {a b : Prop}, (a ∨ b) = (¬a → b) | null | false |
Lean.IR.EmitLLVM.declareVars._unsafe_rec | Lean.Compiler.IR.EmitLLVM | {llvmctx : Lean.LLVM.Context} → Lean.LLVM.Builder llvmctx → Lean.IR.FnBody → Lean.IR.EmitLLVM.M llvmctx Unit | null | false |
BddLat.Iso.mk._proof_6 | Mathlib.Order.Category.BddLat | ∀ {α β : BddLat} (e : ↑α.toLat ≃o ↑β.toLat) (a b : ↑α.1),
{ toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ }.toFun (a ⊓ b) =
{ toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ }.toFun a ⊓ { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ }.toFun b | null | false |
gronwallBound_x0 | Mathlib.Analysis.ODE.Gronwall | ∀ (δ K ε : ℝ), gronwallBound δ K ε 0 = δ | null | true |
Std.HashMap.Raw.Equiv.diff_right | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ m₃ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → m₃.WF → m₂.Equiv m₃ → (m₁ \ m₂).Equiv (m₁ \ m₃) | null | true |
_private.Mathlib.SetTheory.ZFC.Class.0.ZFSet.coe_equiv_aux._simp_1_1 | Mathlib.SetTheory.ZFC.Class | ∀ (x : PSet.{u_1}), x.Equiv x = True | null | false |
String.Slice.endsWith_string_eq_false_iff._simp_1 | Init.Data.String.Lemmas.Pattern.TakeDrop.String | ∀ {pat : String} {s : String.Slice}, (s.endsWith pat = false) = ¬pat.toList <:+ s.copy.toList | null | false |
_private.Mathlib.Order.Bounds.Basic.0.upperBounds_empty._simp_1_1 | Mathlib.Order.Bounds.Basic | ∀ {α : Type u} {s : Set α}, (s = Set.univ) = ∀ (x : α), x ∈ s | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd.go_decl_eq | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (curr : ℕ) (hcurr : curr ≤ w)
(cin : aig.Ref) (s : aig.RefVec curr) (lhs rhs : aig.RefVec w) (idx : ℕ) (h1 : idx < aig.decls.size)
(h2 : idx < (Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd.go aig lhs rhs curr hcurr cin s).aig.de... | null | true |
Lean.Parser.setExpected | Lean.Parser.Basic | List String → Lean.Parser.Parser → Lean.Parser.Parser | null | true |
Polynomial.dickson_of_two_le | Mathlib.RingTheory.Polynomial.Dickson | ∀ {R : Type u_1} [inst : CommRing R] (k : ℕ) (a : R) {n : ℕ},
2 ≤ n →
Polynomial.dickson k a n =
Polynomial.X * Polynomial.dickson k a (n - 1) - Polynomial.C a * Polynomial.dickson k a (n - 2) | null | true |
UInt8.toUInt64_shiftLeft | Init.Data.UInt.Bitwise | ∀ (a b : UInt8), (a <<< b).toUInt64 = a.toUInt64 <<< (b % 8).toUInt64 % 256 | null | true |
AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.hasPullback_of_right | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : AlgebraicGeometry.PresheafedSpace C} (f : X ⟶ Z)
[hf : AlgebraicGeometry.PresheafedSpace.IsOpenImmersion f] (g : Y ⟶ Z), CategoryTheory.Limits.HasPullback g f | null | true |
LightDiagram.cone | Mathlib.Topology.Category.LightProfinite.Basic | (self : LightDiagram) → CategoryTheory.Limits.Cone (self.diagram.comp FintypeCat.toProfinite) | The limit cone. | true |
Equidecomp.mk._flat_ctor | Mathlib.Algebra.Group.Action.Equidecomp | {X : Type u_1} →
{G : Type u_2} →
[inst : SMul G X] →
(toFun invFun : X → X) →
(source target : Set X) →
(∀ ⦃x : X⦄, x ∈ source → toFun x ∈ target) →
(∀ ⦃x : X⦄, x ∈ target → invFun x ∈ source) →
(∀ ⦃x : X⦄, x ∈ source → invFun (toFun x) = x) →
(∀ ... | null | false |
FunLike.commMonoid._proof_1 | Mathlib.Algebra.Group.FunLike | ∀ {F : Type u_3} {α : Type u_1} {β : Type u_2} [inst : FunLike F α β] [inst_1 : One F] [inst_2 : CommMonoid β]
[IsOneApply F α β], ⇑1 = 1 | null | false |
_private.Batteries.Data.List.Basic.0.List.rotate.match_1.eq_1 | Batteries.Data.List.Basic | ∀ {α : Type u_1} (motive : List α × List α → Sort u_2) (l₁ l₂ : List α) (h_1 : (l₁ l₂ : List α) → motive (l₁, l₂)),
(match (l₁, l₂) with
| (l₁, l₂) => h_1 l₁ l₂) =
h_1 l₁ l₂ | null | true |
Polynomial.SplittingField.instField._proof_13 | Mathlib.FieldTheory.SplittingField.Construction | ∀ {K : Type u_1} [inst : Field K], IsScalarTower ℚ K K | null | false |
Lean.Meta.Sym.Arith.ClassifyResult.nonCommSemiring.elim | Lean.Meta.Sym.Arith.Types | {motive : Lean.Meta.Sym.Arith.ClassifyResult → Sort u} →
(t : Lean.Meta.Sym.Arith.ClassifyResult) →
t.ctorIdx = 3 → ((id : ℕ) → motive (Lean.Meta.Sym.Arith.ClassifyResult.nonCommSemiring id)) → motive t | null | false |
Algebra.FormallyUnramified.isRadical_map_isMaximal | Mathlib.RingTheory.Unramified.Field | ∀ (A : Type u_2) [inst : CommRing A] (B : Type u_4) [inst_1 : CommRing B] [inst_2 : Algebra A B]
[Algebra.EssFiniteType A B] [Algebra.FormallyUnramified A B] (p : Ideal A) [p.IsMaximal],
(Ideal.map (algebraMap A B) p).IsRadical | null | true |
Lean.Expr.isAppOfArity._f | Lean.Expr | (x : Lean.Expr) → Lean.Expr.below (motive := fun x => Lean.Name → ℕ → Bool) x → Lean.Name → ℕ → Bool | null | false |
Configuration.HasPoints.hasLines._proof_1 | Mathlib.Combinatorics.Configuration | ∀ {P : Type u_2} {L : Type u_1} [inst : Fintype P] [inst_1 : Fintype L],
Fintype.card P = Fintype.card L → Fintype.card L = Fintype.card P | null | false |
IsNonarchimedeanLocalField.instCompleteSpace | Mathlib.NumberTheory.LocalField.Basic | ∀ (K : Type u_1) [inst : Field K] [inst_1 : ValuativeRel K] [inst_2 : UniformSpace K] [IsUniformAddGroup K]
[IsNonarchimedeanLocalField K], CompleteSpace K | null | true |
CategoryTheory.CartesianMonoidalCategory.lift_comp_fst_snd | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{X Y Z : C} (f : X ⟶ CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z),
CategoryTheory.CartesianMonoidalCategory.lift
(CategoryTheory.CategoryStruct.comp f (CategoryTheory.SemiCartesianMonoidalCat... | null | true |
Subrel.inclusionEmbedding._proof_1 | Mathlib.Order.RelIso.Set | ∀ {α : Type u_1} {s t : Set α} (h : s ⊆ t) (x x_1 : { x // x ∈ s }), Set.inclusion h x = Set.inclusion h x_1 → x = x_1 | null | false |
NormedSpace.casesOn | Mathlib.Analysis.Normed.Module.Basic | {𝕜 : Type u_6} →
{E : Type u_7} →
[inst : NormedField 𝕜] →
[inst_1 : SeminormedAddCommGroup E] →
{motive : NormedSpace 𝕜 E → Sort u} →
(t : NormedSpace 𝕜 E) →
([toModule : Module 𝕜 E] →
(norm_smul_le : ∀ (a : 𝕜) (b : E), ‖a • b‖ ≤ ‖a‖ * ‖b‖) →
... | null | false |
Ideal.stableFiltration_N | Mathlib.RingTheory.Filtration | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (I : Ideal R)
(N : Submodule R M) (i : ℕ), (I.stableFiltration N).N i = I ^ i • N | null | true |
AddMonoidAlgebra.rTensorEquivAlgEquiv.eq_1 | Mathlib.RingTheory.TensorProduct.MonoidAlgebra | ∀ (R : Type u_1) {M : Type u_2} (S : Type u_4) (A : Type u_5) (B : Type u_6) [inst : CommSemiring R]
[inst_1 : CommSemiring S] [inst_2 : CommSemiring A] [inst_3 : CommSemiring B] [inst_4 : Algebra R S]
[inst_5 : Algebra R A] [inst_6 : Algebra R B] [inst_7 : Algebra S A] [inst_8 : IsScalarTower R S A]
[inst_9 : Ad... | null | true |
AddConstMap._aux_Mathlib_Algebra_AddConstMap_Basic___unexpand_AddConstMap_1 | Mathlib.Algebra.AddConstMap.Basic | Lean.PrettyPrinter.Unexpander | null | false |
ENNReal.natCast_lt_top | Mathlib.Basic.ENNReal.Basic | ∀ (n : ℕ), ↑n < ⊤ | null | true |
Nat.doubleFactorial.eq_3 | Mathlib.Data.Nat.Factorial.DoubleFactorial | ∀ (k : ℕ), k.succ.succ.doubleFactorial = (k + 2) * k.doubleFactorial | null | true |
UpperHalfPlane.instContinuousSMulSL2R | Mathlib.Analysis.Complex.UpperHalfPlane.ProperAction | ContinuousSMul (Matrix.SpecialLinearGroup (Fin 2) ℝ) UpperHalfPlane | The action of `SL(2, ℝ)` on `ℍ` is jointly continuous. | true |
List.next_getLast_eq_head | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] (l : List α) (h : l ≠ []), l.Nodup → l.next (l.getLast h) ⋯ = l.head h | null | true |
_private.Init.Data.UInt.Bitwise.0.UInt32.shiftLeft_add._proof_1_2 | Init.Data.UInt.Bitwise | ∀ {b c : UInt32}, b.toNat < 32 → c.toNat < 32 → ¬b.toNat + c.toNat < 4294967296 → False | null | false |
Algebra.IsAlgebraic.algEquivEquivAlgHom._proof_2 | Mathlib.RingTheory.Algebraic.Basic | ∀ (K : Type u_2) (L : Type u_1) [inst : CommRing K] [inst_1 : IsDomain K] [inst_2 : Field L] [inst_3 : Algebra K L]
[inst_4 : Module.IsTorsionFree K L] [inst_5 : Algebra.IsAlgebraic K L],
Function.RightInverse (fun ϕ => AlgEquiv.ofBijective ϕ ⋯) fun ϕ => ↑ϕ | null | false |
_private.Mathlib.RingTheory.MvPolynomial.Symmetric.FundamentalTheorem.0.MvPolynomial.supDegree_monic_esymm._simp_1_2 | Mathlib.RingTheory.MvPolynomial.Symmetric.FundamentalTheorem | ∀ {α : Type u_1} {M : Type u_8} [inst : AddCommMonoid M] (s : Finset α) (f : α → M),
(∑ x ∈ s, fun₀ | x => f x) = Finsupp.indicator s fun x x_1 => f x | null | false |
CategoryTheory.HasShift.noConfusion | Mathlib.CategoryTheory.Shift.Basic | {P : Sort u_1} →
{C : Type u} →
{A : Type u_2} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : AddMonoid A} →
{t : CategoryTheory.HasShift C A} →
{C' : Type u} →
{A' : Type u_2} →
{inst' : CategoryTheory.Category.{v, u} C'} →
... | null | false |
StrictConcaveOn.lt_slope_of_hasDerivWithinAt | Mathlib.Analysis.Convex.Deriv | ∀ {S : Set ℝ} {f : ℝ → ℝ} {x y f' : ℝ},
StrictConcaveOn ℝ S f → x ∈ S → y ∈ S → x < y → HasDerivWithinAt f f' S y → f' < slope f x y | null | true |
Finsupp.instSemigroupWithZero._proof_1 | Mathlib.Data.Finsupp.Pointwise | ∀ {α : Type u_1} {β : Type u_2} [inst : SemigroupWithZero β], Function.Injective DFunLike.coe | null | false |
Lean.Meta.Grind.Arith.isNatType | Lean.Meta.Tactic.Grind.Arith.Util | Lean.Expr → Bool | Returns `true` if `e` is of the form `Nat` | true |
Lean.Elab.Term.withoutHeedElabAsElim | Lean.Elab.Term.TermElabM | {m : Type → Type u_1} → {α : Type} → [MonadFunctorT Lean.Elab.TermElabM m] → m α → m α | Execute `x` without heeding the `elab_as_elim` attribute. Useful when there is
no expected type (so `elabAppArgs` would fail), but expect that the user wants
to use such constants.
| true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree.0.WeierstrassCurve.natDegree_coeff_ΨSq_ofNat | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) (n : ℕ),
(W.ΨSq ↑n).natDegree ≤ n ^ 2 - 1 ∧ (W.ΨSq ↑n).coeff (n ^ 2 - 1) = ↑(↑n ^ 2) | null | true |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.assemble₃_eq_some_of_toBitVec._simp_1_9 | Init.Data.String.Decode | ∀ {n : ℕ} {x y : BitVec n}, (x = y) = (x.toNat = y.toNat) | null | false |
Std.DTreeMap.Raw.Const.forInUncurried_eq_forIn_toArray | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {δ : Type w} {m : Type w → Type w'} {β : Type v}
{t : Std.DTreeMap.Raw α (fun x => β) cmp} [inst : Monad m] [LawfulMonad m] {f : α × β → δ → m (ForInStep δ)}
{init : δ}, Std.DTreeMap.Raw.Const.forInUncurried f init t = forIn (Std.DTreeMap.Raw.Const.toArray t) init f | null | true |
_private.Mathlib.Tactic.SetNotationForOrder.0.Mathlib.Meta.SetNotationForOrder.initFn._@.Mathlib.Tactic.SetNotationForOrder.3871832695._hygCtx._hyg.2 | Mathlib.Tactic.SetNotationForOrder | IO Unit | Generate a variant of a theorem by restricting the order on the specified types to those
that are tagged `@[use_set_notation_for_order]`.
Explicitly, `to_set_notation` inserts a `[UsesSetNotationForOrder α]` type class
assumption for each type `α`.
TODO: it would be nice to be able to restrict which types get the assu... | false |
IsAlgClosed.exists_root | Mathlib.FieldTheory.IsAlgClosed.Basic | ∀ {k : Type u} [inst : Field k] [IsAlgClosed k] (p : Polynomial k), p.degree ≠ 0 → ∃ x, p.IsRoot x | If `k` is algebraically closed, then every nonconstant polynomial has a root.
| true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc.0.CategoryTheory.Limits._aux_Mathlib_CategoryTheory_Limits_Shapes_Pullback_Assoc___macroRules__private_Mathlib_CategoryTheory_Limits_Shapes_Pullback_Assoc_0_CategoryTheory_Limits_termF₂_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc | Lean.Macro | null | false |
CategoryTheory.IsHomLift.instIsHomLiftIdObj | Mathlib.CategoryTheory.FiberedCategory.HomLift | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₂} 𝒳] [inst_1 : CategoryTheory.Category.{v₂, u₁} 𝒮]
(p : CategoryTheory.Functor 𝒳 𝒮) (a : 𝒳),
p.IsHomLift (CategoryTheory.CategoryStruct.id (p.obj a)) (CategoryTheory.CategoryStruct.id a) | null | true |
_private.Mathlib.Data.Nat.Digits.Defs.0.Nat.ofDigits_inj_of_len_eq._simp_1_2 | Mathlib.Data.Nat.Digits.Defs | ∀ {G : Type u_1} [inst : Add G] [IsLeftCancelAdd G] (a : G) {b c : G}, (a + b = a + c) = (b = c) | null | false |
HahnSeries.single_zero_ratCast | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {Γ : Type u_1} {R : Type u_3} [inst : Zero Γ] [inst_1 : PartialOrder Γ] [inst_2 : Zero R] [inst_3 : RatCast R]
(q : ℚ), (HahnSeries.single 0) ↑q = ↑q | null | true |
_private.Mathlib.Topology.Constructions.SumProd.0.isOpenQuotientMap_prodMap_iff._proof_1_1 | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u_2} {Y : Type u_4} {W : Type u_3} {Z : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] [inst_3 : TopologicalSpace W] [Nonempty X] [Nonempty Z] {f : X → Y} {g : Z → W},
Nonempty Y → Nonempty W → (IsOpenQuotientMap (Prod.map f g) ↔ IsOpenQuotientMap f ∧ I... | null | false |
Vector.uset.congr_simp | Batteries.Data.Vector.Basic | ∀ {α : Type u_1} {n : ℕ} (xs xs_1 : Vector α n),
xs = xs_1 →
∀ (i i_1 : USize) (e_i : i = i_1) (v v_1 : α), v = v_1 → ∀ (h : i.toNat < n), xs.uset i v h = xs_1.uset i_1 v_1 ⋯ | null | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rio.toList_succ_eq_map._simp_1_10 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerable α]
[inst_2 : Std.PRange.InfinitelyUpwardEnumerable α] [Std.PRange.LinearlyUpwardEnumerable α] {a b : α},
Std.PRange.UpwardEnumerable.LT (Std.PRange.succ a) (Std.PRange.succ b) = Std.PRange.UpwardEnumerable.LT a b | null | false |
Std.Tactic.BVDecide.BVExpr.shiftLeft._override | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {m n : ℕ} → Std.Tactic.BVDecide.BVExpr m → Std.Tactic.BVDecide.BVExpr n → Std.Tactic.BVDecide.BVExpr m | null | false |
Finset.HasAntidiagonal.antidiagonalOfLocallyFinite.eq_1 | Mathlib.Algebra.Order.Antidiag.Prod | ∀ {A : Type u_2} [inst : AddCommMagma A] [inst_1 : PartialOrder A] [inst_2 : CanonicallyOrderedAdd A]
[inst_3 : LocallyFiniteOrderBot A] [inst_4 : DecidableEq A],
Finset.HasAntidiagonal.antidiagonalOfLocallyFinite =
{ antidiagonal := fun n => {uv ∈ Finset.Iic n ×ˢ Finset.Iic n | uv.1 + uv.2 = n}, mem_antidiagon... | null | true |
Batteries.Tactic._aux_Batteries_Tactic_Init___macroRules_Batteries_Tactic_tacticSplit_ands_1 | Batteries.Tactic.Init | Lean.Macro | null | false |
MonoidAlgebra.domCongrBialgEquiv | Mathlib.RingTheory.Bialgebra.MonoidAlgebra | (R : Type u_1) →
(A : Type u_3) →
{M : Type u_8} →
{N : Type u_9} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Bialgebra R A] →
[inst_3 : Monoid M] → [inst_4 : Monoid N] → M ≃* N → MonoidAlgebra A M ≃ₐc[R] MonoidAlgebra A N | Isomorphic monoids have isomorphic monoid algebras. | true |
ContinuousAddMonoidHom.instAddCommMonoid.eq_1 | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {A : Type u_2} {E : Type u_6} [inst : AddMonoid A] [inst_1 : TopologicalSpace A] [inst_2 : AddCommMonoid E]
[inst_3 : TopologicalSpace E] [inst_4 : ContinuousAdd E],
ContinuousAddMonoidHom.instAddCommMonoid =
{ toZero := ContinuousAddMonoidHom.instZero A E, add := fun f g => (ContinuousAddMonoidHom.add E).com... | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Circle.0.Circle.angleDiff_nonneg._proof_1_2 | Mathlib.Analysis.SpecialFunctions.Complex.Circle | NormOneClass ℂ | null | false |
_private.Std.Http.Transport.0.Std.Http.Internal.Mock.SharedState._sizeOf_1 | Std.Http.Transport | Std.Http.Internal.Mock.SharedState✝ → ℕ | null | false |
Int.Internal.Linear.le_of_le_cert.induct_unfolding | Init.Data.Int.Linear | ∀ (motive : Int.Internal.Linear.Poly → Int.Internal.Linear.Poly → Bool → Prop),
(∀ (k : ℤ) (v : Int.Internal.Linear.Var) (p : Int.Internal.Linear.Poly) (k_1 : ℤ),
motive (Int.Internal.Linear.Poly.add k v p) (Int.Internal.Linear.Poly.num k_1) false) →
(∀ (k k_1 : ℤ) (v : Int.Internal.Linear.Var) (p : Int.Int... | null | true |
Meromorphic.logDeriv_mul_eventuallyEq | Mathlib.Analysis.Meromorphic.LogDeriv | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {𝕜' : Type u_2} [inst_1 : NontriviallyNormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {f g : 𝕜 → 𝕜'},
Meromorphic f →
Meromorphic g →
(∀ (x : 𝕜), meromorphicOrderAt f x ≠ ⊤) →
(∀ (x : 𝕜), meromorphicOrderAt g x ≠ ⊤) → logDeriv (f * g) =ᶠ[... | The logarithmic derivative converts products into sums: away from a codiscrete subset of `𝕜`, the
logarithmic derivative of a product of two meromorphic functions is the sum of the logarithmic
derivatives.
| true |
CategoryTheory.Arrow.isIso_iff_isIso_of_isIso | Mathlib.CategoryTheory.Comma.Arrow | ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] {W X Y Z : T} {f : W ⟶ X} {g : Y ⟶ Z}
(sq : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk g) [CategoryTheory.IsIso sq],
CategoryTheory.IsIso f ↔ CategoryTheory.IsIso g | null | true |
List.dropSlice_eq_dropSliceTR | Batteries.Data.List.Basic | @List.dropSlice = @List.dropSliceTR | null | true |
Option.forM_map | Init.Data.Option.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_4} [inst : Monad m] [LawfulMonad m] (o : Option α) (g : α → β)
(f : β → m PUnit.{u_1 + 1}), forM (Option.map g o) f = forM o fun a => f (g a) | null | true |
_private.Init.System.FilePath.0.System.FilePath.posOfLastSep | Init.System.FilePath | (p : System.FilePath) → Option p.toString.Pos | null | true |
ModuleCat.CoextendScalars.distribMulAction._proof_4 | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : Ring S] (f : R →+* S) (M : Type u_3)
[inst_2 : AddCommMonoid M] [inst_3 : Module R M] (s : S) (g h : ↑((ModuleCat.restrictScalars f).obj ↧S) →ₗ[R] M),
s • (g + h) = s • g + s • h | null | false |
TopologicalSpace.NonemptyCompacts.instNontrivial | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] [Nontrivial α], Nontrivial (TopologicalSpace.NonemptyCompacts α) | null | true |
CategoryTheory.SubmonoidFunctor._sizeOf_inst | Mathlib.CategoryTheory.Subfunctor.SubmonoidFunctor | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
(M : CategoryTheory.Functor C MonCat) → [SizeOf C] → SizeOf (CategoryTheory.SubmonoidFunctor M) | null | false |
Submonoid.LocalizationMap.isCancelMul | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : CommMonoid M] {S : Submonoid M} [inst_1 : CommMonoid N]
(f : S.LocalizationMap N) [IsCancelMul M], IsCancelMul N | null | true |
Fintype.truncRecEmptyOption | Mathlib.Data.Fintype.Option | {P : Type u → Sort v} →
({α β : Type u} → α ≃ β → P α → P β) →
P PEmpty.{u + 1} →
({α : Type u} → [Fintype α] → [DecidableEq α] → P α → P (Option α)) →
(α : Type u) → [Fintype α] → [DecidableEq α] → Trunc (P α) | A recursor principle for finite types, analogous to `Nat.rec`. It effectively says
that every `Fintype` is either `Empty` or `Option α`, up to an `Equiv`. | true |
Exists.snd | Mathlib.Basic.Logic.Basic | ∀ {b : Prop} {p : b → Prop} (h : Exists p), p ⋯ | null | true |
Mathlib.Tactic.Determinant.Cert.noConfusionType | Mathlib.Tactic.Determinant.Bird.Cert | Sort u →
{u : Lean.Level} →
{α : Q(Type u)} →
{rα : Q(CommRing «$α»)} →
Mathlib.Tactic.Determinant.Cert rα →
{u' : Lean.Level} →
{α' : Q(Type u')} → {rα' : Q(CommRing «$α'»)} → Mathlib.Tactic.Determinant.Cert rα' → Sort u | null | false |
Lean.Meta.Sym.ApplyResult.ctorElimType | Lean.Meta.Sym.Apply | {motive : Lean.Meta.Sym.ApplyResult → Sort u} → ℕ → Sort (max 1 u) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.