name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Util.0.Int.Linear.Poly.pp.match_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Util | (motive : Int.Linear.Poly → Sort u_1) →
(p : Int.Linear.Poly) →
((k : ℤ) → motive (Int.Linear.Poly.num k)) →
((x : Int.Linear.Var) → (p : Int.Linear.Poly) → motive (Int.Linear.Poly.add 1 x p)) →
((k : ℤ) → (x : Int.Linear.Var) → (p : Int.Linear.Poly) → motive (Int.Linear.Poly.add k x p)) → motive p |
IsLocalRing.map_mkQ_eq | Mathlib.RingTheory.LocalRing.Module | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : IsLocalRing R] {N₁ N₂ : Submodule R M},
N₁ ≤ N₂ →
N₂.FG →
(Submodule.map (IsLocalRing.maximalIdeal R • N₂).mkQ N₁ = Submodule.map (IsLocalRing.maximalIdeal R • N₂).mkQ N₂ ↔
N₁ = N₂) |
CategoryTheory.ShiftedHom.id_map | Mathlib.CategoryTheory.Shift.ShiftedHom | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {M : Type u_4} [inst_1 : AddMonoid M]
[inst_2 : CategoryTheory.HasShift C M] {X Y : C} {a : M} (f : CategoryTheory.ShiftedHom X Y a),
f.map (CategoryTheory.Functor.id C) = f |
CategoryTheory.GrothendieckTopology.le_canonical | Mathlib.CategoryTheory.Sites.Canonical | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) [J.Subcanonical],
J ≤ CategoryTheory.Sheaf.canonicalTopology C |
Algebra.Extension.Hom.algebraMap_toRingHom | Mathlib.RingTheory.Extension.Basic | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {P : Algebra.Extension R S}
{R' : Type u_1} {S' : Type u_2} [inst_3 : CommRing R'] [inst_4 : CommRing S'] [inst_5 : Algebra R' S']
{P' : Algebra.Extension R' S'} [inst_6 : Algebra R R'] [inst_7 : Algebra S S'] (self : P.Hom P') (x : P.Ring),
(algebraMap P'.Ring S') (self.toRingHom x) = (algebraMap S S') ((algebraMap P.Ring S) x) |
Lean.Grind.CutsatConfig.maxSuggestions._inherited_default | Init.Grind.Config | Option ℕ |
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 |
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' → inst ≍ inst' → inst_1 ≍ inst'_1 → t ≍ t' → WeakFEPair.noConfusionType P t t' |
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 |
Subgroup.ofUnits_bot | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : Monoid M], ⊥.ofUnits = ⊥ |
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⟩ |
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 |
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) |
_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 ⋯)) →
((k : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.impure) → motive (Lean.Compiler.LCNF.Alt.default k)) →
motive alt |
_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 |
Fin.rec0 | Mathlib.Data.Fin.Basic | {α : Fin 0 → Sort u_1} → (i : Fin 0) → α i |
Lean.Server.instInhabitedRequestError.default | Lean.Server.Requests | Lean.Server.RequestError |
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 |
Lean.Elab.Tactic.evalWithReducibleAndInstances._regBuiltin.Lean.Elab.Tactic.evalWithReducibleAndInstances_1 | Lean.Elab.Tactic.ElabTerm | IO Unit |
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 |
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 |
QuaternionAlgebra.imIₗ | Mathlib.Algebra.Quaternion | {R : Type u_3} → (c₁ c₂ c₃ : R) → [inst : CommRing R] → QuaternionAlgebra R c₁ c₂ c₃ →ₗ[R] R |
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) 𝓕) |
Nat.Partrec.Code.rfind'.noConfusion | Mathlib.Computability.PartrecCode | {P : Sort u} → {a a' : Nat.Partrec.Code} → a.rfind' = a'.rfind' → (a = a' → P) → P |
_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₂) |
UInt64.lt_iff_toBitVec_lt | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, a < b ↔ a.toBitVec < b.toBitVec |
Lean.Meta.DefEqCacheKey | Lean.Meta.Basic | Type |
Ordinal.nhds_eq_pure | Mathlib.SetTheory.Ordinal.Topology | ∀ {a : Ordinal.{u}}, nhds a = pure a ↔ ¬Order.IsSuccLimit a |
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 |
_private.Lean.Elab.Structure.0.Lean.Elab.Command.Structure.replaceFieldInfo | Lean.Elab.Structure | Lean.Elab.Command.Structure.StructFieldInfo → Lean.Elab.Command.Structure.StructElabM✝ Unit |
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) |
_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 |
Lean.Lsp.LeanImport.ctorIdx | Lean.Data.Lsp.Extra | Lean.Lsp.LeanImport → ℕ |
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 |
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) |
_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 |
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.SqStruct c p f g j) {j' : J}
(α : j' ⟶ j), (sq'.map α).f' = CategoryTheory.CategoryStruct.comp (F.map α) sq'.f' |
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 |
_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 |
Set.Ici.isAtom_iff | Mathlib.Order.Atoms | ∀ {α : Type u_2} [inst : PartialOrder α] {a : α} {b : ↑(Set.Ici a)}, IsAtom b ↔ a ⋖ ↑b |
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_3 : F'.IsRightKanExtension α] (G : CategoryTheory.Functor D H),
Function.RightInverse (fun β => F'.liftOfIsRightKanExtension α G β) fun β =>
CategoryTheory.CategoryStruct.comp (L.whiskerLeft β) α |
_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 |
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 |
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 (Opposite.unop X).hom.op |
_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 |
_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 |
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 compare k ky with
| Ordering.gt => Std.DTreeMap.Internal.Impl.Const.getEntryLT?.go k (some (ky, y)) r
| x => Std.DTreeMap.Internal.Impl.Const.getEntryLT?.go k best l |
Lean.Doc.Parser.UnorderedListType.ofNat | Lean.DocString.Parser | ℕ → Lean.Doc.Parser.UnorderedListType |
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₁.toBasis v₁.toBasis)).toFun |
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₂ |
Set.sUnion_powerset_gc | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1}, GaloisConnection (fun x => ⋃₀ x) fun x => 𝒫 x |
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 |
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 |
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₂ τ =
CategoryTheory.Localization.liftNatIso (CategoryTheory.FreeGroupoid.of C) ⊤
((CategoryTheory.FreeGroupoid.of C).comp F₁) ((CategoryTheory.FreeGroupoid.of C).comp F₂) F₁ F₂ τ |
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.CategoryStruct.comp (h.hom i j) (g.f j)) +
(prevD i) fun i j => CategoryTheory.CategoryStruct.comp (h.hom i j) (g.f j)) +
(CategoryTheory.CategoryStruct.comp f g).f i |
Lean.Elab.Info | Lean.Elab.InfoTree.Types | Type |
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 → ConvexOn 𝕜 s g → StrictConvexOn 𝕜 s (f + g) |
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) (x : CategoryTheory.Subobject A),
CategoryTheory.CategoryStruct.comp ⋯.choose (T.map (↑⟨CategoryTheory.StructuredArrow.projectSubobject x, ⋯⟩).arrow) =
A.hom |
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 |
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 |
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
(CategoryTheory.Limits.limit.π (CategoryTheory.Limits.cospan f g) CategoryTheory.Limits.WalkingCospan.one) |
WithBot.coe_le_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} {a : α} [inst : LE α] {x : WithBot α}, ↑a ≤ x ↔ ∃ b, x = ↑b ∧ a ≤ b |
_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) |
_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 |
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₂) |
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) α |
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 |
WithBot.bot_wcovBy_coe._simp_1 | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, (⊥ ⩿ ↑a) = IsMin a |
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.MorphismProperty T} →
{Q : CategoryTheory.MorphismProperty A} →
{W : CategoryTheory.MorphismProperty B} →
[inst_3 : Q.IsMultiplicative] →
[inst_4 : W.IsMultiplicative] →
{L₁ L₂ L₃ : CategoryTheory.Functor A T} →
[Q.RespectsIso] →
[W.RespectsIso] →
(l : L₁ ⟶ L₂) →
(l' : L₂ ⟶ L₃) →
(hl :
∀ (X : CategoryTheory.MorphismProperty.Comma L₂ R P Q W),
P (CategoryTheory.CategoryStruct.comp (l.app X.left) X.hom)) →
(hl' :
∀ (X : CategoryTheory.MorphismProperty.Comma L₃ R P Q W),
P (CategoryTheory.CategoryStruct.comp (l'.app X.left) X.hom)) →
(hll' :
∀ (X : CategoryTheory.MorphismProperty.Comma L₃ R P Q W),
P
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.CategoryStruct.comp l l').app X.left) X.hom)) →
CategoryTheory.MorphismProperty.Comma.mapLeft R
(CategoryTheory.CategoryStruct.comp l l') hll' ≅
(CategoryTheory.MorphismProperty.Comma.mapLeft R l' hl').comp
(CategoryTheory.MorphismProperty.Comma.mapLeft R l hl) |
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 |
Num.Prime | Mathlib.Data.Num.Prime | Num → Prop |
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₁ M₂).map f)) (m₁ ⊗ₜ[↑(R.obj X)] m₂) =
(CategoryTheory.ConcreteCategory.hom (M₁.map f)) m₁ ⊗ₜ[↑(R.obj Y)]
(CategoryTheory.ConcreteCategory.hom (M₂.map f)) m₂ |
Cycle.prev | Mathlib.Data.List.Cycle | {α : Type u_1} → [DecidableEq α] → (s : Cycle α) → s.Nodup → (x : α) → x ∈ s → α |
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 |
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 ↔ ContDiffWithinAt 𝕜 n f s x) |
_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) |
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 : BoxIntegral.IntegrationParams} →
{f : (ι → ℝ) → E} →
{vol : BoxIntegral.BoxAdditiveMap ι (E →L[ℝ] F) ⊤} →
BoxIntegral.Integrable I l f vol → ℝ → NNReal → (ι → ℝ) → ↑(Set.Ioi 0) |
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.rightUnitor (F.obj X)).hom |
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 |
_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.ExpandedFieldVal.proj✝¹ fvarId_1 stx_1 parentStructName_1 parentFieldName_1) =
(fvarId = fvarId_1 ∧ stx = stx_1 ∧ parentStructName = parentStructName_1 ∧ parentFieldName = parentFieldName_1) |
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) |
_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 |
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 |
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.insertManyIfNewUnit m l).getKey! k' = k |
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' |
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 |
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 |
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 |
Int.neg_inj | Init.Data.Int.Lemmas | ∀ {a b : ℤ}, -a = -b ↔ a = b |
_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),
(match Std.IterStep.yield it' out with
| Std.IterStep.yield it' out => h_1 it' out
| Std.IterStep.skip it' => h_2 it'
| Std.IterStep.done => h_3 ()) =
h_1 it' out |
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 |
_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) |
_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 |
Lean.Lsp.instInhabitedCallHierarchyIncomingCall.default | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.CallHierarchyIncomingCall |
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) |
FormalMultilinearSeries.unshift._proof_3 | Mathlib.Analysis.Calculus.FormalMultilinearSeries | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜], RingHomIsometric (RingHom.id 𝕜) |
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 H)
(CategoryTheory.CategoryStruct.comp f h) =
CategoryTheory.CategoryStruct.comp g h |
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 |
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 |
Lean.IR.CollectUsedDecls.collectFnBody | Lean.Compiler.IR.EmitUtil | Lean.IR.FnBody → Lean.IR.CollectUsedDecls.M Unit |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.