name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
SeparationQuotient.instAddSemigroup.eq_1 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {M : Type u_1} [inst : TopologicalSpace M] [inst_1 : AddSemigroup M] [inst_2 : ContinuousAdd M],
SeparationQuotient.instAddSemigroup = Function.Surjective.addSemigroup SeparationQuotient.mk ⋯ ⋯ | true |
Flow.mk | Mathlib.Dynamics.Flow | {τ : Type u_1} →
[inst : TopologicalSpace τ] →
[inst_1 : AddMonoid τ] →
[inst_2 : ContinuousAdd τ] →
{α : Type u_2} →
[inst_3 : TopologicalSpace α] →
(toFun : τ → α → α) →
Continuous (Function.uncurry toFun) →
(∀ (t₁ t₂ : τ) (x : α), toFun (t₁ + t₂... | true |
BitVec.getMsbD_or | Init.Data.BitVec.Lemmas | ∀ {w i : ℕ} {x y : BitVec w}, (x ||| y).getMsbD i = (x.getMsbD i || y.getMsbD i) | true |
CategoryTheory.Limits.colimit.isoColimitCocone.eq_1 | Mathlib.CategoryTheory.Limits.Constructions.Filtered | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasColimit F]
(t : CategoryTheory.Limits.ColimitCocone F),
CategoryTheory.Limits.colimit.isoColimitCocone t =
(CategoryTheory.Li... | true |
Submodule.toLocalizedQuotient' | Mathlib.Algebra.Module.LocalizedModule.Submodule | {R : Type u_5} →
(S : Type u_6) →
{M : Type u_7} →
{N : Type u_8} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : AddCommGroup M] →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R M] →
[inst_5 : Module R N] →
... | true |
String.reduceNe._regBuiltin.String.reduceNe.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.String.731978007._hygCtx._hyg.24 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.String | IO Unit | false |
Quantale.noConfusion | Mathlib.Algebra.Order.Quantale | {P : Sort u} →
{α : Type u_1} →
{inst : Semigroup α} →
{inst_1 : CompleteLattice α} →
{inst_2 : IsQuantale α} →
{t : Quantale α} →
{α' : Type u_1} →
{inst' : Semigroup α'} →
{inst'_1 : CompleteLattice α'} →
{inst'_2 : IsQuantale α... | false |
MoritaEquivalence.mk.inj | Mathlib.RingTheory.Morita.Basic | ∀ {R : Type u₀} {inst : CommSemiring R} {A : Type u₁} {inst_1 : Ring A} {inst_2 : Algebra R A} {B : Type u₂}
{inst_3 : Ring B} {inst_4 : Algebra R B} {eqv : ModuleCat A ≌ ModuleCat B}
{linear : autoParam (CategoryTheory.Functor.Linear R eqv.functor) MoritaEquivalence.linear._autoParam}
{eqv_1 : ModuleCat A ≌ Modu... | true |
NNReal.natCast_iSup | Mathlib.Data.NNReal.Basic | ∀ {ι : Sort u_3} (f : ι → ℕ), ↑(⨆ i, f i) = ⨆ i, ↑(f i) | true |
_private.Lean.Meta.LazyDiscrTree.0.Lean.Meta.LazyDiscrTree.instBEqKey.beq._sparseCasesOn_3 | Lean.Meta.LazyDiscrTree | {motive : Lean.Meta.LazyDiscrTree.Key → Sort u} →
(t : Lean.Meta.LazyDiscrTree.Key) →
((a : Lean.Literal) → motive (Lean.Meta.LazyDiscrTree.Key.lit a)) →
(Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | false |
LieAlgebra.IsKilling.restr_invtSubmoduleToLieIdeal_eq_iSup | Mathlib.Algebra.Lie.Weights.IsSimple | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : CharZero K] [inst_2 : LieRing L] [inst_3 : LieAlgebra K L]
[inst_4 : FiniteDimensional K L] {H : LieSubalgebra K L} [inst_5 : H.IsCartanSubalgebra]
[inst_6 : LieAlgebra.IsKilling K L] [inst_7 : LieModule.IsTriangularizable K (↥H) L]
(q : Submodule K (Modu... | true |
Subgroup.mulSingle_mem_pi | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {η : Type u_7} {f : η → Type u_8} [inst : (i : η) → Group (f i)] [inst_1 : DecidableEq η] {I : Set η}
{H : (i : η) → Subgroup (f i)} (i : η) (x : f i), Pi.mulSingle i x ∈ Subgroup.pi I H ↔ i ∈ I → x ∈ H i | true |
_private.Mathlib.CategoryTheory.EssentialImage.0.CategoryTheory.Functor.essImage_comp_apply_of_essSurj.match_1_3 | Mathlib.CategoryTheory.EssentialImage | ∀ {C : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{u_1, u_3} C]
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {F : CategoryTheory.Functor C D} (Y : D)
(motive : F.essImage Y → Prop) (x : F.essImage Y), (∀ (Z : C) (e' : F.obj Z ≅ Y), motive ⋯) → motive x | false |
List.transpose.go.match_1 | Batteries.Data.List.Basic | {α : Type u_1} →
(motive : Id (Array (List α) × List α) → Sort u_2) →
(x : Id (Array (List α) × List α)) → ((acc : Array (List α)) → (l : List α) → motive (acc, l)) → motive x | false |
Lean.Meta.Instances._sizeOf_1 | Lean.Meta.Instances | Lean.Meta.Instances → ℕ | false |
Rep.FiniteCyclicGroup.chainComplexFunctor_map_f | Mathlib.RepresentationTheory.Homological.FiniteCyclic | ∀ (k : Type u) {G : Type u} [inst : CommRing k] [inst_1 : CommGroup G] [inst_2 : Fintype G] (g : G)
{X Y : Rep.{u_1, u, u} k G} (f : X ⟶ Y) (i : ℕ), ((Rep.FiniteCyclicGroup.chainComplexFunctor k g).map f).f i = f | true |
CategoryTheory.Monoidal.leftRigidFunctorCategory | Mathlib.CategoryTheory.Monoidal.Rigid.FunctorCategory | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Groupoid C] →
[inst_1 : CategoryTheory.Category.{v_1, u_2} D] →
[inst_2 : CategoryTheory.MonoidalCategory D] →
[CategoryTheory.LeftRigidCategory D] → CategoryTheory.LeftRigidCategory (CategoryTheory.Functor C D) | true |
Submodule.orthogonal_orthogonal | Mathlib.Analysis.InnerProductSpace.Projection.Submodule | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K : Submodule 𝕜 E) [K.HasOrthogonalProjection], Kᗮᗮ = K | true |
instReprAtomBool | Init.Data.Repr | ReprAtom Bool | true |
AddMonoidAlgebra.exists_supDegree_mem_support | Mathlib.Algebra.MonoidAlgebra.Degree | ∀ {R : Type u_1} {A : Type u_3} {B : Type u_5} [inst : Semiring R] [inst_1 : LinearOrder B] [inst_2 : OrderBot B]
{p : AddMonoidAlgebra R A} (D : A → B), p ≠ 0 → ∃ a ∈ p.support, AddMonoidAlgebra.supDegree D p = D a | true |
_private.Lean.Elab.DocString.0.Lean.Doc.elabBlocks'.match_5 | Lean.Elab.DocString | (motive :
Option
(Array (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock) ×
Array (Lean.Doc.Part Lean.ElabInline Lean.ElabBlock Empty)) →
Sort u_1) →
(x :
Option
(Array (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock) ×
Array (Lean.Doc.Part Lean.ElabInline Lean.ElabBlo... | false |
Ideal.quotEquivPowQuotPowSucc._proof_2 | Mathlib.RingTheory.Ideal.IsPrincipalPowQuotient | ∀ {R : Type u_1} [inst : CommRing R], IsScalarTower R R R | false |
smooth_functions_tower | Mathlib.Geometry.Manifold.DerivationBundle | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H) (M : Type u_4)
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M],
IsScalarTower 𝕜 (ContMDiffMap I (mo... | true |
uniformContinuousOn_iff_restrict | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] [inst_1 : UniformSpace β] {f : α → β} {s : Set α},
UniformContinuousOn f s ↔ UniformContinuous (s.restrict f) | true |
Int.ediv_dvd_iff_dvd_mul._simp_1 | Init.Data.Int.DivMod.Lemmas | ∀ {a b c : ℤ}, b ∣ a → b ≠ 0 → (a / b ∣ c) = (a ∣ b * c) | false |
ContinuousMap.compStarAlgHom._proof_6 | Mathlib.Topology.ContinuousMap.Star | ∀ (X : Type u_1) {𝕜 : Type u_4} {A : Type u_2} {B : Type u_3} [inst : TopologicalSpace X] [inst_1 : CommSemiring 𝕜]
[inst_2 : TopologicalSpace A] [inst_3 : Semiring A] [inst_4 : Star A] [inst_5 : ContinuousStar A]
[inst_6 : Algebra 𝕜 A] [inst_7 : TopologicalSpace B] [inst_8 : Semiring B] [inst_9 : Star B]
[ins... | false |
AugmentedSimplexCategory.inr_comp_associator_assoc | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | ∀ (x y z : AugmentedSimplexCategory) {Z : AugmentedSimplexCategory}
(h : CategoryTheory.MonoidalCategoryStruct.tensorObj x (CategoryTheory.MonoidalCategoryStruct.tensorObj y z) ⟶ Z),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.MonoidalCategoryStruct.tensorObj x y).inr z)
(CategoryTheory.CategoryStruct... | true |
Lean.IndirectModUse.recOn | Lean.ExtraModUses | {motive : Lean.IndirectModUse → Sort u} →
(t : Lean.IndirectModUse) →
((kind : String) → (declName : Lean.Name) → motive { kind := kind, declName := declName }) → motive t | false |
CategoryTheory.effectiveEpiFamilyStructOfIsColimit._proof_1 | Mathlib.CategoryTheory.Sites.EffectiveEpimorphic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {B : C} {α : Type u_3} (X : α → C)
(π : (a : α) → X a ⟶ B) (obj : CategoryTheory.Over B) (hT : (CategoryTheory.Sieve.generateFamily X π).arrows obj.hom),
∃ g, CategoryTheory.CategoryStruct.comp g (π (Exists.choose hT)) = obj.hom | false |
Bool.instDecidableLe | Init.Data.Bool | (x y : Bool) → Decidable (x ≤ y) | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.Cache._sizeOf_1 | Std.Sat.AIG.CNF | {aig : Std.Sat.AIG ℕ} → {cnf : Std.Sat.CNF ℕ} → Std.Sat.AIG.toCNF.Cache✝ aig cnf → ℕ | false |
PredOrder.prelimitRecOn._proof_2 | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : PredOrder α] (a : α),
¬Order.IsPredPrelimit a → ∃ b, ¬IsMin b ∧ Order.pred b = a | false |
Lean.Doc.Syntax.footnote_ref | Lean.DocString.Syntax | Lean.ParserDescr | true |
Batteries.Tactic.tacticSplit_ands | Batteries.Tactic.Init | Lean.ParserDescr | true |
_private.Batteries.Data.UnionFind.Lemmas.0.Batteries.UnionFind.equiv_union._simp_1_4 | Batteries.Data.UnionFind.Lemmas | ∀ {a b : ℕ} {self : Batteries.UnionFind} {x : Fin self.size}, (self.find x).fst.Equiv a b = self.Equiv a b | false |
Lean.Meta.Grind.Goal.ppENodeRef | Lean.Meta.Tactic.Grind.PP | Lean.Meta.Grind.Goal → Lean.Expr → Lean.MetaM Lean.MessageData | true |
_private.Mathlib.Analysis.Meromorphic.Divisor.0.MeromorphicOn.divisor._simp_13 | Mathlib.Analysis.Meromorphic.Divisor | ∀ {α : Sort u_1} {p q : α → Prop} {a' : α}, (∃ a, p a ∧ q a ∧ a = a') = (p a' ∧ q a') | false |
_private.Mathlib.Util.PrintSorries.0.Mathlib.PrintSorries.collect._sparseCasesOn_1 | Mathlib.Util.PrintSorries | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
CategoryTheory.ComposableArrows.ext | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {n : ℕ} {F G : CategoryTheory.ComposableArrows C n}
(h : ∀ (i : Fin (n + 1)), F.obj i = G.obj i),
(∀ (i : ℕ) (hi : i < n),
F.map' i (i + 1) ⋯ hi =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
(CategoryTheory.Cate... | true |
Subgroup.normalizer_eq_top | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) [h : H.Normal], Subgroup.normalizer ↑H = ⊤ | true |
CategoryTheory.Sheaf.instMonoidalFunctorOppositePresheafToSheaf._proof_19 | Mathlib.CategoryTheory.Sites.Monoidal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] (J : CategoryTheory.GrothendieckTopology C)
(A : Type u_3) [inst_1 : CategoryTheory.Category.{u_2, u_3} A] [inst_2 : CategoryTheory.MonoidalCategory A]
[inst_3 : J.W.IsMonoidal] [inst_4 : CategoryTheory.HasWeakSheafify J A],
autoParam
(CategoryThe... | false |
circleMap_zero_zpow | Mathlib.Analysis.SpecialFunctions.Complex.CircleMap | ∀ (n : ℤ) (R θ : ℝ), circleMap 0 R θ ^ n = circleMap 0 (R ^ n) (↑n * θ) | true |
Lean.Grind.Linarith.Expr.intMul | Init.Grind.Ordered.Linarith | ℤ → Lean.Grind.Linarith.Expr → Lean.Grind.Linarith.Expr | true |
_private.Lean.Meta.Sym.Simp.Forall.0.Lean.Meta.Sym.Simp.ArrowInfo.casesOn | Lean.Meta.Sym.Simp.Forall | {motive : Lean.Meta.Sym.Simp.ArrowInfo✝ → Sort u} →
(t : Lean.Meta.Sym.Simp.ArrowInfo✝¹) →
((binderName : Lean.Name) →
(binderInfo : Lean.BinderInfo) →
(u v : Lean.Level) → motive { binderName := binderName, binderInfo := binderInfo, u := u, v := v }) →
motive t | false |
_private.Init.Data.String.Lemmas.IsEmpty.0.String.Slice.startPos_eq_endPos_iff._simp_1_1 | Init.Data.String.Lemmas.IsEmpty | ∀ {s : String.Slice} {x y : s.Pos}, (x = y) = (x.offset = y.offset) | false |
Equiv.piUnique | Mathlib.Logic.Equiv.Defs | {α : Sort u} → [inst : Unique α] → (β : α → Sort u_1) → ((i : α) → β i) ≃ β default | true |
_private.Mathlib.CategoryTheory.Triangulated.Orthogonal.0.CategoryTheory.ObjectProperty.isLocal_trW.match_1_1 | Mathlib.CategoryTheory.Triangulated.Orthogonal | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (P : CategoryTheory.ObjectProperty C)
[inst_1 : CategoryTheory.Limits.HasZeroObject C] [inst_2 : CategoryTheory.HasShift C ℤ]
[inst_3 : CategoryTheory.Preadditive C] [inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive]
[inst_5 : CategoryTh... | false |
ENat.add_lt_add | Mathlib.Data.ENat.Basic | ∀ {a b c d : ℕ∞}, a < c → b < d → a + b < c + d | true |
EuclideanGeometry.Sphere._sizeOf_inst | Mathlib.Geometry.Euclidean.Sphere.Basic | (P : Type u_2) → {inst : MetricSpace P} → [SizeOf P] → SizeOf (EuclideanGeometry.Sphere P) | false |
Mathlib.Meta.NormNum.deriveBool | Mathlib.Tactic.NormNum.Core | (p : Q(Prop)) → Lean.MetaM ((b : Bool) × Mathlib.Meta.NormNum.BoolResult p b) | true |
Filter.zeroAtFilterSubmodule | Mathlib.Order.Filter.ZeroAndBoundedAtFilter | (𝕜 : Type u_1) →
{α : Type u_2} →
{β : Type u_3} →
[inst : TopologicalSpace β] →
[inst_1 : Semiring 𝕜] →
[inst_2 : AddCommMonoid β] →
[inst_3 : Module 𝕜 β] → [ContinuousAdd β] → [ContinuousConstSMul 𝕜 β] → Filter α → Submodule 𝕜 (α → β) | true |
Std.DTreeMap.Const.ofList_eq_insertMany_empty | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {l : List (α × β)},
Std.DTreeMap.Const.ofList l cmp = Std.DTreeMap.Const.insertMany ∅ l | true |
Lean.LocalInstance.casesOn | Lean.MetavarContext | {motive : Lean.LocalInstance → Sort u} →
(t : Lean.LocalInstance) →
((className : Lean.Name) → (fvar : Lean.Expr) → motive { className := className, fvar := fvar }) → motive t | false |
Lean.Parser.Command.declaration._regBuiltin.Lean.Parser.Command.computedField.formatter_117 | Lean.Parser.Command | IO Unit | false |
_private.Mathlib.SetTheory.Ordinal.CantorNormalForm.0.Ordinal.CNF.rec._proof_2 | Mathlib.SetTheory.Ordinal.CantorNormalForm | ∀ (o : Ordinal.{u_1}), o = 0 → 0 = o | false |
Relation.reflTransGen_of_equivalence | Mathlib.Logic.Relation | ∀ {α : Sort u_1} {r : α → α → Prop} {a b : α} {r' : α → α → Prop},
Equivalence r → (∀ (a b : α), r' a b → r a b) → Relation.ReflTransGen r' a b → r a b | true |
Lean.Meta.Grind.instInhabitedAction | Lean.Meta.Tactic.Grind.Types | Inhabited Lean.Meta.Grind.Action | true |
_private.Mathlib.Algebra.Polynomial.RingDivision.0.Polynomial.prime_X_sub_C._simp_1_2 | Mathlib.Algebra.Polynomial.RingDivision | ∀ {R : Type u} {a : R} [inst : Semiring R] {p : Polynomial R}, p.IsRoot a = (Polynomial.eval a p = 0) | false |
List.findSomeRev?.eq_def | Init.Data.List.Impl | ∀ {α : Type u} {β : Type v} (f : α → Option β) (x : List α),
List.findSomeRev? f x =
match x with
| [] => none
| a :: as =>
match List.findSomeRev? f as with
| some b => some b
| none => f a | true |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.toLCNF.visitMData | Lean.Compiler.LCNF.ToLCNF | Lean.MData → Lean.Expr → Lean.Compiler.LCNF.ToLCNF.M (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure) | true |
_private.Mathlib.Logic.Embedding.Set.0.Function.Embedding.sigmaSet_preimage._simp_1_1 | Mathlib.Logic.Embedding.Set | ∀ {α : Type u} {a b : Set α}, (a = b) = ∀ (x : α), x ∈ a ↔ x ∈ b | false |
Topology.CWComplex.Subcomplex.coe_mk'' | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] [inst : T2Space X] (C : Set X) [h : Topology.CWComplex C] (E : Set X)
(I : (n : ℕ) → Set (Topology.RelCWComplex.cell C n)) [inst_1 : Topology.CWComplex E]
(union : ⋃ n, ⋃ j, Topology.RelCWComplex.openCell n ↑j = E), ↑(Topology.CWComplex.Subcomplex.mk'' C E I union) = E | true |
_private.Mathlib.Analysis.Convex.Combination.0.AffineIndependent.convexHull_inter._simp_1_4 | Mathlib.Analysis.Convex.Combination | ∀ {ι : Type u_1} {M : Type u_4} {s : Finset ι} [inst : AddCommMonoid M] (p : ι → Prop) [inst_1 : DecidablePred p]
(f : ι → M), (∑ a ∈ s, if p a then f a else 0) = ∑ a ∈ s with p a, f a | false |
Lean.Meta.initFn._@.Lean.Meta.Coe.1863807188._hygCtx._hyg.2 | Lean.Meta.Coe | IO Lean.TagAttribute | false |
Lean.StructureResolutionState.casesOn | Lean.Structure | {motive : Lean.StructureResolutionState → Sort u} →
(t : Lean.StructureResolutionState) →
((resolutions : Lean.PHashMap Lean.Name (Array Lean.Name)) → motive { resolutions := resolutions }) → motive t | false |
WeierstrassCurve.variableChange_j | Mathlib.AlgebraicGeometry.EllipticCurve.VariableChange | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) (C : WeierstrassCurve.VariableChange R)
[inst_1 : W.IsElliptic], (C • W).j = W.j | true |
Lean.Options.ctorIdx | Lean.Data.Options | Lean.Options → ℕ | false |
Cardinal.lift_max | Mathlib.SetTheory.Cardinal.Order | ∀ {a b : Cardinal.{v}}, Cardinal.lift.{u, v} (max a b) = max (Cardinal.lift.{u, v} a) (Cardinal.lift.{u, v} b) | true |
CategoryTheory.presheafHom | Mathlib.CategoryTheory.Sites.SheafHom | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{A : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} A] →
CategoryTheory.Functor Cᵒᵖ A →
CategoryTheory.Functor Cᵒᵖ A → CategoryTheory.Functor Cᵒᵖ (Type (max (max u v) v')) | true |
QuaternionAlgebra.im_natCast | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} {c₁ c₂ c₃ : R} [inst : AddCommGroupWithOne R] (n : ℕ), (↑n).im = 0 | true |
Mathlib.Tactic.FinVec.vecPerm | Mathlib.Tactic.Simproc.VecPerm | Lean.Meta.Simp.Simproc | true |
Matroid.IsLoop.dep_of_mem._auto_1 | Mathlib.Combinatorics.Matroid.Loop | Lean.Syntax | false |
ModularForm.eisensteinSeriesMF._proof_2 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Basic | ∀ {k : ℤ} {N : ℕ} (a : Fin 2 → ZMod N),
∀ γ ∈ Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ) (CongruenceSubgroup.Gamma N),
SlashAction.map k γ (EisensteinSeries.eisensteinSeriesSIF a k).toFun =
(EisensteinSeries.eisensteinSeriesSIF a k).toFun | false |
SetLike.instSubtypeSet._proof_1 | Mathlib.Data.SetLike.Basic | ∀ {X : Type u_1} {p : Set X → Prop}, Function.Injective Subtype.val | false |
Lean.Order.Array.monotone_allM | Init.Internal.Order.Lemmas | ∀ {γ : Type w} [inst : Lean.Order.PartialOrder γ] {m : Type → Type v} [inst_1 : Monad m]
[inst_2 : (α : Type) → Lean.Order.PartialOrder (m α)] [Lean.Order.MonoBind m] {α : Type u} (f : γ → α → m Bool)
(xs : Array α) (start stop : ℕ), Lean.Order.monotone f → Lean.Order.monotone fun x => Array.allM (f x) xs start sto... | true |
SimpleGraph.CompleteEquipartiteSubgraph.ofCopy | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | {V : Type u_1} →
{G : SimpleGraph V} →
{r t : ℕ} → (SimpleGraph.completeEquipartiteGraph r t).Copy G → G.CompleteEquipartiteSubgraph r t | true |
_private.Mathlib.Topology.Algebra.InfiniteSum.Order.0.Mathlib.Meta.Positivity.evalTsum._proof_1 | Mathlib.Topology.Algebra.InfiniteSum.Order | ∀ {u : Lean.Level} {α : Q(Type u)} (zα : Q(Zero «$α»)) (mα' : Q(AddCommMonoid «$α»))
(__defeqres : PLift («$zα» =Q «$mα'».toAddZeroClass.toZero)), «$zα» =Q «$mα'».toAddZeroClass.toZero | false |
MulEquiv.toMagmaCatIso | Mathlib.Algebra.Category.Semigrp.Basic | {X Y : Type u} → [inst : Mul X] → [inst_1 : Mul Y] → X ≃* Y → (MagmaCat.of X ≅ MagmaCat.of Y) | true |
compl_ne_self._simp_1 | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : HeytingAlgebra α] {a : α} [Nontrivial α], (aᶜ = a) = False | false |
ValuativeRel.ValueGroupWithZero.lift_valuation | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] {α : Sort u_2}
(f : R → ↥(ValuativeRel.posSubmonoid R) → α)
(hf : ∀ (x y : R) (t s : ↥(ValuativeRel.posSubmonoid R)), x * ↑t ≤ᵥ y * ↑s → y * ↑s ≤ᵥ x * ↑t → f x s = f y t)
(x : R), ValuativeRel.ValueGroupWithZero.lift f hf ((ValuativeRel.valuation R) x... | true |
RingEquiv.toRingCatIso._proof_2 | Mathlib.Algebra.Category.Ring.Basic | ∀ {R S : Type u_1} [inst : Ring R] [inst_1 : Ring S] (e : R ≃+* S),
CategoryTheory.CategoryStruct.comp (RingCat.ofHom ↑e) (RingCat.ofHom ↑e.symm) =
CategoryTheory.CategoryStruct.id (RingCat.of R) | false |
Unitization.inl_zero | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_3} (A : Type u_4) [inst : Zero R] [inst_1 : Zero A], Unitization.inl 0 = 0 | true |
Std.IterStep.mapIterator | Init.Data.Iterators.Basic | {α : Type u} → {β : Type w} → {α' : Type u'} → (α → α') → Std.IterStep α β → Std.IterStep α' β | true |
List.takeWhile_append_dropWhile | Init.Data.List.TakeDrop | ∀ {α : Type u_1} {p : α → Bool} {l : List α}, List.takeWhile p l ++ List.dropWhile p l = l | true |
CategoryTheory.WideSubcategory | Mathlib.CategoryTheory.Widesubcategory | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(_P : CategoryTheory.MorphismProperty C) → [_P.IsMultiplicative] → Type u₁ | true |
_private.Batteries.Data.MLList.Basic.0.MLList.uncons?Impl.match_1 | Batteries.Data.MLList.Basic | {m : Type u_1 → Type u_1} →
{α : Type u_1} →
(motive : MLList.MLListImpl✝ m α → Sort u_2) →
(x : MLList.MLListImpl✝¹ m α) →
(Unit → motive MLList.MLListImpl.nil✝) →
((x : α) → (xs : MLList.MLListImpl✝² m α) → motive (MLList.MLListImpl.cons✝ x xs)) →
((x : MLList.MLListImpl✝³ m ... | false |
Lean.Meta.Grind.ppPattern | Lean.Meta.Tactic.Grind.EMatchTheorem | Lean.Expr → Lean.MessageData | true |
Monoid.PushoutI.NormalWord.rcons.eq_1 | Mathlib.GroupTheory.PushoutI | ∀ {ι : Type u_1} {G : ι → Type u_2} {H : Type u_3} [inst : (i : ι) → Group (G i)] [inst_1 : Group H]
{φ : (i : ι) → H →* G i} {d : Monoid.PushoutI.NormalWord.Transversal φ} [inst_2 : DecidableEq ι]
[inst_3 : (i : ι) → DecidableEq (G i)] (i : ι) (p : Monoid.PushoutI.NormalWord.Pair d i),
Monoid.PushoutI.NormalWord... | true |
Submonoid.prod_mem | Mathlib.Algebra.Group.Submonoid.BigOperators | ∀ {M : Type u_4} [inst : CommMonoid M] (S : Submonoid M) {ι : Type u_5} {t : Finset ι} {f : ι → M},
(∀ c ∈ t, f c ∈ S) → ∏ c ∈ t, f c ∈ S | true |
Matrix.PosSemidef.diagonal | Mathlib.LinearAlgebra.Matrix.PosDef | ∀ {n : Type u_2} {R : Type u_3} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R]
[inst_4 : DecidableEq n] {d : n → R}, 0 ≤ d → (Matrix.diagonal d).PosSemidef | true |
List.map_reverse | Init.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l : List α}, List.map f l.reverse = (List.map f l).reverse | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.Balanced.map.match_1_1 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} {t₁ : Std.DTreeMap.Internal.Impl α β}
(motive : (t₂ : Std.DTreeMap.Internal.Impl α β) → t₁.Balanced → t₁ = t₂ → Prop) (t₂ : Std.DTreeMap.Internal.Impl α β)
(x : t₁.Balanced) (x_1 : t₁ = t₂), (∀ (h : t₁.Balanced), motive t₁ h ⋯) → motive t₂ x x_1 | false |
_private.Mathlib.AlgebraicGeometry.Morphisms.Finite.0.AlgebraicGeometry.IsFinite.instHasAffinePropertyAndIsAffineFiniteCarrierObjOppositeOpensCarrierCarrierCommRingCatPresheafOpOpensTopHomAppTop._simp_1 | Mathlib.AlgebraicGeometry.Morphisms.Finite | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y),
AlgebraicGeometry.IsFinite f =
(AlgebraicGeometry.IsAffineHom f ∧
∀ (U : Y.Opens),
AlgebraicGeometry.IsAffineOpen U → (CommRingCat.Hom.hom (AlgebraicGeometry.Scheme.Hom.app f U)).Finite) | false |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.evalAlts.goWithIncremental | Lean.Elab.Tactic.Induction | Lean.Meta.ElimInfo →
Array Lean.Elab.Tactic.ElimApp.Alt →
Lean.Syntax →
Option (Array Lean.Syntax) →
Lean.Syntax →
ℕ →
Array Lean.FVarId →
Array Lean.FVarId →
Array (Lean.Ident × Lean.FVarId) →
Array (Lean.Language.SnapshotBundle ... | true |
TopologicalSpace.Opens.coe_disjoint | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_2} [inst : TopologicalSpace α] {s t : TopologicalSpace.Opens α}, Disjoint ↑s ↑t ↔ Disjoint s t | true |
antitone_const | Mathlib.Order.Monotone.Defs | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {c : β}, Antitone fun x => c | true |
Polynomial.fiberEquivQuotient._proof_5 | Mathlib.RingTheory.LocalRing.ResidueField.Polynomial | ∀ {R : Type u_1} [inst : CommRing R] (p : Ideal R) [inst_1 : p.IsPrime], IsScalarTower R p.ResidueField p.ResidueField | false |
Finset.prod_flip | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {M : Type u_4} [inst : CommMonoid M] {n : ℕ} (f : ℕ → M),
∏ r ∈ Finset.range (n + 1), f (n - r) = ∏ k ∈ Finset.range (n + 1), f k | true |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.Nat.isSemilinearSet_of_isSlice._proof_1_5 | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {ι : Type u_1} (t : Finset ι) {s : Set (ι → ℕ)} (a : ι → ℕ),
(∀ x ∈ s, ∀ i ∉ t, x i = a i) →
∀ x ∈ s,
∀ (y : ι → ℕ),
y ∈ s ↔ (y ∈ s ∧ ∀ (i : ι), x i ≤ y i) ∨ ∃ i, ∃ (_ : i ∈ t), ∃ i_1, ∃ (_ : i_1 < x i), y ∈ s ∧ y i = i_1 | false |
CategoryTheory.Functor.shiftMap.eq_1 | Mathlib.CategoryTheory.Shift.ShiftSequence | ∀ {C : Type u_1} {A : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} A] (F : CategoryTheory.Functor C A) {M : Type u_3} [inst_2 : AddMonoid M]
[inst_3 : CategoryTheory.HasShift C M] [inst_4 : F.ShiftSequence M] {X Y : C} {n : M}
(f : X ⟶ (CategoryTheory.shiftF... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.