name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.Triangulated.TStructure.triangleLTLTGELT_obj_mor₂ | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryTheory.... | true |
CategoryTheory.HasSubobjectClassifier.χ | Mathlib.CategoryTheory.Subobject.Classifier.Defs | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.HasSubobjectClassifier C] →
{U X : C} → (m : U ⟶ X) → [CategoryTheory.Mono m] → X ⟶ CategoryTheory.HasSubobjectClassifier.Ω C | true |
CategoryTheory.MonoidalCategory.MonoidalRightAction.curriedActionMonoidal._proof_29 | Mathlib.CategoryTheory.Monoidal.Action.End | ∀ {C : Type u_4} {D : Type u_1} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{u_2, u_1} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] (X Y : C),
CategoryTheory.CategoryStruct.comp
{ app := fun x => (Categ... | false |
MeasureTheory.measureReal_inter_add_diff₀ | Mathlib.MeasureTheory.Measure.Real | ∀ {α : Type u_1} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t : Set α},
MeasureTheory.NullMeasurableSet t μ →
autoParam (μ s ≠ ⊤) MeasureTheory.measureReal_inter_add_diff₀._auto_1 → μ.real (s ∩ t) + μ.real (s \ t) = μ.real s | true |
_private.Lean.Meta.Match.MatchEqs.0.Lean.Meta.Match.mkAppDiscrEqs.go._unsafe_rec | Lean.Meta.Match.MatchEqs | Lean.Expr → Array Lean.Expr → ℕ → Lean.Expr → Lean.Expr → ℕ → Lean.MetaM Lean.Expr | false |
SeparationQuotient.liftContinuousMonoidHom._proof_2 | Mathlib.Topology.Algebra.SeparationQuotient.Hom | ∀ {M : Type u_1} {N : Type u_2} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace N] [inst_2 : CommMonoid M]
[inst_3 : ContinuousMul M] [inst_4 : CommMonoid N] (f : M →ₜ* N) (hf : ∀ (x y : M), Inseparable x y → f x = f y)
(q₁ q₂ : Quotient (inseparableSetoid M)),
SeparationQuotient.lift (⇑f) hf (q₁ * q₂) = S... | false |
CategoryTheory.prod.functorProdToProdFunctorAssociator | Mathlib.CategoryTheory.Products.Associator | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(D : Type u₂) →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(E : Type u₃) →
[inst_2 : CategoryTheory.Category.{v₃, u₃} E] →
(A : Type u₄) →
[inst_3 : CategoryTheory.Category.{v₄, u₄} A] →
... | true |
Real.sigmoid_inj | Mathlib.Analysis.SpecialFunctions.Sigmoid | ∀ {a b : ℝ}, a.sigmoid = b.sigmoid ↔ a = b | true |
Submonoid.mem_iSup_prop._simp_2 | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {M : Type u_1} [inst : MulOneClass M] {p : Prop} {S : p → Submonoid M} {x : M},
(x ∈ ⨆ (h : p), S h) = (x = 1 ∨ ∃ (h : p), x ∈ S h) | false |
IsDedekindFiniteMonoid.mk | Mathlib.Algebra.Group.Defs | ∀ {M : Type u_2} [inst : MulOne M], (∀ {a b : M}, a * b = 1 → b * a = 1) → IsDedekindFiniteMonoid M | true |
CategoryTheory.Equivalence.cancel_unit_left | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(e : C ≌ D) {X Y : C} (f f' : e.inverse.obj (e.functor.obj Y) ⟶ X),
CategoryTheory.CategoryStruct.comp (e.unit.app Y) f = CategoryTheory.CategoryStruct.comp (e.unit.app Y) f' ↔ f = f' | true |
summable_unop | Mathlib.Topology.Algebra.InfiniteSum.Constructions | ∀ {α : Type u_1} {β : Type u_2} {L : SummationFilter β} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α]
{f : β → αᵐᵒᵖ}, Summable (fun a => MulOpposite.unop (f a)) L ↔ Summable f L | true |
TensorProduct.AlgebraTensorModule.map | Mathlib.LinearAlgebra.TensorProduct.Tower | {R : Type uR} →
{A : Type uA} →
{M : Type uM} →
{N : Type uN} →
{P : Type uP} →
{Q : Type uQ} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Algebra R A] →
[inst_3 : AddCommMonoid M] →
[inst_4 : ... | true |
Cardinal.ord_lt_omega0._simp_1 | Mathlib.SetTheory.Ordinal.Basic | ∀ {a : Cardinal.{u_1}}, (a.ord < Ordinal.omega0) = (a < Cardinal.aleph0) | false |
CategoryTheory.Grothendieck.grothendieckTypeToCat_inverse_map_base | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (G : CategoryTheory.Functor C (Type w)) {X Y : G.Elements}
(f : X ⟶ Y), ((CategoryTheory.Grothendieck.grothendieckTypeToCat G).inverse.map f).base = ↑f | true |
_private.Mathlib.Topology.UniformSpace.UniformApproximation.0.continuous_of_uniform_approx_of_continuous._simp_1_1 | Mathlib.Topology.UniformSpace.UniformApproximation | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β},
ContinuousOn f Set.univ = Continuous f | false |
CategoryTheory.Idempotents.functorExtension₂CompWhiskeringLeftToKaroubiIso | Mathlib.CategoryTheory.Idempotents.FunctorExtension | (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] →
(CategoryTheory.Idempotents.functorExtension₂ C D).comp
((CategoryTheory.Functor.whiskeringLeft C (CategoryTheory.Idempotents.Karoubi C)
(... | true |
_private.Mathlib.Combinatorics.SimpleGraph.Subgraph.0.SimpleGraph.map_singletonSubgraph._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {a b : Prop}, (a ∧ b ↔ a) = (a → b) | false |
MulSemiringActionHom.polynomial._proof_1 | Mathlib.Algebra.Polynomial.GroupRingAction | ∀ {M : Type u_3} [inst : Monoid M] {P : Type u_2} [inst_1 : CommSemiring P] [inst_2 : MulSemiringAction M P]
{Q : Type u_1} [inst_3 : CommSemiring Q] [inst_4 : MulSemiringAction M Q] (g : P →+*[M] Q) (m : M) (b : P),
Polynomial.map (↑g) (m • Polynomial.C b) = (MonoidHom.id M) m • Polynomial.map (↑g) (Polynomial.C b... | false |
Lean.Meta.ConfigWithKey.noConfusion | Lean.Meta.Basic | {P : Sort u} → {t t' : Lean.Meta.ConfigWithKey} → t = t' → Lean.Meta.ConfigWithKey.noConfusionType P t t' | false |
CochainComplex.HomComplex.Cocycle.fromSingleMk | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.Limits.HasZeroObject C] →
{X : C} →
{K : CochainComplex C ℤ} →
{p q : ℤ} →
(f : X ⟶ K.X q) →
{n : ℤ} →
p... | true |
_private.Mathlib.Analysis.Complex.UpperHalfPlane.Basic.0.UpperHalfPlane.pos_real_smul_injective._simp_1_1 | Mathlib.Analysis.Complex.UpperHalfPlane.Basic | ∀ {x y : UpperHalfPlane}, (x = y) = (↑x = ↑y) | false |
HasStrictFDerivAt.abs_of_pos | Mathlib.Analysis.Calculus.Deriv.Abs | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {f' : StrongDual ℝ E} {x : E},
HasStrictFDerivAt f f' x → 0 < f x → HasStrictFDerivAt (fun x => |f x|) f' x | true |
Std.DHashMap.Internal.Raw₀.get_filter | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α]
[inst_2 : LawfulBEq α] {f : (a : α) → β a → Bool} {k : α} (h : (↑m).WF)
{h' : (Std.DHashMap.Internal.Raw₀.filter f m).contains k = true},
(Std.DHashMap.Internal.Raw₀.filter f m).get k h' = m.get k ⋯ | true |
Lean.Meta.AbstractNestedProofs.Context.noConfusionType | Lean.Meta.AbstractNestedProofs | Sort u → Lean.Meta.AbstractNestedProofs.Context → Lean.Meta.AbstractNestedProofs.Context → Sort u | false |
Std.DTreeMap.Raw.Equiv.union_congr | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ t₃ t₄ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → t₃.WF → t₄.WF → t₁.Equiv t₃ → t₂.Equiv t₄ → (t₁ ∪ t₂).Equiv (t₃ ∪ t₄) | true |
IsPoly.below.mul | Mathlib.NumberTheory.Dioph | ∀ {α : Type u_1} {motive : (a : (α → ℕ) → ℤ) → IsPoly a → Prop} {f g : (α → ℕ) → ℤ} (a : IsPoly f) (a_1 : IsPoly g),
IsPoly.below a → motive f a → IsPoly.below a_1 → motive g a_1 → IsPoly.below ⋯ | true |
Ring.ordFrac._proof_6 | Mathlib.RingTheory.OrderOfVanishing | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : Nontrivial R] [IsNoetherianRing R] [Ring.KrullDimLE 1 R]
(y : ↥(nonZeroDivisors R)), IsUnit ((Ring.ordMonoidWithZeroHom R) ↑y) | false |
WithAbs.ofAbs_inv | Mathlib.Analysis.Normed.Field.WithAbs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring S] [inst_1 : PartialOrder S] [inst_2 : Field R] (v : AbsoluteValue R S)
(x : WithAbs v), x⁻¹.ofAbs = x.ofAbs⁻¹ | true |
_private.Mathlib.Analysis.Calculus.Taylor.0.taylor_tendsto._simp_1_3 | Mathlib.Analysis.Calculus.Taylor | ∀ {E : Type u_5} [inst : NormedAddGroup E] {a : E}, (‖a‖ = 0) = (a = 0) | false |
CategoryTheory.instIsContinuousOverLeftDiscretePUnitIteratedSliceBackwardOver | Mathlib.CategoryTheory.Sites.Over | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C}
(f : CategoryTheory.Over X), f.iteratedSliceBackward.IsContinuous (J.over f.left) ((J.over X).over f) | true |
AddSubsemigroup.instCompleteLattice._proof_10 | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {M : Type u_1} [inst : Add M] (x x_1 : AddSubsemigroup M) (x_2 : M), x_2 ∈ ↑x ∧ x_2 ∈ ↑x_1 → x_2 ∈ ↑x_1 | false |
List.coe_idxInj | Batteries.Data.List.Perm | ∀ {α : Type u_1} [inst : BEq α] [inst_1 : ReflBEq α] {xs ys : List α} {h : xs.Subperm ys} {i : Fin xs.length},
↑(h.idxInj i) = List.idxOfNth xs[i] ys (List.countBefore xs[i] xs ↑i) | true |
cfcₙAux_id | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Instances | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : RCLike 𝕜] [inst_1 : NonUnitalNormedRing A] [inst_2 : StarRing A]
[inst_3 : NormedSpace 𝕜 A] [inst_4 : IsScalarTower 𝕜 A A] [inst_5 : SMulCommClass 𝕜 A A] [inst_6 : StarModule 𝕜 A]
{p : A → Prop} {p₁ : Unitization 𝕜 A → Prop} (hp₁ : ∀ {x : A}, p₁ ↑x ↔ p x) (a : A) (ha :... | true |
Lean.Elab.Term.AsyncBodyInfo.casesOn | Lean.Elab.MutualDef | {motive : Lean.Elab.Term.AsyncBodyInfo → Sort u} → (t : Lean.Elab.Term.AsyncBodyInfo) → motive { } → motive t | false |
_private.Mathlib.Computability.Primrec.List.0.Nat.Primrec'.encode.match_1_1 | Mathlib.Computability.Primrec.List | ∀ (n : ℕ) (motive : List.Vector ℕ n.succ → Prop) (x : List.Vector ℕ n.succ),
(∀ (head : ℕ) (tail : List ℕ) (property : (head :: tail).length = n.succ), motive ⟨head :: tail, property⟩) → motive x | false |
Function.Injective.smulWithZero | Mathlib.Algebra.GroupWithZero.Action.Defs | {M₀ : Type u_2} →
{A : Type u_7} →
{A' : Type u_8} →
[inst : Zero M₀] →
[inst_1 : Zero A] →
[inst_2 : SMulWithZero M₀ A] →
[inst_3 : Zero A'] →
[inst_4 : SMul M₀ A'] →
(f : ZeroHom A' A) →
Function.Injective ⇑f → (∀ (a : M₀) (b : ... | true |
Equiv.Perm.sameCycle_zpow_left._simp_1 | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} {f : Equiv.Perm α} {x y : α} {n : ℤ}, f.SameCycle ((f ^ n) x) y = f.SameCycle x y | false |
CategoryTheory.eHom_whisker_cancel_assoc | Mathlib.CategoryTheory.Enriched.Ordinary.Basic | ∀ (V : Type u') [inst : CategoryTheory.Category.{v', u'} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u}
[inst_2 : CategoryTheory.Category.{v, u} C] [inst_3 : CategoryTheory.EnrichedOrdinaryCategory V C] {X Y Y₁ Z : C}
(α : Y ≅ Y₁) {Z_1 : V} (h : (X ⟶[V] Z) ⟶ Z_1),
CategoryTheory.CategoryStruct.comp
... | true |
WeierstrassCurve.Affine.Point.instAddCommGroup._proof_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {F : Type u_1} [inst : Field F] {W : WeierstrassCurve.Affine F} [inst_1 : DecidableEq F] (x : W.Point),
nsmulBinRec 0 x = 0 | false |
CategoryTheory.Limits.colimit.w_apply | Mathlib.CategoryTheory.ConcreteCategory.Elementwise | ∀ {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] {j j' : J} (f : j ⟶ j')
{F_1 : C → C → Type uF} {carrier : C → Type w} {instFunLike : (X Y : C) → FunLike (F_1 X Y) (car... | true |
LinearMap.toMatrixRight' | Mathlib.LinearAlgebra.Matrix.ToLin | {R : Type u_1} →
[inst : Semiring R] →
{m : Type u_3} → {n : Type u_4} → [Fintype m] → [DecidableEq m] → ((m → R) →ₗ[R] n → R) ≃ₗ[Rᵐᵒᵖ] Matrix m n R | true |
NumberField.mixedEmbedding.norm_nonneg | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (x : NumberField.mixedEmbedding.mixedSpace K),
0 ≤ NumberField.mixedEmbedding.norm x | true |
CategoryTheory.Sheaf.instAdditiveAddCommGrpCatCohomologyFunctor._proof_1 | Mathlib.CategoryTheory.Sites.SheafCohomology.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] (J : CategoryTheory.GrothendieckTopology C)
[inst_1 : CategoryTheory.HasSheafify J AddCommGrpCat]
[inst_2 : CategoryTheory.HasExt (CategoryTheory.Sheaf J AddCommGrpCat)] (n : ℕ),
(CategoryTheory.Sheaf.cohomologyFunctor J n).Additive | false |
MvPowerSeries.constantCoeff_one | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R], MvPowerSeries.constantCoeff 1 = 1 | true |
List.eraseIdx_set_eq | Init.Data.List.Nat.Erase | ∀ {α : Type u_1} {l : List α} {i : ℕ} {a : α}, (l.set i a).eraseIdx i = l.eraseIdx i | true |
Lean.MonadOptions.getOptions | Lean.Data.Options | {m : Type → Type} → [self : Lean.MonadOptions m] → m Lean.Options | true |
Lean.Grind.Field.div_div_left | Init.Grind.Ring.Field | ∀ {α : Type u_1} [inst : Lean.Grind.Field α] {x y z : α}, x / y / z = x / (y * z) | true |
_private.Mathlib.Algebra.GroupWithZero.Associated.0.Associated.of_mul_left.match_1_3 | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] {a b c d : M} (motive : Associated (a * b) (c * d) → Prop)
(h : Associated (a * b) (c * d)), (∀ (u : Mˣ) (hu : a * b * ↑u = c * d), motive ⋯) → motive h | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get_insert_self._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
zpow_le_zpow_left | Mathlib.Algebra.Order.Group.Basic | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : PartialOrder α] [IsOrderedMonoid α] {n : ℤ} {a b : α},
0 ≤ n → a ≤ b → a ^ n ≤ b ^ n | true |
CategoryTheory.Abelian.SpectralObject.spectralSequenceHomologyData_left_π | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | ∀ {C : Type u_1} {ι : Type u_2} {κ : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Abelian C] [inst_2 : Preorder ι] (X : CategoryTheory.Abelian.SpectralObject C ι)
{c : ℤ → ComplexShape κ} {r₀ : ℤ} (data : CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore ι c r₀)
[i... | true |
MeasureTheory.projectiveFamilyFun_empty | Mathlib.MeasureTheory.Constructions.ProjectiveFamilyContent | ∀ {ι : Type u_1} {α : ι → Type u_2} {mα : (i : ι) → MeasurableSpace (α i)}
{P : (J : Finset ι) → MeasureTheory.Measure ((j : ↥J) → α ↑j)},
MeasureTheory.IsProjectiveMeasureFamily P → MeasureTheory.projectiveFamilyFun P ∅ = 0 | true |
continuous_coinduced_dom | Mathlib.Topology.Order | ∀ {α : Type u} {β : Type v} {γ : Type u_1} {f : α → β} {g : β → γ} {t₁ : TopologicalSpace α} {t₂ : TopologicalSpace γ},
Continuous g ↔ Continuous (g ∘ f) | true |
_private.Mathlib.RingTheory.Regular.RegularSequence.0.RingTheory.Sequence.IsWeaklyRegular.recIterModByRegularWithRing.match_1.splitter | Mathlib.RingTheory.Regular.RegularSequence | (α : Type u_1) →
(x : CommRing α) →
(M : Type u_2) →
(x_1 : AddCommGroup M) →
(x_2 : Module α M) →
(r : α) →
(rs : List α) →
(motive :
IsSMulRegular M r ∧
RingTheory.Sequence.IsWeaklyRegular (QuotSMulTop r M)
... | true |
Vector.pmap_push._proof_3 | Init.Data.Vector.Attach | ∀ {α : Type u_1} {n : ℕ} {a : α} {xs : Vector α n}, a ∈ xs.push a | false |
nhdsSet_Ico | Mathlib.Topology.Order.NhdsSet | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [OrderClosedTopology α] {a b : α},
a < b → nhdsSet (Set.Ico a b) = nhds a ⊔ Filter.principal (Set.Ioo a b) | true |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.getParamKinds._sparseCasesOn_1 | Lean.PrettyPrinter.Delaborator.Builtins | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
(Nat.hasNotBit 128 t.ctorIdx → motive t) → motive t | false |
AddAction.isInvariantBlock_iff_isFixedBlock | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} [inst : AddGroup G] {X : Type u_2} [inst_1 : AddAction G X] {B : Set X},
AddAction.IsInvariantBlock G B ↔ AddAction.IsFixedBlock G B | true |
CategoryTheory.Limits.cokernel.ofIsoComp | Mathlib.CategoryTheory.Limits.Shapes.Kernels | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{X Y : C} →
(f : X ⟶ Y) →
[inst_2 : CategoryTheory.Limits.HasCokernel f] →
{Z : C} →
(l : Z ⟶ Y) →
(i : X ≅ Z) →
(h :... | true |
Topology.IsOpenEmbedding.sheafPullbackIso | Mathlib.Topology.Sheaves.Functors | {X Y : TopCat} →
(A : Type u_1) →
[inst : CategoryTheory.Category.{w, u_1} A] →
{f : X ⟶ Y} →
(hf : Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom f)) →
{FA : A → A → Type u_2} →
{CA : A → Type w} →
[inst_1 : (X Y : A) → FunLike (FA X Y) (CA X) (CA... | true |
Real.isTheta_exp_comp_exp_comp._simp_1 | Mathlib.Analysis.SpecialFunctions.Exp | ∀ {α : Type u_1} {l : Filter α} {f g : α → ℝ},
((fun x => Real.exp (f x)) =Θ[l] fun x => Real.exp (g x)) =
Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) l fun x => |f x - g x| | false |
Lean.RBTree.instRepr | Lean.Data.RBTree | {α : Type u} → {cmp : α → α → Ordering} → [Repr α] → Repr (Lean.RBTree α cmp) | true |
hasDerivWithinAt_iff_tendsto | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜} {s : Set 𝕜},
HasDerivWithinAt f f' s x ↔
Filter.Tendsto (fun x' => ‖x' - x‖⁻¹ * ‖f x' - f x - (x' - x) • f'‖) (nhdsWithin x s) (nhds 0) | true |
Ring.instFaithfulSMulSubtypeAlgebraicClosureFractionRingMemIntermediateFieldNormalClosure | Mathlib.RingTheory.NormalClosure | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : IsDomain R] [inst_3 : IsDomain S]
[inst_4 : Algebra R S] [inst_5 : Module.IsTorsionFree R S],
FaithfulSMul S
↥(IntermediateField.normalClosure (FractionRing R) (FractionRing S) (AlgebraicClosure (FractionRing S))) | true |
String.Slice.Subslice.extendLeft_extendLeft._proof_1 | Init.Data.String.Subslice | ∀ {s : String.Slice} {sl : s.Subslice} (p₁ p₂ : s.Pos) (h₂ : p₂ ≤ sl.startInclusive),
p₁ ≤ (sl.extendLeft p₂ h₂).startInclusive → p₁ ≤ sl.startInclusive | false |
Submonoid.PowSaturated.eq_1 | Mathlib.GroupTheory.Subgroup.Saturated | ∀ {G : Type u_1} [inst : Monoid G] (H : Submonoid G), H.PowSaturated = ∀ ⦃n : ℕ⦄ ⦃g : G⦄, g ^ n ∈ H → n = 0 ∨ g ∈ H | true |
CategoryTheory.Abelian.SpectralObject.SpectralSequence.HomologyData.ccSc_X₁ | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | ∀ {C : Type u_1} {ι : Type u_2} {κ : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Abelian C] [inst_2 : Preorder ι] (X : CategoryTheory.Abelian.SpectralObject C ι)
{c : ℤ → ComplexShape κ} {r₀ : ℤ} (data : CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore ι c r₀)
(r... | true |
Finset.le_inf_mul | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Mul α] {β : Type u_5} [inst_2 : SemilatticeInf β]
[inst_3 : OrderTop β] {s t : Finset α} {f : α → β} {a : β}, a ≤ (s * t).inf f ↔ ∀ x ∈ s, ∀ y ∈ t, a ≤ f (x * y) | true |
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.DTreeMap.Internal.Impl.link2.match_5.splitter | Std.Data.DTreeMap.Internal.WF.Lemmas | {α : Type u_1} →
{β : α → Type u_2} →
(motive : (r : Std.DTreeMap.Internal.Impl α β) → r.Balanced → Sort u_3) →
(r : Std.DTreeMap.Internal.Impl α β) →
(hr : r.Balanced) →
((hr : Std.DTreeMap.Internal.Impl.leaf.Balanced) →
r = Std.DTreeMap.Internal.Impl.leaf → motive Std.DTree... | true |
Matrix.nonUnitalNonAssocRing._proof_2 | Mathlib.Data.Matrix.Mul | ∀ {n : Type u_1} {α : Type u_2} [inst : NonUnitalNonAssocRing α] (a : Matrix n n α), SubNegMonoid.zsmul 0 a = 0 | false |
_private.Mathlib.Combinatorics.Matroid.Sum.0.Matroid.sum_indep_iff._simp_1_3 | Mathlib.Combinatorics.Matroid.Sum | ∀ {p : Bool → Prop}, (∀ (b : Bool), p b) = (p false ∧ p true) | false |
Homotopy.smul._proof_1 | 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 : HomologicalComplex V c} {f g : C ⟶ D} {R : Type u_4} [inst_2 : Semiring R]
[inst_3 : CategoryTheory.Linear R V] (h : Homotopy f g) (a : R) (i j : ι), ¬c.Rel j i → a • h.h... | false |
VectorPrebundle.contMDiffVectorBundle | Mathlib.Geometry.Manifold.VectorBundle.Basic | ∀ {n : WithTop ℕ∞} {𝕜 : Type u_1} {B : Type u_2} {F : Type u_4} {E : B → Type u_6} [inst : NontriviallyNormedField 𝕜]
{EB : Type u_7} [inst_1 : NormedAddCommGroup EB] [inst_2 : NormedSpace 𝕜 EB] {HB : Type u_8}
[inst_3 : TopologicalSpace HB] (IB : ModelWithCorners 𝕜 EB HB) [inst_4 : TopologicalSpace B]
[inst_... | true |
_private.Mathlib.RingTheory.Ideal.NatInt.0.Nat.one_mem_span_iff._simp_1_2 | Mathlib.RingTheory.Ideal.NatInt | ∀ {α : Type u_1} {a : α} {s : Set α}, (a ∈ s) = ({a} ⊆ s) | false |
String.Slice.Pattern.ForwardSliceSearcher.emptyBefore.elim | Init.Data.String.Pattern.String | {s : String.Slice} →
{motive : String.Slice.Pattern.ForwardSliceSearcher s → Sort u} →
(t : String.Slice.Pattern.ForwardSliceSearcher s) →
t.ctorIdx = 0 → ((pos : s.Pos) → motive (String.Slice.Pattern.ForwardSliceSearcher.emptyBefore pos)) → motive t | false |
instMulActionElemFixedPointsSubtypeMemSubgroupOfNormal._proof_3 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {G : Type u_2} [inst : Group G] {α : Type u_1} [inst_1 : MulAction G α] {H : Subgroup G} (_x_1 : H.Normal) (x y : G)
(b : ↑(MulAction.fixedPoints (↥H) α)), (x * y) • b = x • y • b | false |
FirstOrder.Language.BoundedFormula.castLE.eq_1 | Mathlib.ModelTheory.Syntax | ∀ {L : FirstOrder.Language} {α : Type u'} (x x_1 : ℕ) (x_2 : x ≤ x_1),
FirstOrder.Language.BoundedFormula.castLE x_2 FirstOrder.Language.BoundedFormula.falsum =
FirstOrder.Language.BoundedFormula.falsum | true |
Multiset.singleton_join | Mathlib.Data.Multiset.Bind | ∀ {α : Type u_1} (a : Multiset α), {a}.join = a | true |
CategoryTheory.Functor.mapAddGrpFunctor | Mathlib.CategoryTheory.Monoidal.Grp_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.CartesianMonoidalCategory D] →
CategoryTheory.Functor (C ⥤ₗ D) (Categor... | true |
UniformSpace.Completion.instAddActionOfUniformContinuousConstVAdd._proof_2 | Mathlib.Topology.Algebra.UniformMulAction | ∀ (M : Type u_2) (X : Type u_1) [inst : UniformSpace X] [inst_1 : AddMonoid M] [inst_2 : AddAction M X]
[UniformContinuousConstVAdd M X] (a : X), 0 +ᵥ ↑a = ↑a | false |
εNFA.isPath_singleton | Mathlib.Computability.EpsilonNFA | ∀ {α : Type u} {σ : Type v} (M : εNFA α σ) {s t : σ} {a : Option α}, M.IsPath s t [a] ↔ t ∈ M.step s a | true |
FirstOrder.Language.BoundedFormula.relabelAux | Mathlib.ModelTheory.Syntax | {α : Type u'} → {β : Type v'} → {n : ℕ} → (α → β ⊕ Fin n) → (k : ℕ) → α ⊕ Fin k → β ⊕ Fin (n + k) | true |
Nat.digitChar_eq_a._simp_1 | Init.Data.Nat.ToString | ∀ {n : ℕ}, (n.digitChar = 'a') = (n = 10) | false |
SimpleGraph.bipartiteDoubleCover | Mathlib.Combinatorics.SimpleGraph.Bipartite | {V : Type u_1} → SimpleGraph V → SimpleGraph (V ⊕ V) | true |
Topology.WithUpper.instInhabited | Mathlib.Topology.Order.LowerUpperTopology | {α : Type u_1} → [Inhabited α] → Inhabited (Topology.WithUpper α) | true |
instInhabitedList | Init.Prelude | {α : Type u_1} → Inhabited (List α) | true |
CategoryTheory.Limits.Cofan.IsColimit.fac | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {β : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : β → C} {c : CategoryTheory.Limits.Cofan F}
(hc : CategoryTheory.Limits.IsColimit c) {A : C} (f : (i : β) → F i ⟶ A) (i : β),
CategoryTheory.CategoryStruct.comp (c.inj i) (CategoryTheory.Limits.Cofan.IsColimit.desc hc f) = f i | true |
_private.Mathlib.MeasureTheory.Integral.CircleTransform.0.Complex.norm_circleTransformBoundingFunction_le._simp_1_1 | Mathlib.MeasureTheory.Integral.CircleTransform | ∀ {α : Type u} {β : Type v} [inst : Preorder β] {f : α → β} {s : Set α} {a : α}, IsMaxOn f s a = ∀ x ∈ s, f x ≤ f a | false |
IntermediateField.relrank_eq_one_iff | Mathlib.FieldTheory.Relrank | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {A B : IntermediateField F E},
A.relrank B = 1 ↔ B ≤ A | true |
PLift.down | Init.Prelude | {α : Sort u} → PLift α → α | true |
DFA.instInhabited | Mathlib.Computability.DFA | {α : Type u} → {σ : Type v} → [Inhabited σ] → Inhabited (DFA α σ) | true |
CategoryTheory.ShortComplex.SnakeInput.w₁₃ | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(self : CategoryTheory.ShortComplex.SnakeInput C), CategoryTheory.CategoryStruct.comp self.v₁₂ self.v₂₃ = 0 | true |
Finset.biUnion_op_smul_finset | Mathlib.Algebra.Group.Action.Pointwise.Finset | ∀ {α : Type u_2} [inst : Mul α] [inst_1 : DecidableEq α] (s t : Finset α),
(t.biUnion fun a => MulOpposite.op a • s) = s * t | true |
Ordering.ctorElimType | Init.Data.Ord.Basic | {motive : Ordering → Sort u} → ℕ → Sort (max 1 u) | false |
upperCentralSeriesAux._proof_2 | Mathlib.GroupTheory.Nilpotent | ∀ (G : Type u_1) [inst : Group G] (n : ℕ), (upperCentralSeriesAux G n).fst.Characteristic | false |
AddGrpCat.noConfusion | Mathlib.Algebra.Category.Grp.Basic | {P : Sort u_1} → {t t' : AddGrpCat} → t = t' → AddGrpCat.noConfusionType P t t' | false |
ProbabilityTheory.Kernel.partialTraj_le | Mathlib.Probability.Kernel.IonescuTulcea.PartialTraj | ∀ {X : ℕ → Type u_1} {mX : (n : ℕ) → MeasurableSpace (X n)} {a b : ℕ}
{κ : (n : ℕ) → ProbabilityTheory.Kernel ((i : ↥(Finset.Iic n)) → X ↑i) (X (n + 1))} (hba : b ≤ a),
ProbabilityTheory.Kernel.partialTraj κ a b = ProbabilityTheory.Kernel.deterministic (Preorder.frestrictLe₂ hba) ⋯ | true |
NumberField.mixedEmbedding.fundamentalCone.preimageOfMemIntegerSet._proof_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K]
(a : ↑(NumberField.mixedEmbedding.fundamentalCone.integerSet K)), ∃ x, (NumberField.mixedEmbedding K) ↑x = ↑a | false |
Std.DTreeMap.Internal.Impl.link._proof_18 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (szl : ℕ) (k' : α) (v' : β k') (l' r' : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner szl k' v' l' r').Balanced →
∀ (szr : ℕ) (k'' : α) (v'' : β k'') (l'' r'' : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner szr k'' v'' l'' r'').Ba... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.