name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Grind.CutsatConfig.maxSuggestions._inherited_default | Init.Grind.Config | Option ℕ | false |
Submodule.botEquivPUnit_apply | Mathlib.Algebra.Module.Submodule.Lattice | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (x : ↥⊥),
Submodule.botEquivPUnit x = PUnit.unit | true |
WeakFEPair.noConfusion | Mathlib.NumberTheory.LSeries.AbstractFuncEq | {P : Sort u} →
{E : Type u_1} →
{inst : NormedAddCommGroup E} →
{inst_1 : NormedSpace ℂ E} →
{t : WeakFEPair E} →
{E' : Type u_1} →
{inst' : NormedAddCommGroup E'} →
{inst'_1 : NormedSpace ℂ E'} →
{t' : WeakFEPair E'} →
E = E' → i... | false |
Subalgebra.instCommRingSubtypeMemCenter._proof_14 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_2} [inst : CommSemiring R] {A : Type u_1} [inst_1 : Ring A] [inst_2 : Algebra R A],
autoParam (∀ (n : ℕ), IntCast.intCast ↑n = ↑n) AddGroupWithOne.intCast_ofNat._autoParam | false |
OrderAddMonoidIso.map_le_map_iff' | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_6} {β : Type u_7} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Add α] [inst_3 : Add β]
(self : α ≃+o β) {a b : α}, self.toFun a ≤ self.toFun b ↔ a ≤ b | true |
Subgroup.ofUnits_bot | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : Monoid M], ⊥.ofUnits = ⊥ | true |
Ordinal.uniqueToTypeOne._proof_3 | Mathlib.SetTheory.Ordinal.Basic | ∀ (a : Ordinal.ToType 1), a = (Ordinal.enum fun x1 x2 => x1 < x2) ⟨0, Ordinal.uniqueToTypeOne._proof_2⟩ | false |
Std.Time.Month.Ordinal.ofNat | Std.Time.Date.Unit.Month | (data : ℕ) → autoParam (data ≥ 1 ∧ data ≤ 12) Std.Time.Month.Ordinal.ofNat._auto_1 → Std.Time.Month.Ordinal | true |
CauSeq.coe_inf._simp_1 | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] (f g : CauSeq α abs),
↑f ⊓ ↑g = ↑(f ⊓ g) | false |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.Code.explicitRc.match_3 | Lean.Compiler.LCNF.ExplicitRC | (motive : Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.impure → Sort u_1) →
(alt : Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.impure) →
((c : Lean.Compiler.LCNF.CtorInfo) →
(k : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.Alt.ctorAlt c k ⋯)) →... | false |
_private.Batteries.Data.Array.Lemmas.0.Array.extract_append_of_stop_le_size_left._proof_1_6 | Batteries.Data.Array.Lemmas | ∀ {α : Type u_1} {j i : ℕ} {a b : Array α},
j ≤ a.size →
-1 * ↑i + ↑a.size ≤ 0 →
¬-1 * ↑j + ↑a.size ≤ 0 →
((a ++ b).extract i j).size = (a.extract i j).size →
∀ (w : ℕ), w + 1 ≤ ((a ++ b).extract i j).size → w < (a.extract i j).size | false |
Fin.rec0 | Mathlib.Data.Fin.Basic | {α : Fin 0 → Sort u_1} → (i : Fin 0) → α i | true |
Lean.Server.instInhabitedRequestError.default | Lean.Server.Requests | Lean.Server.RequestError | true |
AlgebraicGeometry.IsZariskiLocalAtSource.of_iSup_eq_top | Mathlib.AlgebraicGeometry.Morphisms.Basic | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [AlgebraicGeometry.IsZariskiLocalAtSource P]
{X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} {ι : Sort u_1} (U : ι → X.Opens),
iSup U = ⊤ → (∀ (i : ι), P (CategoryTheory.CategoryStruct.comp (U i).ι f)) → P f | true |
Lean.Elab.Tactic.evalWithReducibleAndInstances._regBuiltin.Lean.Elab.Tactic.evalWithReducibleAndInstances_1 | Lean.Elab.Tactic.ElabTerm | IO Unit | false |
IsMulCentral.left_assoc | Mathlib.Algebra.Group.Center | ∀ {M : Type u_1} [inst : Mul M] {z : M}, IsMulCentral z → ∀ (b c : M), z * (b * c) = z * b * c | true |
Finpartition.parts_subset_extendOfLE | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : GeneralizedBooleanAlgebra α] [inst_1 : DecidableEq α] {a b : α} (P : Finpartition a)
(hab : a ≤ b), P.parts ⊆ (P.extendOfLE hab).parts | true |
QuaternionAlgebra.imIₗ | Mathlib.Algebra.Quaternion | {R : Type u_3} → (c₁ c₂ c₃ : R) → [inst : CommRing R] → QuaternionAlgebra R c₁ c₂ c₃ →ₗ[R] R | true |
RestrictedProduct.instT2Space | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {ι : Type u_1} {R : ι → Type u_2} {A : (i : ι) → Set (R i)} {𝓕 : Filter ι} [inst : (i : ι) → TopologicalSpace (R i)]
[∀ (i : ι), T2Space (R i)], T2Space (RestrictedProduct (fun i => R i) (fun i => A i) 𝓕) | true |
_private.Mathlib.RingTheory.AdicCompletion.Completeness.0.AdicCompletion.pow_smul_top_eq_ker_eval._simp_1_1 | Mathlib.RingTheory.AdicCompletion.Completeness | ∀ {R₁ : Type u_2} {R₂ : Type u_3} {R₃ : Type u_4} {M₁ : Type u_9} {M₂ : Type u_10} {M₃ : Type u_11} [inst : Semiring R₁]
[inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M₁] [inst_4 : AddCommMonoid M₂]
[inst_5 : AddCommMonoid M₃] {module_M₁ : Module R₁ M₁} {module_M₂ : Module R₂ M₂} {module_M₃ ... | false |
Nat.Partrec.Code.rfind'.noConfusion | Mathlib.Computability.PartrecCode | {P : Sort u} → {a a' : Nat.Partrec.Code} → a.rfind' = a'.rfind' → (a = a' → P) → P | false |
_private.Mathlib.Combinatorics.SetFamily.AhlswedeZhang.0.AhlswedeZhang.supSum_singleton._simp_1_1 | Mathlib.Combinatorics.SetFamily.AhlswedeZhang | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ≤ s₂) = (s₁ ⊆ s₂) | false |
UInt64.lt_iff_toBitVec_lt | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, a < b ↔ a.toBitVec < b.toBitVec | true |
Lean.Meta.DefEqCacheKey | Lean.Meta.Basic | Type | true |
Ordinal.nhds_eq_pure | Mathlib.SetTheory.Ordinal.Topology | ∀ {a : Ordinal.{u}}, nhds a = pure a ↔ ¬Order.IsSuccLimit a | true |
IsWeakLowerModularLattice.casesOn | Mathlib.Order.ModularLattice | {α : Type u_2} →
[inst : Lattice α] →
{motive : IsWeakLowerModularLattice α → Sort u} →
(t : IsWeakLowerModularLattice α) →
((inf_covBy_of_covBy_covBy_sup : ∀ {a b : α}, a ⋖ a ⊔ b → b ⋖ a ⊔ b → a ⊓ b ⋖ a) → motive ⋯) → motive t | false |
_private.Lean.Elab.Structure.0.Lean.Elab.Command.Structure.replaceFieldInfo | Lean.Elab.Structure | Lean.Elab.Command.Structure.StructFieldInfo → Lean.Elab.Command.Structure.StructElabM✝ Unit | true |
Module.Finite.kerRepr | Mathlib.RingTheory.Finiteness.Cardinality | (R : Type u) →
(M : Type u_1) →
[inst : Ring R] →
[inst_1 : AddCommGroup M] → [inst_2 : Module R M] → [inst_3 : Module.Finite R M] → Submodule R (Fin ⋯.choose → R) | true |
TwoP.largeCategory._aux_3 | Mathlib.CategoryTheory.Category.TwoP | (X : TwoP) → X ⟶ X | false |
_private.Lean.Meta.Tactic.Simp.Main.0.Lean.Meta.Simp.reduceProjFn?.match_5 | Lean.Meta.Tactic.Simp.Main | (motive : Option Lean.ProjectionFunctionInfo → Sort u_1) →
(__do_lift : Option Lean.ProjectionFunctionInfo) →
(Unit → motive none) → ((projInfo : Lean.ProjectionFunctionInfo) → motive (some projInfo)) → motive __do_lift | false |
Lean.Lsp.LeanImport.ctorIdx | Lean.Data.Lsp.Extra | Lean.Lsp.LeanImport → ℕ | false |
ComplexShape.Embedding.truncLE'Functor._proof_1 | Mathlib.Algebra.Homology.Embedding.TruncLE | ∀ {ι' : Type u_3} {c' : ComplexShape ι'} (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.CategoryWithHomology C]
(K : HomologicalComplex C c') (i' : ι'), (K.sc i').HasHomology | false |
AlgebraicGeometry.Scheme.IdealSheafData.ofIdealTop._proof_7 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} (I : Ideal ↑(X.presheaf.obj (Opposite.op ⊤))) (U : ↑X.affineOpens),
∀ x ∈ ↑U,
x ∈ X.zeroLocus ↑I ↔
x ∈ X.zeroLocus ↑((fun U => Ideal.map (CommRingCat.Hom.hom (X.presheaf.map (CategoryTheory.homOfLE ⋯).op)) I) U) | false |
_private.Init.Data.Int.Order.0.Int.ofNat_le.match_1_1 | Init.Data.Int.Order | ∀ {m n : ℕ} (motive : (∃ n_1, ↑m + ↑n_1 = ↑n) → Prop) (x : ∃ n_1, ↑m + ↑n_1 = ↑n),
(∀ (k : ℕ) (hk : ↑m + ↑k = ↑n), motive ⋯) → motive x | false |
CategoryTheory.HasLiftingProperty.transfiniteComposition.SqStruct.map_f' | Mathlib.CategoryTheory.SmallObject.TransfiniteCompositionLifting | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type w} [inst_1 : LinearOrder J] [inst_2 : OrderBot J]
{F : CategoryTheory.Functor J C} {c : CategoryTheory.Limits.Cocone F} {X Y : C} {p : X ⟶ Y} {f : F.obj ⊥ ⟶ X}
{g : c.pt ⟶ Y} {j : J} (sq' : CategoryTheory.HasLiftingProperty.transfiniteComposition.Sq... | true |
pow_le_pow_right' | Mathlib.Algebra.Order.Monoid.Unbundled.Pow | ∀ {M : Type u_3} [inst : Monoid M] [inst_1 : Preorder M] [MulLeftMono M] {a : M} {n m : ℕ},
1 ≤ a → n ≤ m → a ^ n ≤ a ^ m | true |
_private.Mathlib.Order.Filter.Bases.Basic.0.Filter.HasBasis.forall_iff.match_1_1 | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_2} {ι : Sort u_1} {p : ι → Prop} {s : ι → Set α} (_s : Set α) (motive : (∃ i, p i ∧ s i ⊆ _s) → Prop)
(x : ∃ i, p i ∧ s i ⊆ _s), (∀ (i : ι) (hi : p i) (his : s i ⊆ _s), motive ⋯) → motive x | false |
Set.Ici.isAtom_iff | Mathlib.Order.Atoms | ∀ {α : Type u_2} [inst : PartialOrder α] {a : α} {b : ↑(Set.Ici a)}, IsAtom b ↔ a ⋖ ↑b | true |
CategoryTheory.Functor.homEquivOfIsRightKanExtension._proof_3 | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_3} {H : Type u_4} {D : Type u_1} [inst : CategoryTheory.Category.{u_6, u_3} C]
[inst_1 : CategoryTheory.Category.{u_2, u_4} H] [inst_2 : CategoryTheory.Category.{u_5, u_1} D]
(F' : CategoryTheory.Functor D H) {L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H}
(α : L.comp F' ⟶ F) [inst... | false |
_private.Mathlib.Tactic.Linarith.NNRealPreprocessor.0.Mathlib.Tactic.Linarith.isNNRealtoReal.match_1 | Mathlib.Tactic.Linarith.NNRealPreprocessor | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((us : List Lean.Level) → (n : Lean.Expr) → motive ((Lean.Expr.const `NNReal.toReal us).app n)) →
((x : Lean.Expr) → motive x) → motive e | false |
mulRightLinearMap_apply | Mathlib.Data.Matrix.Bilinear | ∀ (l : Type u_1) {m : Type u_2} {n : Type u_3} (R : Type u_5) {A : Type u_6} [inst : Fintype m] [inst_1 : Semiring R]
[inst_2 : NonUnitalNonAssocSemiring A] [inst_3 : Module R A] [inst_4 : IsScalarTower R A A] (Y : Matrix m n A)
(x : Matrix l m A), (mulRightLinearMap l R Y) x = x * Y | true |
CategoryTheory.CostructuredArrow.toStructuredArrow_obj | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) (d : D) (X : (CategoryTheory.CostructuredArrow F d)ᵒᵖ),
(CategoryTheory.CostructuredArrow.toStructuredArrow F d).obj X =
CategoryTheory.StructuredArrow.mk (Opp... | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Reflexive.0.CategoryTheory.Limits.WalkingParallelPair.inclusionWalkingReflexivePair.match_1.splitter | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | (motive : CategoryTheory.Limits.WalkingParallelPair → Sort u_1) →
(x : CategoryTheory.Limits.WalkingParallelPair) →
(Unit → motive CategoryTheory.Limits.WalkingParallelPair.one) →
(Unit → motive CategoryTheory.Limits.WalkingParallelPair.zero) → motive x | true |
_private.Init.Data.Nat.Div.Basic.0.Nat.mod.match_1.splitter | Init.Data.Nat.Div.Basic | (motive : ℕ → ℕ → Sort u_1) → (x x_1 : ℕ) → ((x : ℕ) → motive 0 x) → ((n m : ℕ) → motive n.succ m) → motive x x_1 | true |
Std.DTreeMap.Internal.Impl.Const.getEntryLT?.go.eq_def | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} [inst : Ord α] (k : α) (best : Option (α × β))
(x : Std.DTreeMap.Internal.Impl α fun x => β),
Std.DTreeMap.Internal.Impl.Const.getEntryLT?.go k best x =
match x with
| Std.DTreeMap.Internal.Impl.leaf => best
| Std.DTreeMap.Internal.Impl.inner size ky y l r =>
match comp... | true |
Lean.Doc.Parser.UnorderedListType.ofNat | Lean.DocString.Parser | ℕ → Lean.Doc.Parser.UnorderedListType | true |
LinearMap.toMatrixOrthonormal._proof_3 | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{n : Type u_3} [inst_3 : Fintype n] [inst_4 : DecidableEq n] (v₁ : OrthonormalBasis n 𝕜 E),
Function.LeftInverse (LinearMap.toMatrix v₁.toBasis v₁.toBasis).invFun
(↑(LinearMap.toMatrix v₁.toBas... | false |
List.suffix_iff_eq_drop | Init.Data.List.Nat.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <:+ l₂ ↔ l₁ = List.drop (l₂.length - l₁.length) l₂ | true |
Set.sUnion_powerset_gc | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1}, GaloisConnection (fun x => ⋃₀ x) fun x => 𝒫 x | true |
String.Slice.Pattern.ToBackwardSearcher.DefaultBackwardSearcher.mk._flat_ctor | Init.Data.String.Pattern.Basic | {ρ : Type} →
{pat : ρ} → {s : String.Slice} → s.Pos → String.Slice.Pattern.ToBackwardSearcher.DefaultBackwardSearcher pat s | false |
CategoryTheory.SingleFunctors.Hom.ext_iff | Mathlib.CategoryTheory.Shift.SingleFunctors | ∀ {C : Type u_1} {D : Type u_2} {inst : CategoryTheory.Category.{v_1, u_1} C}
{inst_1 : CategoryTheory.Category.{v_2, u_2} D} {A : Type u_5} {inst_2 : AddMonoid A}
{inst_3 : CategoryTheory.HasShift D A} {F G : CategoryTheory.SingleFunctors C D A} {x y : F.Hom G},
x = y ↔ x.hom = y.hom | true |
CategoryTheory.FreeGroupoid.liftNatIso.eq_1 | Mathlib.CategoryTheory.Groupoid.FreeGroupoidOfCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {G : Type u₁} [inst_1 : CategoryTheory.Groupoid G]
(F₁ F₂ : CategoryTheory.Functor (CategoryTheory.FreeGroupoid C) G)
(τ : (CategoryTheory.FreeGroupoid.of C).comp F₁ ≅ (CategoryTheory.FreeGroupoid.of C).comp F₂),
CategoryTheory.FreeGroupoid.liftNatIso F₁ F₂... | true |
Homotopy.compRight._proof_2 | Mathlib.Algebra.Homology.Homotopy | ∀ {ι : Type u_3} {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ι} {C D E : HomologicalComplex V c} {e f : C ⟶ D} (h : Homotopy e f) (g : D ⟶ E) (i : ι),
(CategoryTheory.CategoryStruct.comp e g).f i =
(((dNext i) fun i j => CategoryTheory.C... | false |
Lean.Elab.Info | Lean.Elab.InfoTree.Types | Type | true |
StrictConvexOn.add_convexOn | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommMonoid β] [inst_4 : PartialOrder β] [IsOrderedCancelAddMonoid β] [inst_6 : SMul 𝕜 E]
[inst_7 : DistribMulAction 𝕜 β] {s : Set E} {f g : E → β},
StrictConvexOn 𝕜 s f → Conv... | true |
CategoryTheory.StructuredArrow.subobjectEquiv._proof_6 | Mathlib.CategoryTheory.Subobject.Comma | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {S : D} {T : CategoryTheory.Functor C D}
[inst_2 : CategoryTheory.Limits.HasFiniteLimits C] [inst_3 : CategoryTheory.Limits.PreservesFiniteLimits T]
(A : CategoryTheory.StructuredArrow S T... | false |
DiscreteTiling.PlacedTile.coe_smul | Mathlib.Combinatorics.Tiling.Tile | ∀ {G : Type u_1} {X : Type u_2} {ιₚ : Type u_3} [inst : Group G] [inst_1 : MulAction G X]
{ps : DiscreteTiling.Protoset G X ιₚ} (g : G) (pt : DiscreteTiling.PlacedTile ps), ↑(g • pt) = g • ↑pt | true |
Lean.Elab.Tactic.Omega.MetaProblem.mk | Lean.Elab.Tactic.Omega.Frontend | Lean.Elab.Tactic.Omega.Problem →
List Lean.Expr → List Lean.Expr → Std.HashSet Lean.Expr → Lean.Elab.Tactic.Omega.MetaProblem | true |
AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.pullbackToBaseIsOpenImmersion | 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)
[inst_1 : AlgebraicGeometry.PresheafedSpace.IsOpenImmersion g],
AlgebraicGeometry.PresheafedSpace.IsOpenImmersion
(CategoryT... | true |
WithBot.coe_le_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} {a : α} [inst : LE α] {x : WithBot α}, ↑a ≤ x ↔ ∃ b, x = ↑b ∧ a ≤ b | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getD_alter._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) | false |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.minContentIndent.match_1 | Lean.DocString.Parser | (text : Lean.FileMap) →
(motive : MProd Bool (MProd text.source.Pos (MProd ℕ ℕ)) → Sort u_1) →
(r : MProd Bool (MProd text.source.Pos (MProd ℕ ℕ))) →
((afterNewline : Bool) →
(i : text.source.Pos) → (result thisLineCol : ℕ) → motive ⟨afterNewline, i, result, thisLineCol⟩) →
motive r | false |
BoundedOrderHom.cancel_right | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
[inst_3 : BoundedOrder α] [inst_4 : BoundedOrder β] [inst_5 : BoundedOrder γ] {g₁ g₂ : BoundedOrderHom β γ}
{f : BoundedOrderHom α β}, Function.Surjective ⇑f → (g₁.comp f = g₂.comp f ↔ g₁ = g₂) | true |
smul_mem_fixedPoints_of_normal | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {G : Type u_1} [inst : Group G] {α : Type u_2} [inst_1 : MulAction G α] {H : Subgroup G} [hH : H.Normal] (g : G)
{a : α}, a ∈ MulAction.fixedPoints (↥H) α → g • a ∈ MulAction.fixedPoints (↥H) α | true |
Lean.Elab.Info.ofErrorNameInfo.noConfusion | Lean.Elab.InfoTree.Types | {P : Sort u} →
{i i' : Lean.Elab.ErrorNameInfo} →
Lean.Elab.Info.ofErrorNameInfo i = Lean.Elab.Info.ofErrorNameInfo i' → (i = i' → P) → P | false |
WithBot.bot_wcovBy_coe._simp_1 | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, (⊥ ⩿ ↑a) = IsMin a | false |
CategoryTheory.MorphismProperty.Comma.mapLeftComp | Mathlib.CategoryTheory.MorphismProperty.Comma | {A : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} A] →
{B : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] →
{T : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} T] →
(R : CategoryTheory.Functor B T) →
{P : CategoryTheory.MorphismPr... | true |
Std.DHashMap.Internal.Raw₀.Const.wf_insertManyIfNewUnit₀ | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α] {ρ : Type w} [inst_4 : ForIn Id ρ α]
{m : Std.DHashMap.Raw α fun x => Unit} {h : 0 < m.buckets.size} {l : ρ},
m.WF → (↑↑(Std.DHashMap.Internal.Raw₀.Const.insertManyIfNewUnit ⟨m, h⟩ l)).WF | true |
Num.Prime | Mathlib.Data.Num.Prime | Num → Prop | true |
PresheafOfModules.Monoidal.tensorObj_map_tmul | Mathlib.Algebra.Category.ModuleCat.Presheaf.Monoidal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {R : CategoryTheory.Functor Cᵒᵖ CommRingCat}
{M₁ M₂ : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat RingCat))} {X Y : Cᵒᵖ} (f : X ⟶ Y)
(m₁ : ↑(M₁.obj X)) (m₂ : ↑(M₂.obj X)),
(ModuleCat.Hom.hom ((PresheafOfModules.Monoidal.tensorObj M₁ ... | true |
Cycle.prev | Mathlib.Data.List.Cycle | {α : Type u_1} → [DecidableEq α] → (s : Cycle α) → s.Nodup → (x : α) → x ∈ s → α | true |
Matrix.kroneckerMap_transpose | Mathlib.LinearAlgebra.Matrix.Kronecker | ∀ {α : Type u_3} {β : Type u_5} {γ : Type u_7} {l : Type u_9} {m : Type u_10} {n : Type u_11} {p : Type u_12}
(f : α → β → γ) (A : Matrix l m α) (B : Matrix n p β),
Matrix.kroneckerMap f A.transpose B.transpose = (Matrix.kroneckerMap f A B).transpose | true |
contDiffWithinAt_inter | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s t : Set E}
{f : E → F} {x : E} {n : WithTop ℕ∞}, t ∈ nhds x → (ContDiffWithinAt 𝕜 n f (s ∩ t) x ↔ ContDiffWithin... | true |
_private.Mathlib.LinearAlgebra.RootSystem.Defs.0.RootPairing.isFixedPt_reflectionPerm_iff._simp_1_2 | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} {i j : ι},
((P.reflectionPerm i) j = j) = (P.pairing j i • P.root i = 0) | false |
BoxIntegral.Integrable.convergenceR | Mathlib.Analysis.BoxIntegral.Basic | {ι : Type u} →
{E : Type v} →
{F : Type w} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
[inst_2 : NormedAddCommGroup F] →
[inst_3 : NormedSpace ℝ F] →
{I : BoxIntegral.Box ι} →
[inst_4 : Fintype ι] →
{l : BoxInte... | true |
CategoryTheory.Monoidal.rightUnitor_hom_app | Mathlib.CategoryTheory.Monoidal.FunctorCategory | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.MonoidalCategory D] {F : CategoryTheory.Functor C D} {X : C},
(CategoryTheory.MonoidalCategoryStruct.rightUnitor F).hom.app X =
(CategoryTheory.MonoidalCategoryStruct.... | true |
Array.getElem?_zipWith | Init.Data.Array.Zip | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {as : Array α} {bs : Array β} {f : α → β → γ} {i : ℕ},
(Array.zipWith f as bs)[i]? =
match as[i]?, bs[i]? with
| some a, some b => some (f a b)
| x, x_1 => none | true |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.ExpandedFieldVal.proj.injEq | Lean.Elab.StructInst | ∀ (fvarId : Lean.FVarId) (stx : Lean.Term) (parentStructName parentFieldName : Lean.Name) (fvarId_1 : Lean.FVarId)
(stx_1 : Lean.Term) (parentStructName_1 parentFieldName_1 : Lean.Name),
(Lean.Elab.Term.StructInst.ExpandedFieldVal.proj✝ fvarId stx parentStructName parentFieldName =
Lean.Elab.Term.StructInst.E... | true |
ModuleCat.localizedModuleMap._proof_2 | Mathlib.Algebra.Category.ModuleCat.Localization | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : Small.{u_2, u_1} R] {N : ModuleCat R} (S : Submonoid R),
SMulCommClass (Localization S) R ↑(N.localizedModule S) | false |
_private.Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic.0.InnerProductGeometry.sin_angle_mul_norm_mul_norm._simp_1_3 | Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | false |
SkewMonoidAlgebra.instNonAssocRing._proof_9 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_2} {G : Type u_1} [inst : Ring k] [inst_1 : Monoid G] [inst_2 : MulSemiringAction G k], ↑0 = 0 | false |
Std.ExtDHashMap.Const.getKey!_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtDHashMap α fun x => Unit} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] [inst_2 : Inhabited α] {l : List α} {k k' : α},
(k == k') = true →
k ∉ m →
List.Pairwise (fun a b => (a == b) = false) l →
k ∈ l → (Std.ExtDHashMap.Const.insertManyIf... | true |
MvPFunctor.castLastB | Mathlib.Data.PFunctor.Multivariate.M | {n : ℕ} → (P : MvPFunctor.{u} (n + 1)) → {a a' : P.A} → a = a' → P.last.B a → P.last.B a' | true |
mul_le_mul_left | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : LE α] [i : MulRightMono α] {b c : α}, b ≤ c → ∀ (a : α), b * a ≤ c * a | true |
Finsupp.support_smul_eq | Mathlib.Data.Finsupp.SMul | ∀ {α : Type u_1} {M : Type u_3} {R : Type u_6} [inst : Semiring R] [IsDomain R] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M] [Module.IsTorsionFree R M] {b : R}, b ≠ 0 → ∀ {g : α →₀ M}, (b • g).support = g.support | true |
AddSubgroup.addOrderOf_mk | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G} (a : G) (ha : a ∈ H), addOrderOf ⟨a, ha⟩ = addOrderOf a | true |
Int.neg_inj | Init.Data.Int.Lemmas | ∀ {a b : ℤ}, -a = -b ↔ a = b | true |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.Attach.0.Std.IterM.toArray_eq_match_step.match_1.eq_1 | Init.Data.Iterators.Lemmas.Combinators.Monadic.Attach | ∀ {α β : Type u_1} {m : Type u_1 → Type u_2} (motive : Std.IterStep (Std.IterM m β) β → Sort u_3) (it' : Std.IterM m β)
(out : β) (h_1 : (it' : Std.IterM m β) → (out : β) → motive (Std.IterStep.yield it' out))
(h_2 : (it' : Std.IterM m β) → motive (Std.IterStep.skip it')) (h_3 : Unit → motive Std.IterStep.done),
... | true |
FirstOrder.Language.DefinableSet.instSetLike._proof_1 | Mathlib.ModelTheory.Definability | ∀ {L : FirstOrder.Language} {M : Type u_2} [inst : L.Structure M] {A : Set M} {α : Type u_1},
Function.Injective Subtype.val | false |
_private.Mathlib.Computability.Primrec.Basic.0.Primrec.eq._simp_1_1 | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, (a = b) = (a ≤ b ∧ b ≤ a) | false |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.exists_mem_support_mem_erase_mem_support_takeUntil_eq_empty._proof_1_3 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} {p : G.Walk u v}, ∀ x ∈ p.support, x ∈ p.support | false |
Lean.Lsp.instInhabitedCallHierarchyIncomingCall.default | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.CallHierarchyIncomingCall | true |
CategoryTheory.Limits.hasLimitsOfShape_thinSkeleton | Mathlib.CategoryTheory.Limits.Skeleton | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} C]
[Quiver.IsThin C] [CategoryTheory.Limits.HasLimitsOfShape J C],
CategoryTheory.Limits.HasLimitsOfShape J (CategoryTheory.ThinSkeleton C) | true |
FormalMultilinearSeries.unshift._proof_3 | Mathlib.Analysis.Calculus.FormalMultilinearSeries | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜], RingHomIsometric (RingHom.id 𝕜) | false |
AlgebraicGeometry.IsClosedImmersion.lift_fac_assoc | Mathlib.AlgebraicGeometry.Morphisms.ClosedImmersion | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Z) (g : Y ⟶ Z) [inst : AlgebraicGeometry.IsClosedImmersion f]
(H : AlgebraicGeometry.Scheme.Hom.ker f ≤ AlgebraicGeometry.Scheme.Hom.ker g) {Z_1 : AlgebraicGeometry.Scheme}
(h : Z ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.IsClosedImmersion.lift f g... | true |
Filter.Germ.LiftRel | Mathlib.Order.Filter.Germ.Basic | {α : Type u_1} → {β : Type u_2} → {γ : Type u_3} → {l : Filter α} → (β → γ → Prop) → l.Germ β → l.Germ γ → Prop | true |
DivisorChain.eq_pow_second_of_chain_of_has_chain | Mathlib.RingTheory.ChainOfDivisors | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [UniqueFactorizationMonoid M] {q : Associates M} {n : ℕ},
n ≠ 0 →
∀ {c : Fin (n + 1) → Associates M},
StrictMono c → (∀ {r : Associates M}, r ≤ q ↔ ∃ i, r = c i) → q ≠ 0 → q = c 1 ^ n | true |
Lean.IR.CollectUsedDecls.collectFnBody | Lean.Compiler.IR.EmitUtil | Lean.IR.FnBody → Lean.IR.CollectUsedDecls.M Unit | true |
CategoryTheory.ComposableArrows.IsComplex.opcyclesToCycles_fac._auto_1 | Mathlib.Algebra.Homology.ExactSequenceFour | Lean.Syntax | false |
NNRat.cast_inj._simp_1 | Mathlib.Data.Rat.Cast.CharZero | ∀ {α : Type u_3} [inst : DivisionSemiring α] [CharZero α] {p q : ℚ≥0}, (↑p = ↑q) = (p = q) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.