name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Algebra.Module.Submodule.Range.0.LinearMap.ker_le_iff._simp_1_1 | Mathlib.Algebra.Module.Submodule.Range | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{f : M →ₛₗ[τ₁₂] M₂} {y : M}, (y ∈ f.ker) = (f y = 0) | null | false |
_private.Mathlib.AlgebraicGeometry.ColimitsOver.0.AlgebraicGeometry.Scheme.Cover.ColimitGluingData.cocone_ι_transitionMap._simp_1_2 | Mathlib.AlgebraicGeometry.ColimitsOver | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{D : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} D] (H : CategoryTheory.Functor C D)
{F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone F) (j : J),
H.map (c.ι.app j) = (H... | null | false |
diffToIdealOfQuotientCompEq_apply | Mathlib.RingTheory.Derivation.ToSquareZero | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : CommRing B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (I : Ideal B) (f₁ f₂ : A →ₐ[R] B)
(e : (Ideal.Quotient.mkₐ R I).comp f₁ = (Ideal.Quotient.mkₐ R I).comp f₂) (x : A),
↑((diffToIdealOfQuotientCompEq I f₁ f₂... | null | true |
LinearMap.rTensor_smul_action | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_4) (N : Type u_5) [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (r : R),
LinearMap.rTensor M (DistribSMul.toLinearMap R N r) = DistribSMul.toLinearMap R (TensorProduct R N M) r | null | true |
ProbabilityTheory.covariance_sum_sum' | Mathlib.Probability.Moments.Covariance | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {ι : Type u_2} {X : ι → Ω → ℝ} {s : Finset ι}
[MeasureTheory.IsFiniteMeasure μ] {ι' : Type u_3} {Y : ι' → Ω → ℝ} {t : Finset ι'},
(∀ i ∈ s, MeasureTheory.MemLp (X i) 2 μ) →
(∀ i ∈ t, MeasureTheory.MemLp (Y i) 2 μ) →
ProbabilityTheory.... | null | true |
DirectLimit.Ring.of._proof_3 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_2} [inst : Preorder ι] (G : ι → Type u_1) {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
(f : (x x_1 : ι) → (h : x ≤ x_1) → T h) [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι]
[inst_4 : (i : ι) → NonAssocSemir... | null | false |
Summable.compl_add | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α} [ContinuousAdd α]
{s : Set β}, Summable (f ∘ Subtype.val) → Summable (f ∘ Subtype.val) → Summable f | null | true |
_private.Mathlib.MeasureTheory.Measure.IntegralCharFun.0.MeasureTheory.integral_charFun_Icc._simp_1_9 | Mathlib.MeasureTheory.Measure.IntegralCharFun | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | null | false |
ContinuousMap.instSemiringOfIsTopologicalSemiring._proof_1 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Semiring β]
[inst_3 : IsTopologicalSemiring β] (a : C(α, β)), 0 * a = 0 | null | false |
Std.Http.Protocol.H1.Reader.isComplete | Std.Http.Protocol.H1.Reader | {dir : Std.Http.Protocol.H1.Direction} → Std.Http.Protocol.H1.Reader dir → Bool | Checks if the reader has completed parsing the current message.
| true |
Module.FaithfullyFlat.iff_flat_and_ideal_smul_eq_top | Mathlib.RingTheory.Flat.FaithfullyFlat.Basic | ∀ (R : Type u) (M : Type v) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
Module.FaithfullyFlat R M ↔ Module.Flat R M ∧ ∀ (I : Ideal R), I • ⊤ = ⊤ → I = ⊤ | null | true |
Algebra.TensorProduct.nontrivial_of_algebraMap_injective_of_flat_right | Mathlib.RingTheory.Flat.Basic | ∀ (R : Type u_1) [inst : CommSemiring R] (A : Type u_2) (B : Type u_3) [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B],
Function.Injective ⇑(algebraMap R A) → ∀ [Module.Flat R B] [Nontrivial B], Nontrivial (TensorProduct R A B) | If `A`, `B` are `R`-algebras, `R` injects into `A`,
and `B` is a nontrivial flat `R`-algebra, then `A ⊗[R] B` is nontrivial. | true |
DifferentiableOn.clm_comp | Mathlib.Analysis.Calculus.FDeriv.CompCLM | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type u_4}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {s : Set E} {H : Type u_5} [inst_7 : ... | null | true |
CategoryTheory.Limits.WidePullback.π | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | {J : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{B : C} →
{objs : J → C} →
(arrows : (j : J) → objs j ⟶ B) →
[inst_1 : CategoryTheory.Limits.HasWidePullback B objs arrows] →
(j : J) → CategoryTheory.Limits.widePullback B objs arrows ⟶ obj... | The `j`-th projection from the pullback. | true |
NonUnitalStarSubalgebra.iSupLift._proof_9 | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u_2} {A : Type u_1} {B : Type u_4} [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A]
[inst_2 : StarRing A] [inst_3 : Module R A] [inst_4 : NonUnitalSemiring B] [inst_5 : StarRing B] [inst_6 : Module R B]
{ι : Type u_3} [inst_7 : StarRing R] [inst_8 : IsScalarTower R A A] [inst_9 : SMulCommClass R A... | null | false |
Ordinal.add_sub_add_cancel | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (a b c : Ordinal.{u_4}), a + b - (a + c) = b - c | null | true |
FunctionField.finiteDimensional_of_constantExtension | Mathlib.NumberTheory.FunctionField | ∀ {F : Type u_1} (K : Type u_2) [inst : Field F] [inst_1 : Field K] [inst_2 : Algebra (Polynomial F) K]
[inst_3 : FaithfulSMul (Polynomial F) K] [FunctionField F K] {E : Type u_3} [inst_5 : Field E] [inst_6 : Algebra F E]
[inst_7 : Algebra (Polynomial E) K] [FaithfulSMul (Polynomial E) K] [IsScalarTower (Polynomial... | Let `K` be a function field over `F`. If `E` is an algebraic extension of `F` which is
contained in `K` then it is finite over `F`. | true |
PFunctor.M.iselect_cons | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} [inst : DecidableEq F.A] [inst_1 : Inhabited F.M] (ps : PFunctor.Approx.Path F) {a : F.A}
(f : F.B a → F.M) {i : F.B a},
PFunctor.M.iselect (⟨a, i⟩ :: ps) (PFunctor.M.mk (PFunctor.Obj.mk a f)) = PFunctor.M.iselect ps (f i) | null | true |
_private.Init.Data.String.Basic.0.String.Slice.Pos.str_lt_str_iff._simp_1_3 | Init.Data.String.Basic | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ < i₂) = (i₁.byteIdx < i₂.byteIdx) | null | false |
_private.Lean.Server.Requests.0.Lean.Server.initFn._@.Lean.Server.Requests.3846811639._hygCtx._hyg.2 | Lean.Server.Requests | IO (IO.Ref (Lean.PersistentHashMap String Lean.Server.RequestHandler)) | null | false |
CategoryTheory.rightDistributor_hom_comp_biproduct_π_assoc | Mathlib.CategoryTheory.Monoidal.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.MonoidalPreadditive C]
[inst_4 : CategoryTheory.Limits.HasFiniteBiproducts C] {J : Type} [inst_5 : Finite J] (f : J → C) (X : C) (j : J)
{Z :... | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.extractLsb'_append_extractLsb'._proof_1_1 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {len : ℕ} (i : ℕ), ¬i < len → ¬len + (i - len) = i → False | null | false |
_private.Mathlib.CategoryTheory.Sites.Equivalence.0.CategoryTheory.Equivalence.instIsCoverDenseOfIsEquivalence._simp_1 | Mathlib.CategoryTheory.Sites.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : Y ⟶ X), ⊤.1 f = True | null | false |
Lean.Compiler.LCNF.PassInstaller.installAfter | Lean.Compiler.LCNF.PassManager | Lean.Compiler.LCNF.Phase →
Lean.Name → (Lean.Compiler.LCNF.Pass → Lean.Compiler.LCNF.Pass) → optParam ℕ 0 → Lean.Compiler.LCNF.PassInstaller | null | true |
Lean.Server.instInhabitedReferences.default | Lean.Server.References | Lean.Server.References | null | true |
_private.Batteries.Lean.LawfulMonadLift.0.EIO.bind_eq_EST_bind | Batteries.Lean.LawfulMonadLift | ∀ {ε α β : Type} (ma : EIO ε α) (f : α → EIO ε β), ma >>= f = EST.bind ma f | null | true |
TopologicalSpace.Compacts.uniformContinuous_prod | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : UniformSpace β], UniformContinuous fun x => x.1 ×ˢ x.2 | null | true |
StarSubalgebra.mem_sup_right | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : Algebra R A] [inst_4 : StarRing A] [inst_5 : StarModule R A] {S T : StarSubalgebra R A} {x : A},
x ∈ T → x ∈ S ⊔ T | null | true |
IsClosed.analyticSet | Mathlib.MeasureTheory.Constructions.Polish.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] [PolishSpace α] {s : Set α}, IsClosed s → MeasureTheory.AnalyticSet s | null | true |
Lean.Lsp.LeanModuleHierarchyImportsParams._sizeOf_inst | Lean.Data.Lsp.Extra | SizeOf Lean.Lsp.LeanModuleHierarchyImportsParams | null | false |
Std.LawfulOrderBEq | Init.Data.Order.Classes | (α : Type u) → [BEq α] → [LE α] → Prop | null | true |
CategoryTheory.AddMonObj.ofIso._proof_4 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] {M X : C}
[inst_2 : CategoryTheory.AddMonObj M] (e : M ≅ X),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X
(CategoryTheory.CategoryStruct.comp CategoryT... | null | false |
Lean.Meta.Grind.SplitAnchorRefInfo.casesOn | Lean.Meta.Tactic.Grind.Split | {motive : Lean.Meta.Grind.SplitAnchorRefInfo → Sort u} →
(t : Lean.Meta.Grind.SplitAnchorRefInfo) →
((numDigits : ℕ) →
(anchor : UInt64) → (ordinal : ℕ) → motive { numDigits := numDigits, anchor := anchor, ordinal := ordinal }) →
motive t | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.0.Nat.EqResult.false.inj | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | ∀ {p p_1 : Lean.Expr}, Nat.EqResult.false✝ p = Nat.EqResult.false✝ p_1 → p = p_1 | null | true |
CategoryTheory.ModObj.noConfusion | Mathlib.CategoryTheory.Monoidal.Mod | {P : Sort u} →
{C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.MonoidalCategory C} →
{D : Type u₂} →
{inst_2 : CategoryTheory.Category.{v₂, u₂} D} →
{inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D} →
{M : C} ... | null | false |
WittVector.IsocrystalHom.frob_equivariant | Mathlib.RingTheory.WittVector.Isocrystal | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] {k : Type u_1} [inst_1 : CommRing k] [inst_2 : CharP k p]
[inst_3 : PerfectRing k p] {V : Type u_2} [inst_4 : AddCommGroup V] [inst_5 : WittVector.Isocrystal p k V]
{V₂ : Type u_3} [inst_6 : AddCommGroup V₂] [inst_7 : WittVector.Isocrystal p k V₂]
(self : WittVector.Isocrysta... | null | true |
List.zipWith₄._unsafe_rec | Batteries.Data.List.Basic | {α : Type u_1} →
{β : Type u_2} →
{γ : Type u_3} → {δ : Type u_4} → {ε : Type u_5} → (α → β → γ → δ → ε) → List α → List β → List γ → List δ → List ε | null | false |
Std.Internal.List.isSome_getValueCast?_eq_isSome_getEntry? | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {l : List ((a : α) × β a)} {a : α},
(Std.Internal.List.getValueCast? a l).isSome = (Std.Internal.List.getEntry? a l).isSome | null | true |
bihimp_bihimp_self | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : BooleanAlgebra α] (a b : α), bihimp (bihimp a b) a = b | null | true |
_private.Mathlib.Analysis.Analytic.Basic.0.HasFPowerSeriesWithinOnBall.comp_sub._simp_1_1 | Mathlib.Analysis.Analytic.Basic | ∀ {α : Type u_1} {x a : α} {s : Set α}, (x ∈ insert a s) = (x = a ∨ x ∈ s) | null | false |
ByteArray.utf8DecodeChar | Init.Data.String.Decode | (bytes : ByteArray) → (i : ℕ) → (bytes.utf8DecodeChar? i).isSome = true → Char | Decodes and returns the `Char` whose UTF-8 encoding begins at `i` in `bytes`.
This function requires a proof that there is, in fact, a valid `Char` at `i`. `utf8DecodeChar?` is
an alternative function that returns `Option Char` instead of requiring a proof ahead of time.
| true |
CategoryTheory.Limits.Multicoequalizer.instEpiSigmaπ | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape}
(I : CategoryTheory.Limits.MultispanIndex J C) [inst_1 : CategoryTheory.Limits.HasMulticoequalizer I]
[inst_2 : CategoryTheory.Limits.HasCoproduct I.left] [inst_3 : CategoryTheory.Limits.HasCoproduct I.right],
Cate... | null | true |
_private.Lean.Elab.Tactic.Conv.Basic.0.Lean.Elab.Tactic.Conv.evalFirst._regBuiltin.Lean.Elab.Tactic.Conv.evalFirst_1 | Lean.Elab.Tactic.Conv.Basic | IO Unit | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula.0.WeierstrassCurve.Projective.toAffine_negAddY_of_ne._simp_1_2 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
Lean.Compiler.LCNF.LetValue.const | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
Lean.Name →
List Lean.Level →
Array (Lean.Compiler.LCNF.Arg pu) →
autoParam (pu = Lean.Compiler.LCNF.Purity.pure) Lean.Compiler.LCNF.LetValue._auto_3 →
Lean.Compiler.LCNF.LetValue pu | A pure application of a constant.
| true |
CategoryTheory.JointlyReflectIsomorphisms.jointlyReflectsLimit | Mathlib.CategoryTheory.Functor.ReflectsIso.Limits | {C : Type u_1} →
[inst : CategoryTheory.Category.{u_5, u_1} C] →
{I : Type u_2} →
{D : I → Type u_3} →
[inst_1 : (i : I) → CategoryTheory.Category.{u_6, u_3} (D i)] →
{F : (i : I) → CategoryTheory.Functor C (D i)} →
CategoryTheory.JointlyReflectIsomorphisms F →
{J... | If `Fᵢ : C ⥤ Dᵢ` is a conservative family of functors which also
preserve the (existing) limit of a functor `G : J ⥤ C`, then a cone
for `G` is a limit if it is so after applying the functors `Fᵢ`
(see also `reflectsLimit_of_reflectsIsomorphisms` in the file
`Mathlib/CategoryTheory/Limits/Preserves/Basic.lean` for the ... | true |
Cardinal.mk_psum | Mathlib.SetTheory.Cardinal.Defs | ∀ (α : Type u) (β : Type v),
Cardinal.mk (α ⊕' β) = Cardinal.lift.{v, u} (Cardinal.mk α) + Cardinal.lift.{u, v} (Cardinal.mk β) | null | true |
Std.HashMap.Raw.Equiv.getElem!_eq | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α] {k : α} [inst_4 : Inhabited β], m₁.WF → m₂.WF → m₁.Equiv m₂ → m₁[k]! = m₂[k]! | null | true |
ContinuousMultilinearMap.curryMidEquiv._proof_1 | Mathlib.Analysis.Normed.Module.Multilinear.Curry | ∀ (𝕜 : Type u_3) {n : ℕ} (Ei : Fin n.succ → Type u_1) (G : Type u_2) [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : Fin n.succ) → NormedAddCommGroup (Ei i)] [inst_2 : (i : Fin n.succ) → NormedSpace 𝕜 (Ei i)]
[inst_3 : NormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] (p : Fin (n + 1)) (f : ContinuousMultiline... | null | false |
FirstOrder.Language.Term.listEncode.eq_1 | Mathlib.ModelTheory.Encoding | ∀ {L : FirstOrder.Language} {α : Type u'} (i : α), (FirstOrder.Language.var i).listEncode = [Sum.inl i] | null | true |
rootsOfUnityEquivNthRoots_apply | Mathlib.RingTheory.RootsOfUnity.Basic | ∀ {R : Type u_4} {k : ℕ} [inst : NeZero k] [inst_1 : CommRing R] [inst_2 : IsDomain R] (x : ↥(rootsOfUnity k R)),
↑((rootsOfUnityEquivNthRoots R k) x) = ↑↑x | null | true |
CategoryTheory.Functor.preservesMonomorphisms_of_adjunction | Mathlib.CategoryTheory.Functor.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : G ⊣ F), F.PreservesMonomorphisms | null | true |
_private.Init.Grind.Module.NatModuleNorm.0.Lean.Grind.Linarith.Poly.denoteN_combine._proof_1_1 | Init.Grind.Module.NatModuleNorm | ∀ (a₁ : ℤ) (x₁ : Lean.Grind.Linarith.Var) (a₂ : ℤ) (x₂ : Lean.Grind.Linarith.Var),
a₁ ≥ 0 → a₂ ≥ 0 → ¬a₁ + a₂ ≥ 0 → False | null | false |
CompactlyGenerated.instCategory._proof_9 | Mathlib.Topology.Category.CompactlyGenerated | autoParam
(∀ {W X Y Z : CompactlyGenerated} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h =
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h))
CategoryTheory.Category.assoc._autoParam | null | false |
_private.Mathlib.FieldTheory.LinearDisjoint.0.IntermediateField.LinearDisjoint.isDomain'._simp_1_2 | Mathlib.FieldTheory.LinearDisjoint | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {A B : IntermediateField F E},
A.LinearDisjoint ↥B = A.LinearDisjoint B.toSubalgebra | null | false |
CochainComplex.HomComplex.Cochain.mk_v | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{F G : CochainComplex C ℤ} {n : ℤ} (v : (p q : ℤ) → p + n = q → (F.X p ⟶ G.X q)) (p q : ℤ) (hpq : p + n = q),
(CochainComplex.HomComplex.Cochain.mk v).v p q hpq = v p q hpq | null | true |
Algebra.Generators.cotangentCompLocalizationAwayEquiv | Mathlib.RingTheory.Extension.Cotangent.LocalizationAway | {R : Type u_1} →
{S : Type u_2} →
{T : Type u_3} →
{ι : Type u_4} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
[inst_3 : CommRing T] →
[inst_4 : Algebra R T] →
[inst_5 : Algebra S T] →
... | Let `S` be generated over `R` by `P : R[X] → S` with kernel `I` and let `T`
be the localization of `S` away from `g` generated over `S` by `S[Y] → T` with
kernel `K`.
Denote by `J` the kernel of the induced `R[X, Y] → T`. Then
`J/J² ≃ₗ[T] T ⊗[S] (I/I²) × (K/K²)`.
This is the splitting characterised by `x ↦ (0, g * X -... | true |
Meromorphic.mul | Mathlib.Analysis.Meromorphic.Basic | ∀ {𝕜 : Type u_1} {𝕜' : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NontriviallyNormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {f g : 𝕜 → 𝕜'}, Meromorphic f → Meromorphic g → Meromorphic (f * g) | null | true |
Aesop.Frontend.RuleExpr.brecOn | Aesop.Frontend.RuleExpr | {motive_1 : Aesop.Frontend.RuleExpr → Sort u} →
{motive_2 : Array Aesop.Frontend.RuleExpr → Sort u} →
{motive_3 : List Aesop.Frontend.RuleExpr → Sort u} →
(t : Aesop.Frontend.RuleExpr) →
((t : Aesop.Frontend.RuleExpr) → t.below → motive_1 t) →
((t : Array Aesop.Frontend.RuleExpr) → Aesop.F... | null | false |
ComplexShape.instDecidableRelRelDown | Mathlib.Algebra.Homology.ComplexShape | (α : Type u_1) →
[inst : AddRightCancelSemigroup α] →
[DecidableEq α] → [inst_2 : One α] → DecidableRel fun a a_1 => (ComplexShape.down α).Rel a_1 a | null | true |
_private.Mathlib.FieldTheory.CardinalEmb.0.Field.Emb.Cardinal.termĒ | Mathlib.FieldTheory.CardinalEmb | Lean.ParserDescr | null | true |
CategoryTheory.Limits.HasFiniteProducts | Mathlib.CategoryTheory.Limits.Shapes.FiniteProducts | (C : Type u) → [CategoryTheory.Category.{v, u} C] → Prop | A category has finite products if there exists a limit for every diagram
with shape `Discrete J`, where we have `[Finite J]`.
We require this condition only for `J = Fin n` in the definition, then deduce a version for any
`J : Type*` as a corollary of this definition.
| true |
List.lt_findIdx_iff._proof_2 | Init.Data.List.Find | ∀ {α : Type u_1} (xs : List α), ∀ i < xs.length, ∀ j ≤ i, j < xs.length | null | false |
MulRingNorm.isPowMul | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | ∀ {A : Type u_2} [inst : Ring A] (f : MulRingNorm A), IsPowMul ⇑f | A multiplicative ring norm is power-multiplicative. | true |
Submodule.colon_inf_eq_left_of_subset | Mathlib.RingTheory.Ideal.Colon | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{N₁ N₂ : Submodule R M} {S : Set M}, S ⊆ ↑N₂ → (N₁ ⊓ N₂).colon S = N₁.colon S | If `S ⊆ N₂`, then intersecting with `N₂` does not change the colon ideal. | true |
_private.Lean.Elab.ElabRules.0.Lean.Elab.Command.elabElabRulesAux.match_1 | Lean.Elab.ElabRules | (motive : Option Lean.Syntax → Sort u_1) →
(x : Option Lean.Syntax) → (Unit → motive none) → ((quoted : Lean.Syntax) → motive (some quoted)) → motive x | null | false |
PresheafOfModules.Submodule.instCompleteLattice._proof_4 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Submodule | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{M : PresheafOfModules R} (x x_1 : M.Submodule) (x_2 : Cᵒᵖ), x_1.obj x_2 ≤ x.obj x_2 ⊔ x_1.obj x_2 | null | false |
PolyEquivTensor.toFunLinear_one_tmul_one | Mathlib.RingTheory.PolynomialAlgebra | ∀ (R : Type u_1) (A : Type u_3) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
(PolyEquivTensor.toFunLinear R A) (1 ⊗ₜ[R] 1) = 1 | null | true |
_private.Mathlib.Order.RelIso.Basic.0.RelEmbedding.isPartialOrder.match_1_1 | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (motive : r ↪r s → IsPartialOrder β s → Prop)
(x : r ↪r s) (x_1 : IsPartialOrder β s), (∀ (f : r ↪r s) (x : IsPartialOrder β s), motive f x) → motive x x_1 | null | false |
Tactic.ComputeAsymptotics.Seq.instBoundedSpaceStream' | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | ∀ {α : Type u_1}, BoundedSpace (Stream' α) | null | true |
List.head_eq_iff_head?_eq_some | Init.Data.List.Lemmas | ∀ {α : Type u_1} {a : α} {xs : List α} (h : xs ≠ []), xs.head h = a ↔ xs.head? = some a | null | true |
CategoryTheory.Bicategory.Strict.casesOn | Mathlib.CategoryTheory.Bicategory.Strict.Basic | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{motive : CategoryTheory.Bicategory.Strict B → Sort u_1} →
(t : CategoryTheory.Bicategory.Strict B) →
((id_comp :
∀ {a b : B} (f : a ⟶ b), CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id a) f = f) →
... | null | false |
_private.Lean.Meta.Match.SolveOverlap.0.Lean.Meta.Match.InjectionAnyResult.ctorElimType | Lean.Meta.Match.SolveOverlap | {motive : Lean.Meta.Match.InjectionAnyResult✝ → Sort u} → ℕ → Sort (max 1 u) | null | false |
ISize.and_not_self | Init.Data.SInt.Bitwise | ∀ {a : ISize}, a &&& ~~~a = 0 | null | true |
CategoryTheory.Limits.Fork.op_ι_app_zero | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {f g : X ⟶ Y}
(c : CategoryTheory.Limits.Fork f g),
c.op.ι.app CategoryTheory.Limits.WalkingParallelPair.zero = (c.π.app CategoryTheory.Limits.WalkingParallelPair.one).op | null | true |
Vector.mem_ite_empty_right | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {p : Prop} {x : α} [inst : Decidable p] {xs : Vector α 0}, (x ∈ if p then xs else #v[]) ↔ p ∧ x ∈ xs | null | true |
CategoryTheory.InducedWideCategory.Hom.mk.noConfusion | Mathlib.CategoryTheory.Widesubcategory | {C : Type u₁} →
{D : Type u₂} →
{inst : CategoryTheory.Category.{v₁, u₂} D} →
{F : C → D} →
{P : CategoryTheory.MorphismProperty D} →
{inst_1 : P.IsMultiplicative} →
{X Y : CategoryTheory.InducedWideCategory D F P} →
{P_1 : Sort u} →
{hom : F X ⟶ F... | null | false |
AddMonoidAlgebra.mapDomainRingHom._proof_2 | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ (R : Type u_1) {M : Type u_2} {N : Type u_3} [inst : Semiring R] [inst_1 : AddMonoid M] [inst_2 : AddMonoid N]
(f : M →+ N) (x y : AddMonoidAlgebra R M),
AddMonoidAlgebra.mapDomain (⇑f) (x * y) = AddMonoidAlgebra.mapDomain (⇑f) x * AddMonoidAlgebra.mapDomain (⇑f) y | null | false |
instInhabitedPUnit | Init.Core | Inhabited PUnit.{u_1} | null | true |
MeasureTheory.Measure.add_mconv | Mathlib.MeasureTheory.Group.Convolution | ∀ {M : Type u_1} [inst : Monoid M] [inst_1 : MeasurableSpace M] [MeasurableMul₂ M] (μ ν ρ : MeasureTheory.Measure M)
[MeasureTheory.SFinite μ] [MeasureTheory.SFinite ν] [MeasureTheory.SFinite ρ], (μ + ν).mconv ρ = μ.mconv ρ + ν.mconv ρ | null | true |
Nat.ascFactorial_of_sub | Mathlib.Data.Nat.Factorial.Basic | ∀ {n k : ℕ}, (n - k) * (n - k + 1).ascFactorial k = (n - k).ascFactorial (k + 1) | null | true |
SlashInvariantForm.coe_intCast | Mathlib.NumberTheory.ModularForms.SlashInvariantForms | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} [inst : Γ.HasDetPlusMinusOne] (z : ℤ), ⇑↑z = ↑z | null | true |
RingEquiv.asBoolRingAsBoolAlg | Mathlib.Algebra.Ring.BooleanRing | (α : Type u_4) → [inst : BooleanRing α] → AsBoolRing (AsBoolAlg α) ≃+* α | Ring isomorphism between `α` considered as a Boolean algebra considered as a Boolean ring and
`α`. | true |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.Context.noConfusionType | Lean.Meta.IndPredBelow | Sort u → Lean.Meta.IndPredBelow.Context✝ → Lean.Meta.IndPredBelow.Context✝ → Sort u | null | false |
PNat.instHasAntidiagonal._proof_6 | Mathlib.Algebra.Order.Antidiag.Nat | ∀ {n : ℕ+} (x : ℕ+ × ℕ+),
x ∈
(fun n => Finset.map { toFun := fun x => (⟨(↑x).1, ⋯⟩, ⟨(↑x).2, ⋯⟩), inj' := ⋯ } (↑n).divisorsAntidiagonal.attach)
n ↔
x.1 * x.2 = n | null | false |
_private.Mathlib.Algebra.Order.Group.Multiset.0.Multiset.filter_nsmul._simp_1_2 | Mathlib.Algebra.Order.Group.Multiset | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Multiset α}, (Multiset.filter p s = 0) = ∀ a ∈ s, ¬p a | null | false |
CategoryTheory.MonoidalCategory.Arrow.PullbackHom.isTerminalIso | Mathlib.CategoryTheory.Monoidal.PushoutProduct | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasPullbacks C] →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 : CategoryTheory.MonoidalClosed C] →
(X : CategoryTheory.Arrow C) →
{T : C} →
(t : CategoryTheory.Li... | The arrow isomorphism `(f : A ⟶ B) ⋔ (W ⟶ ⋆) ≅ (B ⟹ W ⟶ A ⟹ W)` in a monoidal closed
category with pullbacks and a terminal object. | true |
instLawfulOfScientificOfCharZero | Mathlib.Data.Rat.Cast.OfScientific | ∀ {K : Type u_1} [inst : Field K] [CharZero K], Lean.Grind.LawfulOfScientific K | null | true |
Int16.neg_one_or | Init.Data.SInt.Bitwise | ∀ {a : Int16}, -1 ||| a = -1 | null | true |
_private.Std.Data.DHashMap.Internal.RawLemmas.0.Std.DHashMap.Internal.Raw₀.getD.eq_1 | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] [inst_2 : Hashable α] (a : α) (fallback : β a)
(size : ℕ) (buckets : Array (Std.DHashMap.Internal.AssocList α β))
(hm : 0 < { size := size, buckets := buckets }.buckets.size),
Std.DHashMap.Internal.Raw₀.getD ⟨{ size := size, buckets := buckets ... | null | true |
Lean.Grind.AC.Seq.erase0 | Init.Grind.AC | Lean.Grind.AC.Seq → Lean.Grind.AC.Seq | null | true |
CategoryTheory.CostructuredArrow.projectQuotient_mk | Mathlib.CategoryTheory.Subobject.Comma | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{S : CategoryTheory.Functor C D} {T : D} [inst_2 : CategoryTheory.Limits.HasFiniteColimits C]
[inst_3 : CategoryTheory.Limits.PreservesFiniteColimits S] {A : CategoryTheory.CostructuredArrow S T}
... | null | true |
CategoryTheory.GrothendieckTopology.Point.Hom.recOn | Mathlib.CategoryTheory.Sites.Point.Category | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{Φ₁ Φ₂ : J.Point} →
{motive : Φ₁.Hom Φ₂ → Sort u_1} →
(t : Φ₁.Hom Φ₂) → ((hom : Φ₂.fiber ⟶ Φ₁.fiber) → motive { hom := hom }) → motive t | null | false |
LipschitzWith.dist | Mathlib.Topology.MetricSpace.Lipschitz | ∀ {α : Type u} [inst : PseudoMetricSpace α], LipschitzWith 2 (Function.uncurry dist) | null | true |
Complex.UnitDisc.sq_norm_lt_one | Mathlib.Analysis.Complex.UnitDisc.Basic | ∀ (z : Complex.UnitDisc), ‖↑z‖ ^ 2 < 1 | null | true |
_private.Mathlib.Algebra.Group.Subgroup.ZPowers.Lemmas.0.Subgroup.finsetSup_zpowers._simp_1_2 | Mathlib.Algebra.Group.Subgroup.ZPowers.Lemmas | ∀ {α : Type u_1} {β : Type u_2} (s : Finset α) (t : α → Set β), ⋃ x ∈ s, t x = ⋃ x ∈ ↑s, t x | null | false |
Set.centralizer_eq_univ | Mathlib.Algebra.Group.Center | ∀ (M : Type u_1) {S : Set M} [inst : CommSemigroup M], S.centralizer = Set.univ | null | true |
_private.Mathlib.Algebra.Central.End.0.LinearEquiv.conjAlgEquiv_ext_iff._simp_1_5 | Mathlib.Algebra.Central.End | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(f g : Module.End R M), f ∘ₗ g = f * g | null | false |
Std.WP.Variant.wfRel | Std.WP.Triple.SpecLemmas | {α : Type uα} →
{Pred : Type u} → [inst : Std.WP.Assertion Pred] → (self : Std.WP.Variant α Pred) → WellFoundedRelation self.γ | The well-founded relation that measure values decrease along. | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_ediv_toInt_nonpos_of_nonpos_of_nonneg._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ) {x : BitVec (w + 1)} {y : BitVec (w + 1)}, 0 ≤ y.toInt → ¬y.toInt = 0 → ¬0 < y.toInt → False | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.