name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.JsonRpc.MessageMetaData.responseError.inj | Lean.Data.JsonRpc | ∀ {id : Lean.JsonRpc.RequestID} {code : Lean.JsonRpc.ErrorCode} {message : String} {data? : Option Lean.Json}
{id_1 : Lean.JsonRpc.RequestID} {code_1 : Lean.JsonRpc.ErrorCode} {message_1 : String} {data?_1 : Option Lean.Json},
Lean.JsonRpc.MessageMetaData.responseError id code message data? =
Lean.JsonRpc.MessageMetaData.responseError id_1 code_1 message_1 data?_1 →
id = id_1 ∧ code = code_1 ∧ message = message_1 ∧ data? = data?_1 |
Int.Linear.eq_def_cert.eq_1 | Init.Data.Int.Linear | ∀ (x : Int.Linear.Var) (xPoly p : Int.Linear.Poly),
Int.Linear.eq_def_cert x xPoly p = p.beq' (Int.Linear.Poly.add (-1) x xPoly) |
NNRatCast.noConfusionType | Mathlib.Data.Rat.Init | Sort u → {K : Type u_1} → NNRatCast K → {K' : Type u_1} → NNRatCast K' → Sort u |
Aesop.StatsExtensionEntry._sizeOf_inst | Aesop.Stats.Extension | SizeOf Aesop.StatsExtensionEntry |
pi_properSpace | Mathlib.Topology.MetricSpace.ProperSpace | ∀ {β : Type v} {X : β → Type u_3} [inst : Fintype β] [inst_1 : (b : β) → PseudoMetricSpace (X b)]
[h : ∀ (b : β), ProperSpace (X b)], ProperSpace ((b : β) → X b) |
Order.pred_eq_iff_covBy | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : PredOrder α] {a b : α} [NoMinOrder α], Order.pred b = a ↔ a ⋖ b |
Real.pow_arith_mean_le_arith_mean_pow_of_even | Mathlib.Analysis.MeanInequalitiesPow | ∀ {ι : Type u} (s : Finset ι) (w z : ι → ℝ),
(∀ i ∈ s, 0 ≤ w i) → ∑ i ∈ s, w i = 1 → ∀ {n : ℕ}, Even n → (∑ i ∈ s, w i * z i) ^ n ≤ ∑ i ∈ s, w i * z i ^ n |
_private.Init.Data.Nat.Lemmas.0.Nat.pow_self_pos._simp_1_1 | Init.Data.Nat.Lemmas | ∀ {a n : ℕ}, (0 < a ^ n) = (0 < a ∨ n = 0) |
Finset.inf_inv | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq α] [inst_1 : Inv α] [inst_2 : SemilatticeInf β]
[inst_3 : OrderTop β] (s : Finset α) (f : α → β), s⁻¹.inf f = s.inf fun x => f x⁻¹ |
Submodule.module'._proof_5 | Mathlib.Algebra.Module.Submodule.Defs | ∀ {S : Type u_3} {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M}
(p : Submodule R M) [inst_2 : Semiring S] [inst_3 : SMul S R] [inst_4 : Module S M] [inst_5 : IsScalarTower S R M]
(x : ↥p.toSubMulAction), 1 • x = x |
_private.Std.Internal.Async.System.0.Std.Internal.IO.Async.System.Environment.mk.noConfusion | Std.Internal.Async.System | {P : Sort u} →
{toHashMap toHashMap' : Std.HashMap String String} →
{ toHashMap := toHashMap } = { toHashMap := toHashMap' } → (toHashMap = toHashMap' → P) → P |
_private.Mathlib.Tactic.Explode.0.Mathlib.Explode.explodeCore.match_11 | Mathlib.Tactic.Explode | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((fn arg : Lean.Expr) → motive (fn.app arg)) →
((varName : Lean.Name) →
(varType val body : Lean.Expr) →
(nondep : Bool) → motive (Lean.Expr.letE varName varType val body nondep)) →
((x : Lean.Expr) → motive x) → motive e |
_private.Lean.Meta.Sym.Simp.DiscrTree.0.Lean.Meta.Sym.mkPathAux.match_1 | Lean.Meta.Sym.Simp.DiscrTree | (motive : Lean.Meta.DiscrTree.Key × Array Lean.Expr → Sort u_1) →
(x : Lean.Meta.DiscrTree.Key × Array Lean.Expr) →
((k : Lean.Meta.DiscrTree.Key) → (todo : Array Lean.Expr) → motive (k, todo)) → motive x |
MonoidHom.map_pow | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : Monoid M] [inst_1 : Monoid N] (f : M →* N) (a : M) (n : ℕ), f (a ^ n) = f a ^ n |
_private.Mathlib.GroupTheory.Perm.Centralizer.0.Equiv.Perm.Basis.toCentralizer_equivariant._simp_1_1 | Mathlib.GroupTheory.Perm.Centralizer | ∀ {G : Type u_3} [inst : Group G] {a b c : G}, (a * b⁻¹ = c) = (a = c * b) |
Nat.ne_zero_iff_zero_lt | Init.Data.Nat.Basic | ∀ {n : ℕ}, n ≠ 0 ↔ 0 < n |
CategoryTheory.Limits.preservesColimits_unop | Mathlib.CategoryTheory.Limits.Preserves.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ) [CategoryTheory.Limits.PreservesLimits F],
CategoryTheory.Limits.PreservesColimits F.unop |
Set.image_neg_uIcc | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α] (a b : α),
Neg.neg '' Set.uIcc a b = Set.uIcc (-a) (-b) |
CategoryTheory.Limits.coconeOfConeUnop_ι | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ} (c : CategoryTheory.Limits.Cone F.unop),
(CategoryTheory.Limits.coconeOfConeUnop c).ι = CategoryTheory.NatTrans.removeUnop c.π |
System.Platform.numBits_pos._simp_1 | Init.System.Platform | (0 < System.Platform.numBits) = True |
CategoryTheory.Functor.mapDifferentialObject._proof_3 | Mathlib.CategoryTheory.DifferentialObject | ∀ {S : Type u_3} [inst : AddMonoidWithOne S] {C : Type u_2} [inst_1 : CategoryTheory.Category.{u_1, u_2} C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.HasShift C S] (D : Type u_5)
[inst_4 : CategoryTheory.Category.{u_4, u_5} D] [inst_5 : CategoryTheory.Limits.HasZeroMorphisms D]
[inst_6 : CategoryTheory.HasShift D S] (F : CategoryTheory.Functor C D)
(η : (CategoryTheory.shiftFunctor C 1).comp F ⟶ F.comp (CategoryTheory.shiftFunctor D 1))
(hF : ∀ (c c' : C), F.map 0 = 0) (X : CategoryTheory.DifferentialObject S C),
{ f := F.map (CategoryTheory.CategoryStruct.id X).f, comm := ⋯ } =
CategoryTheory.CategoryStruct.id
{ obj := F.obj X.obj, d := CategoryTheory.CategoryStruct.comp (F.map X.d) (η.app X.obj), d_squared := ⋯ } |
CategoryTheory.Limits.Cocone.fromStructuredArrow_map_hom | Mathlib.CategoryTheory.Limits.ConeCategory | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
(F : CategoryTheory.Functor J C) {X Y : CategoryTheory.StructuredArrow F (CategoryTheory.Functor.const J)}
(f : X ⟶ Y), ((CategoryTheory.Limits.Cocone.fromStructuredArrow F).map f).hom = f.right |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.saveState | Lean.Elab.StructInst | Lean.Elab.Term.StructInst.StructInstM✝ Lean.Elab.Term.StructInst.SavedState✝ |
_aux_Mathlib_Algebra_Group_Equiv_Defs___unexpand_AddEquiv_1 | Mathlib.Algebra.Group.Equiv.Defs | Lean.PrettyPrinter.Unexpander |
WithLp.prod_nndist_eq_of_L1 | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ {α : Type u_2} {β : Type u_3} [inst : SeminormedAddCommGroup α] [inst_1 : SeminormedAddCommGroup β]
(x y : WithLp 1 (α × β)), nndist x y = nndist x.fst y.fst + nndist x.snd y.snd |
CategoryTheory.Equivalence.powNat.match_1 | Mathlib.CategoryTheory.Equivalence | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → (Unit → motive 1) → ((n : ℕ) → motive n.succ.succ) → motive x |
_private.Lean.Elab.Tactic.Monotonicity.0.Lean.Meta.Monotonicity.initFn.match_1._@.Lean.Elab.Tactic.Monotonicity.1250514167._hygCtx._hyg.2 | Lean.Elab.Tactic.Monotonicity | (motive : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr → Sort u_1) →
(__discr : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr) →
((xs : Array Lean.Expr) → (fst : Array Lean.BinderInfo) → (targetTy : Lean.Expr) → motive (xs, fst, targetTy)) →
motive __discr |
Subsemigroup.unop_sInf | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {M : Type u_2} [inst : Mul M] (S : Set (Subsemigroup Mᵐᵒᵖ)), (sInf S).unop = sInf (Subsemigroup.op ⁻¹' S) |
AlgebraicGeometry.AffineSpace.isOpenMap_over | Mathlib.AlgebraicGeometry.AffineSpace | ∀ {n : Type v} (S : AlgebraicGeometry.Scheme), IsOpenMap ⇑(AlgebraicGeometry.AffineSpace n S ↘ S) |
_private.Mathlib.Combinatorics.Additive.PluenneckeRuzsa.0.Finset.mul_aux | Mathlib.Combinatorics.Additive.PluenneckeRuzsa | ∀ {G : Type u_1} [inst : DecidableEq G] [inst_1 : CommGroup G] {A B C : Finset G},
A.Nonempty →
A ⊆ B →
(∀ A' ∈ B.powerset.erase ∅, ↑(A * C).card / ↑A.card ≤ ↑(A' * C).card / ↑A'.card) →
∀ A' ⊆ A, (A * C).card * A'.card ≤ (A' * C).card * A.card |
CategoryTheory.Preadditive.instSemiringEnd._proof_9 | Mathlib.CategoryTheory.Preadditive.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} (n : ℕ) (x : CategoryTheory.End X),
Monoid.npow (n + 1) x = Monoid.npow n x * x |
Bundle.Trivialization.linearMapAt_symmₗ | Mathlib.Topology.VectorBundle.Basic | ∀ {R : Type u_1} {B : Type u_2} {F : Type u_3} {E : B → Type u_4} [inst : Semiring R] [inst_1 : TopologicalSpace F]
[inst_2 : TopologicalSpace B] [inst_3 : TopologicalSpace (Bundle.TotalSpace F E)] [inst_4 : AddCommMonoid F]
[inst_5 : Module R F] [inst_6 : (x : B) → AddCommMonoid (E x)] [inst_7 : (x : B) → Module R (E x)]
(e : Bundle.Trivialization F Bundle.TotalSpace.proj) [inst_8 : Bundle.Trivialization.IsLinear R e] {b : B},
b ∈ e.baseSet → ∀ (y : F), (Bundle.Trivialization.linearMapAt R e b) ((Bundle.Trivialization.symmₗ R e b) y) = y |
LieModuleHom.restrictLie._proof_1 | Mathlib.Algebra.Lie.Subalgebra | ∀ {R : Type u_2} {L : Type u_1} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] {M : Type u_4}
[inst_3 : AddCommGroup M] [inst_4 : LieRingModule L M] {N : Type u_3} [inst_5 : AddCommGroup N]
[inst_6 : LieRingModule L N] [inst_7 : Module R N] [inst_8 : Module R M] (f : M →ₗ⁅R,L⁆ N) (L' : LieSubalgebra R L)
(x : ↥L') (m : M), f ⁅↑x, m⁆ = ⁅↑x, f m⁆ |
CategoryTheory.linearYoneda._proof_2 | Mathlib.CategoryTheory.Linear.Yoneda | ∀ (R : Type u_3) [inst : Ring R] (C : Type u_1) [inst_1 : CategoryTheory.Category.{u_2, u_1} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] (X : C) (X_1 : Cᵒᵖ),
ModuleCat.ofHom (CategoryTheory.Linear.leftComp R X (CategoryTheory.CategoryStruct.id X_1).unop) =
CategoryTheory.CategoryStruct.id (ModuleCat.of R (Opposite.unop X_1 ⟶ X)) |
Finset.strongInduction_eq | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} {p : Finset α → Sort u_4} (H : (s : Finset α) → ((t : Finset α) → t ⊂ s → p t) → p s) (s : Finset α),
Finset.strongInduction H s = H s fun t x => Finset.strongInduction H t |
Std.Internal.IO.Async.Signal.sigtstp | Std.Internal.Async.Signal | Std.Internal.IO.Async.Signal |
_private.Std.Internal.Async.Select.0.Std.Internal.IO.Async.Selectable.one._proof_2 | Std.Internal.Async.Select | ∀ {α : Type} (selectable : Std.Internal.IO.Async.Selectable α), Nonempty (Except IO.Error selectable.β) |
_private.Lean.Meta.Tactic.TryThis.0.Lean.Meta.Tactic.TryThis.mkExactSuggestionSyntax | Lean.Meta.Tactic.TryThis | Lean.Expr → Bool → Lean.MetaM (Lean.TSyntax `tactic × Lean.MessageData) |
DirectedSystem | Mathlib.Order.DirectedInverseSystem | {ι : Type u_1} → [inst : Preorder ι] → (F : ι → Type u_4) → (⦃i j : ι⦄ → i ≤ j → F i → F j) → Prop |
AlgEquiv.toLinearEquiv_refl | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Algebra R A₁],
AlgEquiv.refl.toLinearEquiv = LinearEquiv.refl R A₁ |
CommAlgCat.tensorHom_hom | Mathlib.Algebra.Category.CommAlgCat.Monoidal | ∀ {R : Type u} [inst : CommRing R] {A B C D : CommAlgCat R} (f : A ⟶ C) (g : B ⟶ D),
CommAlgCat.Hom.hom (CategoryTheory.MonoidalCategoryStruct.tensorHom f g) =
Algebra.TensorProduct.map (CommAlgCat.Hom.hom f) (CommAlgCat.Hom.hom g) |
Lean.Elab.Structural.IndGroupInst.levels | Lean.Elab.PreDefinition.Structural.IndGroupInfo | Lean.Elab.Structural.IndGroupInst → List Lean.Level |
AlgebraicGeometry.instQuasiSeparatedOfMonoScheme | Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [CategoryTheory.Mono f], AlgebraicGeometry.QuasiSeparated f |
_private.Lean.Compiler.LCNF.SpecInfo.0.Lean.Compiler.LCNF.isNoSpecType | Lean.Compiler.LCNF.SpecInfo | Lean.Environment → Lean.Expr → Bool |
Lean.Parser.ParserContext.suppressInsideQuot._inherited_default | Lean.Parser.Types | Bool |
EuclideanSpace.nndist_eq | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {𝕜 : Type u_7} [inst : RCLike 𝕜] {n : Type u_8} [inst_1 : Fintype n] (x y : EuclideanSpace 𝕜 n),
nndist x y = NNReal.sqrt (∑ i, nndist (x.ofLp i) (y.ofLp i) ^ 2) |
CategoryTheory.Grp.mk | Mathlib.CategoryTheory.Monoidal.Grp_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
(X : C) → [grp : CategoryTheory.GrpObj X] → CategoryTheory.Grp C |
Finset.emultiplicity_prod | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [IsCancelMulZero α] {β : Type u_3} {p : α},
Prime p → ∀ (s : Finset β) (f : β → α), emultiplicity p (∏ x ∈ s, f x) = ∑ x ∈ s, emultiplicity p (f x) |
Lean.Linter.MissingDocs.handleMutual | Lean.Linter.MissingDocs | Lean.Linter.MissingDocs.Handler |
RCLike.conjAe_coe | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], ⇑RCLike.conjAe = ⇑(starRingEnd K) |
LinearEquiv.ofEq.congr_simp | Mathlib.LinearAlgebra.Basis.Submodule | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M}
(p q : Submodule R M) (h : p = q), LinearEquiv.ofEq p q h = LinearEquiv.ofEq p q h |
RCLike.im_eq_zero | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], RCLike.I = 0 → ∀ (z : K), RCLike.im z = 0 |
CategoryTheory.Limits.BinaryBicone.isBilimitOfCokernelFst._proof_1 | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
(b : CategoryTheory.Limits.BinaryBicone X Y) {T : C} (f : X ⟶ T) (g : Y ⟶ T),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.BinaryCofan.inl b.toCocone)
((fun {T} f g => CategoryTheory.CategoryStruct.comp b.fst f + CategoryTheory.CategoryStruct.comp b.snd g) f g) =
f |
_private.Mathlib.NumberTheory.FLT.Polynomial.0.Polynomial.flt_catalan_aux._simp_1_5 | Mathlib.NumberTheory.FLT.Polynomial | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Add M] [inst_1 : Add N] [inst_2 : FunLike F M N]
[AddHomClass F M N] (f : F) (x y : M), f x + f y = f (x + y) |
Std.Format.tag.sizeOf_spec | Init.Data.Format.Basic | ∀ (a : ℕ) (a_1 : Std.Format), sizeOf (Std.Format.tag a a_1) = 1 + sizeOf a + sizeOf a_1 |
Filter.EventuallyEq.nhdsNE_deriv | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f f₁ : 𝕜 → F} {x : 𝕜}, f₁ =ᶠ[nhdsWithin x {x}ᶜ] f → deriv f₁ =ᶠ[nhdsWithin x {x}ᶜ] deriv f |
List.le_nil._simp_1 | Init.Data.List.Lex | ∀ {α : Type u_1} [inst : LT α] {l : List α}, (l ≤ []) = (l = []) |
_private.Lean.Meta.RecursorInfo.0.Lean.Meta.getMotiveLevel._sparseCasesOn_1 | Lean.Meta.RecursorInfo | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((u : Lean.Level) → motive (Lean.Expr.sort u)) → (Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t |
_private.Aesop.Tree.Data.0.Aesop.GoalId.succ.match_1 | Aesop.Tree.Data | (motive : Aesop.GoalId → Sort u_1) → (x : Aesop.GoalId) → ((n : ℕ) → motive { toNat := n }) → motive x |
Std.HashMap.Equiv.getElem!_eq | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k : α} [inst : Inhabited β], m₁.Equiv m₂ → m₁[k]! = m₂[k]! |
BooleanSubalgebra.topEquiv._proof_1 | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_1} [inst : BooleanAlgebra α] {a b : ↥⊤},
(Equiv.Set.univ α) a ≤ (Equiv.Set.univ α) b ↔ (Equiv.Set.univ α) a ≤ (Equiv.Set.univ α) b |
Int.Linear.Poly.mul_minus_one_getConst_eq | Init.Data.Int.Linear | ∀ (p : Int.Linear.Poly), (p.mul (-1)).getConst = -p.getConst |
NumberField.InfinitePlace.one_le_of_lt_one | Mathlib.NumberTheory.NumberField.InfinitePlace.Basic | ∀ {K : Type u_1} [inst : Field K] [NumberField K] {w : NumberField.InfinitePlace K} {a : NumberField.RingOfIntegers K},
a ≠ 0 → (∀ ⦃z : NumberField.InfinitePlace K⦄, z ≠ w → z ↑a < 1) → 1 ≤ w ↑a |
CategoryTheory.Core.functorToCore._proof_4 | Mathlib.CategoryTheory.Core | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {G : Type u_4} [inst_1 : CategoryTheory.Groupoid G]
(F : CategoryTheory.Functor G C) {X Y : G} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.Groupoid.inv f)) (F.map f) =
CategoryTheory.CategoryStruct.id { of := F.obj Y }.of |
Lean.CollectMVars.State.mk._flat_ctor | Lean.Util.CollectMVars | Lean.ExprSet → Array Lean.MVarId → Lean.CollectMVars.State |
WType.toList._sunfold | Mathlib.Data.W.Constructions | (γ : Type u) → WType (WType.Listβ γ) → List γ |
Std.TreeMap.getEntryGE | Std.Data.TreeMap.AdditionalOperations | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} →
[Std.TransCmp cmp] → (t : Std.TreeMap α β cmp) → (k : α) → (∃ a ∈ t, (cmp a k).isGE = true) → α × β |
_private.Mathlib.Order.Defs.LinearOrder.0.min_eq_left._proof_1_1 | Mathlib.Order.Defs.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, a ≤ b → min a b = a |
Lean.Compiler.LCNF.JoinPointFinder.FindState.mk.noConfusion | Lean.Compiler.LCNF.JoinPoints | {P : Sort u} →
{candidates candidates' : Std.HashMap Lean.FVarId Lean.Compiler.LCNF.JoinPointFinder.CandidateInfo} →
{ candidates := candidates } = { candidates := candidates' } → (candidates = candidates' → P) → P |
CategoryTheory.Quotient.linear._proof_2 | Mathlib.CategoryTheory.Quotient.Linear | ∀ (R : Type u_3) {C : Type u_2} [inst : Semiring R] [inst_1 : CategoryTheory.Category.{u_1, u_2} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] (r : HomRel C)
[inst_4 : CategoryTheory.Congruence r] (hr : ∀ (a : R) ⦃X Y : C⦄ (f₁ f₂ : X ⟶ Y), r f₁ f₂ → r (a • f₁) (a • f₂))
[inst_5 : CategoryTheory.Preadditive (CategoryTheory.Quotient r)]
[inst_6 : (CategoryTheory.Quotient.functor r).Additive] (X Y Z : CategoryTheory.Quotient r) (f : X ⟶ Y) (r_1 : R)
(g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp f (r_1 • g) = r_1 • CategoryTheory.CategoryStruct.comp f g |
Std.Tactic.BVDecide.BVExpr.Cache.insert.match_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | {aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit} →
(motive : Std.Tactic.BVDecide.BVExpr.Cache aig → Sort u_1) →
(cache : Std.Tactic.BVDecide.BVExpr.Cache aig) →
((map : Std.DHashMap Std.Tactic.BVDecide.BVExpr.Cache.Key fun k => Vector Std.Sat.AIG.Fanin k.w) →
(hbound :
∀ {i : ℕ} (k : Std.Tactic.BVDecide.BVExpr.Cache.Key) (h1 : k ∈ map) (h2 : i < k.w),
(map.get k h1)[i].gate < aig.decls.size) →
motive { map := map, hbound := hbound }) →
motive cache |
_private.Mathlib.Tactic.CasesM.0.Mathlib.Tactic.matchPatterns.match_1 | Mathlib.Tactic.CasesM | (motive : Option (Lean.Expr × Array Lean.Expr) → Sort u_1) →
(__do_lift : Option (Lean.Expr × Array Lean.Expr)) →
((fst : Lean.Expr) → motive (some (fst, #[]))) →
((x : Option (Lean.Expr × Array Lean.Expr)) → motive x) → motive __do_lift |
_private.Lean.Linter.UnusedVariables.0.Lean.Linter.initFn._@.Lean.Linter.UnusedVariables.727354328._hygCtx._hyg.2 | Lean.Linter.UnusedVariables | IO Unit |
Submodule.quotientEquivDirectSum._proof_3 | Mathlib.LinearAlgebra.FreeModule.Finite.Quotient | ∀ {ι : Type u_2} {R : Type u_3} {M : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : IsDomain R] [inst_4 : IsPrincipalIdealRing R] [inst_5 : Finite ι] (F : Type u_4) [inst_6 : CommRing F]
[inst_7 : Algebra F R] [inst_8 : Module F M] [inst_9 : IsScalarTower F R M] (b : Module.Basis ι R M)
{N : Submodule R M} (h : Module.finrank R ↥N = Module.finrank R M),
LinearMap.CompatibleSMul (M ⧸ N) ((i : ι) → R ⧸ Ideal.span {Submodule.smithNormalFormCoeffs b h i}) F R |
ContinuousMap.equivFnOfDiscrete_symm_apply | Mathlib.Topology.ContinuousMap.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : DiscreteTopology α]
(f : α → β), ⇑(ContinuousMap.equivFnOfDiscrete.symm f) = f |
Lean.Meta.Sym.Simp.instOrElseSimproc | Lean.Meta.Sym.Simp.Simproc | OrElse Lean.Meta.Sym.Simp.Simproc |
bot_lt_isotypicComponent | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (S : Submodule R M)
[IsSimpleModule R ↥S], ⊥ < isotypicComponent R M ↥S |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_inter._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) |
_private.Mathlib.Analysis.Calculus.UniformLimitsDeriv.0.hasFDerivAt_of_tendstoLocallyUniformlyOn._simp_1_2 | Mathlib.Analysis.Calculus.UniformLimitsDeriv | ∀ {α : Type u_1} {f : Filter α}, (Set.univ ∈ f) = True |
Int.emod_minus_one | Init.Data.Int.DivMod.Lemmas | ∀ (a : ℤ), a % -1 = 0 |
CategoryTheory.StructuredArrow.mapIso | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{S S' : D} →
{T : CategoryTheory.Functor C D} →
(S ≅ S') → (CategoryTheory.StructuredArrow S T ≌ CategoryTheory.StructuredArrow S' T) |
starL.congr_simp | Mathlib.Analysis.Calculus.FDeriv.Star | ∀ (R : Type u_1) {A : Type u_2} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : AddCommMonoid A]
[inst_3 : StarAddMonoid A] [inst_4 : Module R A] [inst_5 : StarModule R A] [inst_6 : TopologicalSpace A]
[inst_7 : ContinuousStar A], starL R = starL R |
npow_one | Mathlib.Algebra.Group.NatPowAssoc | ∀ {M : Type u_1} [inst : MulOneClass M] [inst_1 : Pow M ℕ] [NatPowAssoc M] (x : M), x ^ 1 = x |
_private.Lean.Elab.Tactic.Conv.Simp.0.Lean.Elab.Tactic.Conv.evalSimp.match_1 | Lean.Elab.Tactic.Conv.Simp | (motive : Lean.Meta.Simp.Result × Lean.Meta.Simp.Stats → Sort u_1) →
(__discr : Lean.Meta.Simp.Result × Lean.Meta.Simp.Stats) →
((result : Lean.Meta.Simp.Result) → (snd : Lean.Meta.Simp.Stats) → motive (result, snd)) → motive __discr |
_private.Mathlib.LinearAlgebra.Dimension.Finite.0.Module.exists_nontrivial_relation_sum_zero_of_finrank_succ_lt_card._simp_1_3 | Mathlib.LinearAlgebra.Dimension.Finite | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a + -b = 0) = (a = b) |
Equiv.Perm.IsSwap.congr_simp | Mathlib.GroupTheory.Perm.Sign | ∀ {α : Type u_1} {inst : DecidableEq α} [inst_1 : DecidableEq α] (f f_1 : Equiv.Perm α), f = f_1 → f.IsSwap = f_1.IsSwap |
_private.Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn.0.MeasureTheory.SignedMeasure.exists_subset_restrict_nonpos'._simp_1_2 | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn | ∀ {α : Type u} (x : α), (x ∈ ∅) = False |
Std.DHashMap.Raw.Const.getThenInsertIfNew? | Std.Data.DHashMap.Raw | {α : Type u} →
{β : Type v} →
[BEq α] → [Hashable α] → (Std.DHashMap.Raw α fun x => β) → α → β → Option β × Std.DHashMap.Raw α fun x => β |
Lean.Parser.Command.declVal.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer |
instLawfulCommIdentityInt64HOrOfNat | Init.Data.SInt.Bitwise | Std.LawfulCommIdentity (fun x1 x2 => x1 ||| x2) 0 |
StarAlgHom.prodEquiv._proof_1 | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_4} {A : Type u_1} {B : Type u_2} {C : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : Star A] [inst_4 : Semiring B] [inst_5 : Algebra R B] [inst_6 : Star B]
[inst_7 : Semiring C] [inst_8 : Algebra R C] [inst_9 : Star C],
Function.LeftInverse (fun f => ((StarAlgHom.fst R B C).comp f, (StarAlgHom.snd R B C).comp f)) fun f => f.1.prod f.2 |
ProofWidgets.RpcEncodablePacket.«_@».ProofWidgets.Data.Html.2686543190._hygCtx._hyg.1.ctorElimType | ProofWidgets.Data.Html | {motive : ProofWidgets.RpcEncodablePacket✝ → Sort u} → ℕ → Sort (max 1 u) |
InnerProductGeometry.norm_add_eq_add_norm_of_angle_eq_zero | Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x y : V},
InnerProductGeometry.angle x y = 0 → ‖x + y‖ = ‖x‖ + ‖y‖ |
Ordering.swap | Init.Data.Ord.Basic | Ordering → Ordering |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.updateAltImp | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.Alt pu →
Array (Lean.Compiler.LCNF.Param pu) → Lean.Compiler.LCNF.Code pu → Lean.Compiler.LCNF.Alt pu |
Std.DHashMap.Raw.insert | Std.Data.DHashMap.Raw | {α : Type u} → {β : α → Type v} → [BEq α] → [Hashable α] → Std.DHashMap.Raw α β → (a : α) → β a → Std.DHashMap.Raw α β |
Subsemigroup.map_injective_of_injective | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] {f : M →ₙ* N},
Function.Injective ⇑f → Function.Injective (Subsemigroup.map f) |
Std.Internal.IO.Async.System.UserId.mk._flat_ctor | Std.Internal.Async.System | ℕ → Std.Internal.IO.Async.System.UserId |
CategoryTheory.Limits.preservesLimitsOfSize_of_leftOp | Mathlib.CategoryTheory.Limits.Preserves.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C Dᵒᵖ) [CategoryTheory.Limits.PreservesColimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F.leftOp],
CategoryTheory.Limits.PreservesLimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F |
FirstOrder.Language.Term.substFunc._sunfold | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} →
{L' : FirstOrder.Language} → {α : Type u'} → L.Term α → ({n : ℕ} → L.Functions n → L'.Term (Fin n)) → L'.Term α |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.