name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
DifferentiableAt.fun_neg | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : 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] {f : E → F}
{x : E}, DifferentiableAt 𝕜 f x → DifferentiableAt 𝕜 (fun i => -f i) x | true |
MeasureTheory.Filtration.definition._proof_2._@.Mathlib.Probability.Process.Filtration.205586839._hygCtx._hyg.8 | Mathlib.Probability.Process.Filtration | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} [inst : PartialOrder ι] (𝓕 : MeasureTheory.Filtration ι m)
(i j : ι),
i ≤ j →
(fun i => if (nhdsWithin i (Set.Ioi i)).NeBot then ⨅ j, ⨅ (_ : j > i), ↑𝓕 j else ↑𝓕 i) i ≤
(fun i => if (nhdsWithin i (Set.Ioi i)).NeBot then ⨅ j, ⨅ (_ : j > i), ↑𝓕 j e... | false |
nsmul_le_nsmul_iff_right | Mathlib.Algebra.Order.Monoid.Unbundled.Pow | ∀ {M : Type u_3} [inst : AddMonoid M] [inst_1 : LinearOrder M] [AddLeftStrictMono M] [AddRightStrictMono M] {a b : M}
{n : ℕ}, n ≠ 0 → (n • a ≤ n • b ↔ a ≤ b) | true |
_private.Mathlib.Combinatorics.Young.YoungDiagram.0.YoungDiagram.rowLens_length_ofRowLens._simp_1_6 | Mathlib.Combinatorics.Young.YoungDiagram | ∀ {a : Prop}, (¬¬a) = a | false |
Filter.Tendsto.enorm' | Mathlib.Analysis.Normed.Group.Continuity | ∀ {α : Type u_1} {E : Type u_4} [inst : TopologicalSpace E] [inst_1 : ContinuousENorm E] {a : E} {l : Filter α}
{f : α → E}, Filter.Tendsto f l (nhds a) → Filter.Tendsto (fun x => ‖f x‖ₑ) l (nhds ‖a‖ₑ) | true |
NNReal.rpow_rpow_inv | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {y : ℝ}, y ≠ 0 → ∀ (x : NNReal), (x ^ y) ^ y⁻¹ = x | true |
CategoryTheory.Triangulated.TStructure.π_truncGTIsoTruncGE_hom_ι_app_assoc | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} 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 : CategoryT... | true |
VectorField.mpullback_neg | Mathlib.Geometry.Manifold.VectorField.Pullback | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {H' : Type u_5} [inst_6 : TopologicalSp... | true |
Matrix.piLinearEquiv._proof_1 | Mathlib.Data.Matrix.Basic | ∀ {m : Type u_1} {n : Type u_2} {ι : Type u_3} {β : ι → Type u_4} [inst : (i : ι) → AddCommMonoid (β i)]
(x y : Matrix m n ((i : ι) → β i)),
Matrix.piAddEquiv.toFun (x + y) = Matrix.piAddEquiv.toFun x + Matrix.piAddEquiv.toFun y | false |
WithZero.toMulBot_lt | Mathlib.Algebra.Order.Monoid.ToMulBot | ∀ {α : Type u} [inst : Add α] [inst_1 : Preorder α] (a b : WithZero (Multiplicative α)),
WithZero.toMulBot a < WithZero.toMulBot b ↔ a < b | true |
Lean.AddErrorMessageContext.mk._flat_ctor | Lean.Exception | {m : Type → Type} →
(Lean.Syntax → Lean.MessageData → m (Lean.Syntax × Lean.MessageData)) → Lean.AddErrorMessageContext m | false |
Std.Roc.toList.congr_simp | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LE α] [inst_1 : DecidableLE α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [inst_4 : Std.Rxc.IsAlwaysFinite α] (r r_1 : Std.Roc α),
r = r_1 → r.toList = r_1.toList | true |
_private.Init.Data.Nat.Basic.0.Nat.succ_pred_eq_of_pos.match_1_1 | Init.Data.Nat.Basic | ∀ (motive : (x : ℕ) → 0 < x → Prop) (x : ℕ) (x_1 : 0 < x), (∀ (n : ℕ) (x : 0 < n + 1), motive n.succ x) → motive x x_1 | false |
AlgebraicGeometry.Scheme.instOverCoverOfIsIsoOfIsOver | Mathlib.AlgebraicGeometry.Cover.Over | {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
(S : AlgebraicGeometry.Scheme) →
[inst : P.IsStableUnderBaseChange] →
[inst_1 : AlgebraicGeometry.Scheme.IsJointlySurjectivePreserving P] →
[inst_2 : P.ContainsIdentities] →
[inst_3 : P.RespectsIso] →
{X Y : Algeb... | true |
CategoryTheory.Functor.CorepresentableBy.homEquiv_comp._autoParam | Mathlib.CategoryTheory.Yoneda | Lean.Syntax | false |
Nat.instCeilDiv._proof_2 | Mathlib.Algebra.Order.Floor.Div | ∀ a ≤ 0, ∀ (b : ℕ), (b + a - 1) / a = 0 | false |
Dyadic.instLT | Init.Data.Dyadic.Basic | LT Dyadic | true |
Matrix.SpecialLinearGroup.coe_mk | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] (A : Matrix n n R)
(h : A.det = 1), ↑⟨A, h⟩ = A | true |
_private.Mathlib.LinearAlgebra.RootSystem.Base.0.RootPairing.Base.eq_one_or_neg_one_of_mem_support_of_smul_mem._simp_1_1 | Mathlib.LinearAlgebra.RootSystem.Base | ∀ {G : Type u_3} [inst : InvolutiveNeg G] {a b : G}, (-a = b) = (a = -b) | false |
CategoryTheory.InjectiveResolution.desc._proof_2 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {Y Z : C}
(I : CategoryTheory.InjectiveResolution Y) (J : CategoryTheory.InjectiveResolution Z) (n : ℕ)
(g : J.cocomplex.X n ⟶ I.cocomplex.X n) (g' : J.cocomplex.X (n + 1) ⟶ I.cocomplex.X (n + 1)),
CategoryTheory.Ca... | false |
UInt32.mod_lt | Init.Data.UInt.Lemmas | ∀ (a : UInt32) {b : UInt32}, 0 < b → a % b < b | true |
_private.Mathlib.RingTheory.PicardGroup.0.Submodule.ker_unitsToPic._simp_1_7 | Mathlib.RingTheory.PicardGroup | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x y : M},
(x ∈ R ∙ y) = ∃ a, a • y = x | false |
NonUnitalNonAssocCommSemiring.toCommMagma | Mathlib.Algebra.Ring.Defs | {α : Type u} → [self : NonUnitalNonAssocCommSemiring α] → CommMagma α | true |
_private.Mathlib.Tactic.Positivity.Core.0.Mathlib.Meta.Positivity.pos_of_isNNRat.match_1_1 | Mathlib.Tactic.Positivity.Core | ∀ {A : Type u_1} {e : A} {n d : ℕ} [inst : Semiring A]
(motive : Mathlib.Meta.NormNum.IsNNRat e n d → decide (0 < n) = true → Prop) (x : Mathlib.Meta.NormNum.IsNNRat e n d)
(x_1 : decide (0 < n) = true),
(∀ (inv : Invertible ↑d) (eq : e = ↑n * ⅟↑d) (h : decide (0 < n) = true), motive ⋯ h) → motive x x_1 | false |
_private.Mathlib.Order.ScottContinuity.Prod.0.ScottContinuous.fromProd._simp_1_1 | Mathlib.Order.ScottContinuity.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
ScottContinuous f = ScottContinuousOn Set.univ f | false |
MonoidAlgebra.singleAddHom.eq_1 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] (m : M),
MonoidAlgebra.singleAddHom m = { toFun := MonoidAlgebra.single m, map_zero' := ⋯, map_add' := ⋯ } | true |
AddMonCat.noConfusionType | Mathlib.Algebra.Category.MonCat.Basic | Sort u_1 → AddMonCat → AddMonCat → Sort u_1 | false |
Quandle.instDihedral._proof_2 | Mathlib.Algebra.Quandle | ∀ (n : ℕ) {x y z : Quandle.Dihedral n},
Quandle.dihedralAct n x (Quandle.dihedralAct n y z) =
Quandle.dihedralAct n (Quandle.dihedralAct n x y) (Quandle.dihedralAct n x z) | false |
CategoryTheory.Over.prodComparisonIso_pullback_inv_left_fst_fst | Mathlib.CategoryTheory.Monoidal.Cartesian.Over | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {X Y : C}
(f : X ⟶ Y) (A B : CategoryTheory.Over Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CartesianMonoidalCategory.prodComparisonIso (CategoryTheory.Over.pullback f) A B).inv.left
... | true |
Mathlib.Tactic.BicategoryLike.WhiskerRight.of.noConfusion | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {P : Sort u} →
{η η' : Mathlib.Tactic.BicategoryLike.Atom} →
Mathlib.Tactic.BicategoryLike.WhiskerRight.of η = Mathlib.Tactic.BicategoryLike.WhiskerRight.of η' →
(η = η' → P) → P | false |
WellFoundedLT.conditionallyCompleteLinearOrderBot._proof_5 | Mathlib.Order.ConditionallyCompleteLattice.Defs | ∀ (α : Type u_1) [i₁ : LinearOrder α] (a b : α), a ≤ SemilatticeSup.sup a b | false |
Equiv.pnatEquivNat | Mathlib.Data.PNat.Equiv | ℕ+ ≃ ℕ | true |
CompositionAsSet.ext | Mathlib.Combinatorics.Enumerative.Composition | ∀ {n : ℕ} {x y : CompositionAsSet n}, x.boundaries = y.boundaries → x = y | true |
LinearIsometryEquiv.submoduleMap._proof_1 | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} [inst : Ring R] [inst_1 : Ring R₂] {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R}
{re₁₂ : RingHomInvPair σ₁₂ σ₂₁}, RingHomSurjective σ₁₂ | false |
IsStronglyAtomic.mk._flat_ctor | Mathlib.Order.Atoms | ∀ {α : Type u_5} [inst : Preorder α], (∀ (a b : α), a < b → ∃ x, a ⋖ x ∧ x ≤ b) → IsStronglyAtomic α | false |
List.mem_eraseDups | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a : α} {l : List α}, a ∈ l.eraseDups ↔ a ∈ l | true |
CategoryTheory.GrothendieckTopology.diagram | Mathlib.CategoryTheory.Sites.Plus | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(J : CategoryTheory.GrothendieckTopology C) →
{D : Type w} →
[inst_1 : CategoryTheory.Category.{w', w} D] →
[∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X),
CategoryTheory.Limits.HasMultiequalizer (S.i... | true |
instZeroColex.eq_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [h : Zero α], instZeroColex = h | true |
RingTheory.Sequence.IsRegular.of_faithfullyFlat_of_isBaseChange | Mathlib.RingTheory.Regular.Flat | ∀ {R : Type u_1} {S : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : AddCommGroup N] [inst_6 : Module R N]
[inst_7 : Module S N] [inst_8 : IsScalarTower R S N] [Module.FaithfullyFlat R S] {f : M →ₗ[R]... | true |
Std.HashMap.keys_map | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} {f : α → β → γ},
(Std.HashMap.map f m).keys.Perm m.keys | true |
_private.Mathlib.Analysis.Complex.MeanValue.0.circleAverage_sub_sub_inv_smul_of_differentiable_on_off_countable._simp_1_14 | Mathlib.Analysis.Complex.MeanValue | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | false |
MeasureTheory.«_aux_Mathlib_MeasureTheory_Integral_Bochner_Basic___delab_app_MeasureTheory_term∫_,_∂__1» | Mathlib.MeasureTheory.Integral.Bochner.Basic | Lean.PrettyPrinter.Delaborator.Delab | false |
RelIso._sizeOf_1 | Mathlib.Order.RelIso.Basic | {α : Type u_5} →
{β : Type u_6} →
{r : α → α → Prop} →
{s : β → β → Prop} →
[SizeOf α] → [SizeOf β] → [(a a_1 : α) → SizeOf (r a a_1)] → [(a a_1 : β) → SizeOf (s a a_1)] → r ≃r s → ℕ | false |
Aesop.VariableMap.stats | Aesop.Forward.State | Aesop.VariableMap → Array Aesop.ForwardInstantiationStats | true |
_private.Mathlib.NumberTheory.Cyclotomic.PrimitiveRoots.0.IsPrimitiveRoot.norm_pow_sub_one_of_prime_pow_ne_two._proof_1_1 | Mathlib.NumberTheory.Cyclotomic.PrimitiveRoots | ∀ {k s : ℕ}, k - s + 1 ≤ k + 1 | false |
MeasureTheory.lmarginal.eq_1 | Mathlib.MeasureTheory.Integral.Marginal | ∀ {δ : Type u_1} {X : δ → Type u_3} [inst : (i : δ) → MeasurableSpace (X i)] [inst_1 : DecidableEq δ]
(μ : (i : δ) → MeasureTheory.Measure (X i)) (s : Finset δ) (f : ((i : δ) → X i) → ENNReal) (x : (i : δ) → X i),
(∫⋯∫⁻_s, f ∂μ) x = ∫⁻ (y : (i : ↥s) → X ↑i), f (Function.updateFinset x s y) ∂MeasureTheory.Measure.pi... | true |
Lean.Meta.ExtractLets.withEnsuringDeclsInContext | Lean.Meta.Tactic.Lets | {m : Type → Type} →
{α : Type} →
[Monad m] → [MonadControlT Lean.MetaM m] → [Lean.MonadLCtx m] → Array Lean.Meta.ExtractLets.LocalDecl' → m α → m α | true |
Ideal.cotangentEquivIdeal_apply | Mathlib.RingTheory.Ideal.Cotangent | ∀ {R : Type u} [inst : CommRing R] (I : Ideal R) (x : I.Cotangent),
↑(I.cotangentEquivIdeal x) = I.cotangentToQuotientSquare x | true |
Aesop.Nanos.instOfNat | Aesop.Nanos | {n : ℕ} → OfNat Aesop.Nanos n | true |
Lean.Parser.Term.show.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | true |
_private.Mathlib.Order.Fin.Tuple.0.Fin.insertNth_mem_Icc._simp_1_1 | Mathlib.Order.Fin.Tuple | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Icc a b) = (a ≤ x ∧ x ≤ b) | false |
Lean.Parser.Term.typeOf._regBuiltin.Lean.Parser.Term.typeOf.formatter_7 | Lean.Parser.Term | IO Unit | false |
_private.Mathlib.RingTheory.IsPrimary.0.Submodule.IsPrimary.isPrime_radical_colon._simp_1_5 | Mathlib.RingTheory.IsPrimary | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Submodule R M}
{S : Set M} {r : R}, (r ∈ N.colon S) = ∀ s ∈ S, r • s ∈ N | false |
SymmetricPower.smul'._proof_3 | Mathlib.LinearAlgebra.TensorPower.Symmetric | ∀ {R : Type u_1} (ι : Type u_1) [inst : CommSemiring R] (M : Type u_2) [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(r : R) (b₁ b₂ : PiTensorProduct R fun x => M), r • (b₁ + b₂) = r • b₁ + r • b₂ | false |
List.IsChain.two_mul_count_bool_eq_ite | Mathlib.Data.Bool.Count | ∀ {l : List Bool},
List.IsChain (fun x1 x2 => x1 ≠ x2) l →
∀ (b : Bool),
2 * List.count b l =
if Even l.length then l.length else if (some b == l.head?) = true then l.length + 1 else l.length - 1 | true |
CategoryTheory.Limits.CategoricalPullback.«_aux_Mathlib_CategoryTheory_Limits_Shapes_Pullback_Categorical_Basic___macroRules_CategoryTheory_Limits_CategoricalPullback_term_⊡__1» | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | Lean.Macro | false |
RingCon.factorₐ | Mathlib.RingTheory.Congruence.Hom | {M : Type u_1} →
(R : Type u_4) →
[inst : CommSemiring R] →
[inst_1 : Semiring M] → [inst_2 : Algebra R M] → {c d : RingCon M} → c ≤ d → c.Quotient →ₐ[R] d.Quotient | true |
Subfield.coe_add | Mathlib.Algebra.Field.Subfield.Defs | ∀ {K : Type u} [inst : DivisionRing K] (s : Subfield K) (x y : ↥s), ↑(x + y) = ↑x + ↑y | true |
_private.Mathlib.Computability.PartrecCode.0.Nat.Partrec.Code.encodeCode.match_1.eq_3 | Mathlib.Computability.PartrecCode | ∀ (motive : Nat.Partrec.Code → Sort u_1) (h_1 : Unit → motive Nat.Partrec.Code.zero)
(h_2 : Unit → motive Nat.Partrec.Code.succ) (h_3 : Unit → motive Nat.Partrec.Code.left)
(h_4 : Unit → motive Nat.Partrec.Code.right) (h_5 : (cf cg : Nat.Partrec.Code) → motive (cf.pair cg))
(h_6 : (cf cg : Nat.Partrec.Code) → mot... | true |
AddSubgroup.casesOn | Mathlib.Algebra.Group.Subgroup.Defs | {G : Type u_3} →
[inst : AddGroup G] →
{motive : AddSubgroup G → Sort u} →
(t : AddSubgroup G) →
((toAddSubmonoid : AddSubmonoid G) →
(neg_mem' : ∀ {x : G}, x ∈ toAddSubmonoid.carrier → -x ∈ toAddSubmonoid.carrier) →
motive { toAddSubmonoid := toAddSubmonoid, neg_mem' := ne... | false |
FractionalIdeal.spanSingleton_def | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_5} [inst : CommRing R] (S : Submonoid R) {P : Type u_6} [inst_1 : CommRing P] [inst_2 : Algebra R P]
[inst_3 : IsLocalization S P] (x : P), FractionalIdeal.spanSingleton S x = ⟨R ∙ x, ⋯⟩ | true |
implies_congr_left | Init.SimpLemmas | ∀ {p₁ p₂ : Sort u} {q : Sort v}, p₁ = p₂ → (p₁ → q) = (p₂ → q) | true |
LinearAlgebra.FreeProduct.identify_one | Mathlib.LinearAlgebra.FreeProduct.Basic | ∀ {I : Type u} [inst : DecidableEq I] (R : Type v) [inst_1 : CommSemiring R] (A : I → Type w)
[inst_2 : (i : I) → Semiring (A i)] [inst_3 : (i : I) → Algebra R (A i)] (i : I),
(LinearAlgebra.FreeProduct.ι' R A) ((DirectSum.lof R I A i) 1) = 1 | true |
AffineSubspace.comap_map_eq_of_injective | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {k : Type u_1} {V₁ : Type u_2} {P₁ : Type u_3} {V₂ : Type u_4} {P₂ : Type u_5} [inst : Ring k]
[inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁] [inst_3 : AddTorsor V₁ P₁] [inst_4 : AddCommGroup V₂]
[inst_5 : Module k V₂] [inst_6 : AddTorsor V₂ P₂] {f : P₁ →ᵃ[k] P₂},
Function.Injective ⇑f → ∀ (s : AffineSubspac... | true |
Ideal.le_comap_mul | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : FunLike F R S]
[rc : RingHomClass F R S] (f : F) {K L : Ideal S}, Ideal.comap f K * Ideal.comap f L ≤ Ideal.comap f (K * L) | true |
NumberField.house_prod_le | Mathlib.NumberTheory.NumberField.House | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (s : Finset K),
NumberField.house (∏ x ∈ s, x) ≤ ∏ x ∈ s, NumberField.house x | true |
affineSpan_mono | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {s₁ s₂ : Set P}, s₁ ⊆ s₂ → affineSpan k s₁ ≤ affineSpan k s₂ | true |
AlgEquiv.Algebra.isSeparable_iff | Mathlib.FieldTheory.Separable | ∀ {F : Type u_1} {K : Type u_3} [inst : CommRing F] [inst_1 : Ring K] [inst_2 : Algebra F K] {E : Type u_4}
[inst_3 : Ring E] [inst_4 : Algebra F E] (e : K ≃ₐ[F] E), Algebra.IsSeparable F K ↔ Algebra.IsSeparable F E | true |
Real.sin_nonneg_of_nonneg_of_le_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ {x : ℝ}, 0 ≤ x → x ≤ Real.pi → 0 ≤ Real.sin x | true |
CategoryTheory.Abelian.Ext.bilinearCompOfLinear._proof_3 | Mathlib.Algebra.Homology.DerivedCategory.Ext.Linear | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] (R : Type u_1) [inst_3 : CommRing R] [inst_4 : CategoryTheory.Linear R C] (X Z : C)
(c : ℕ), SMulCommClass R R (CategoryTheory.Abelian.Ext X Z c) | false |
AddCommGrpCat.Colimits.toCocone_pt_coe | Mathlib.Algebra.Category.Grp.Colimits | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] (F : CategoryTheory.Functor J AddCommGrpCat)
[inst_1 : DecidableEq J] {A : Type w} [inst_2 : AddCommGroup A] (f : AddCommGrpCat.Colimits.Quot F →+ A),
↑(AddCommGrpCat.Colimits.toCocone F f).pt = A | true |
MeasureTheory.measureReal_union_add_inter₀ | Mathlib.MeasureTheory.Measure.Real | ∀ {α : Type u_1} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t : Set α},
MeasureTheory.NullMeasurableSet t μ →
autoParam (μ s ≠ ⊤) MeasureTheory.measureReal_union_add_inter₀._auto_1 →
autoParam (μ t ≠ ⊤) MeasureTheory.measureReal_union_add_inter₀._auto_3 →
μ.real (s ∪ t) + μ.real (s ∩ t... | true |
List.forall_mem_map | Init.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l : List α} {P : β → Prop}, (∀ i ∈ List.map f l, P i) ↔ ∀ j ∈ l, P (f j) | true |
CategoryTheory.Limits.pushoutIsoUnopPullback | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Pullbacks | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y Z : C} →
(f : X ⟶ Z) →
(g : X ⟶ Y) →
[h : CategoryTheory.Limits.HasPushout f g] →
CategoryTheory.Limits.pushout f g ≅ Opposite.unop (CategoryTheory.Limits.pullback f.op g.op) | true |
Commute.symm_iff | Mathlib.Algebra.Group.Commute.Defs | ∀ {S : Type u_3} [inst : Mul S] {a b : S}, Commute a b ↔ Commute b a | true |
CategoryTheory.reflectsEpimorphisms_of_reflectsColimitsOfShape | Mathlib.CategoryTheory.Limits.Constructions.EpiMono | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [CategoryTheory.Limits.ReflectsColimitsOfShape CategoryTheory.Limits.WalkingSpan F],
F.ReflectsEpimorphisms | true |
Std.CloseableChannel.Sync.close | Std.Sync.Channel | {α : Type} → Std.CloseableChannel.Sync α → EIO Std.CloseableChannel.Error Unit | true |
SimpleGraph.isNClique_bot_iff | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {n : ℕ} {s : Finset α}, ⊥.IsNClique n s ↔ n ≤ 1 ∧ s.card = n | true |
Stream'.tail_cons | Mathlib.Data.Stream.Init | ∀ {α : Type u} (a : α) (s : Stream' α), (Stream'.cons a s).tail = s | true |
List.toArray_cons | Init.Data.List.ToArray | ∀ {α : Type u_1} (a : α) (l : List α), (a :: l).toArray = #[a] ++ l.toArray | true |
_private.Lean.Compiler.LCNF.ExtractClosed.0.Lean.Compiler.LCNF.ExtractClosed.shouldExtractLetValue.match_1 | Lean.Compiler.LCNF.ExtractClosed | (motive : Lean.ConstantInfo → Sort u_1) →
(constInfo : Lean.ConstantInfo) →
((val : Lean.DefinitionVal) → motive (Lean.ConstantInfo.defnInfo val)) →
((val : Lean.ConstructorVal) → motive (Lean.ConstantInfo.ctorInfo val)) →
((x : Lean.ConstantInfo) → motive x) → motive constInfo | false |
_private.Mathlib.Analysis.Asymptotics.Defs.0.Asymptotics.isBigOWith_insert._simp_1_2 | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {a : α} {p : α → Prop}, (∀ᶠ (x : α) in pure a, p x) = p a | false |
Lean.PersistentArrayNode.brecOn_1.go | Lean.Data.PersistentArray | {α : Type u} →
{motive_1 : Lean.PersistentArrayNode α → Sort u_1} →
{motive_2 : Array (Lean.PersistentArrayNode α) → Sort u_1} →
{motive_3 : List (Lean.PersistentArrayNode α) → Sort u_1} →
(t : Array (Lean.PersistentArrayNode α)) →
((t : Lean.PersistentArrayNode α) → t.below → motive_1 t) ... | true |
_private.Aesop.Script.TacticState.0.Aesop.Script.TacticState.replaceWithArray.match_1 | Aesop.Script.TacticState | {α : Type} →
(motive : MProd Bool (Array α) → Sort u_1) →
(r : MProd Bool (Array α)) → ((found : Bool) → (ys : Array α) → motive ⟨found, ys⟩) → motive r | false |
HomologicalComplex.extend.X | Mathlib.Algebra.Homology.Embedding.Extend | {ι : Type u_1} →
{c : ComplexShape ι} →
{C : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_3} C] →
[CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] → HomologicalComplex C c → Option ι → C | true |
MulAction.IsBlock.subsingleton_of_stabilizer_lt_of_subset | Mathlib.GroupTheory.Perm.MaximalSubgroups | ∀ {M : Type u_1} {α : Type u_2} [inst : Group M] [inst_1 : MulAction M α] {s B : Set α} {G : Subgroup M}
[MulAction.IsPreprimitive ↥(MulAction.stabilizer (↥G) s) ↑s],
MulAction.IsBlock (↥G) B →
(∀ (B : Set α), MulAction.IsBlock (↥G) B → B ⊆ sᶜ → B.Subsingleton) →
MulAction.stabilizer M s < G → B ⊆ s → B.S... | true |
_private.Mathlib.Data.Int.Fib.Basic.0.Int.fib_dvd._simp_1_1 | Mathlib.Data.Int.Fib.Basic | ∀ (n : ℕ), ↑(Nat.fib n) = Int.fib ↑n | false |
CategoryTheory.Functor.LocallyCoverDense.mk | Mathlib.CategoryTheory.Sites.DenseSubsite.InducedTopology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {G : CategoryTheory.Functor C D}
{K : CategoryTheory.GrothendieckTopology D},
(∀ ⦃X : C⦄ (T : ↑(K (G.obj X))),
CategoryTheory.Sieve.functorPushforward G (CategoryTheory.Sieve.functor... | true |
CategoryTheory.Functor.mapTriangle._proof_8 | Mathlib.CategoryTheory.Triangulated.Functor | ∀ {C : Type u_2} {D : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] [inst_2 : CategoryTheory.HasShift C ℤ]
[inst_3 : CategoryTheory.HasShift D ℤ] (F : CategoryTheory.Functor C D) [inst_4 : F.CommShift ℤ]
{X Y Z : CategoryTheory.Pretriangulated.Triangle C} ... | false |
_private.Lean.Compiler.LCNF.PropagateBorrow.0.Lean.Compiler.LCNF.Ownedness.join._sparseCasesOn_3 | Lean.Compiler.LCNF.PropagateBorrow | {motive : Lean.Compiler.LCNF.Ownedness → Sort u} →
(t : Lean.Compiler.LCNF.Ownedness) →
motive Lean.Compiler.LCNF.Ownedness.own → (Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | false |
Equiv.simpleGraph._proof_2 | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_2} {W : Type u_1} (e : V ≃ W) (x : SimpleGraph W),
SimpleGraph.comap (⇑e.symm) (SimpleGraph.comap (⇑e) x) = x | false |
List.any_insert | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {f : α → Bool} {l : List α} {a : α},
(List.insert a l).any f = (f a || l.any f) | true |
intrinsicClosure.eq_1 | Mathlib.Analysis.Convex.Intrinsic | ∀ (𝕜 : Type u_1) {V : Type u_2} {P : Type u_5} [inst : Ring 𝕜] [inst_1 : AddCommGroup V] [inst_2 : Module 𝕜 V]
[inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] (s : Set P),
intrinsicClosure 𝕜 s = Subtype.val '' closure (Subtype.val ⁻¹' s) | true |
_private.Mathlib.Order.InitialSeg.0.collapseF._proof_2 | Mathlib.Order.InitialSeg | ∀ {α : Type u_2} {β : Type u_1} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder β s] (f : r ↪r s) (a : α)
(IH : (y : α) → r y a → { b // ¬s (f y) b }) (b : α) (h : r b a), s (↑(IH b h)) (f a) | false |
CategoryTheory.LaxFunctor.mapId'_eq_mapId | Mathlib.CategoryTheory.Bicategory.Functor.Lax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.LaxFunctor B C) (b : B), F.mapId' (CategoryTheory.CategoryStruct.id b) ⋯ = F.mapId b | true |
CategoryTheory.NonPreadditiveAbelian.epiIsCokernelOfKernel._proof_5 | Mathlib.CategoryTheory.Abelian.NonPreadditive | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.NonPreadditiveAbelian C]
{X Y : C} {f : X ⟶ Y}, CategoryTheory.Limits.HasCokernel (CategoryTheory.Limits.kernel.ι f) | false |
Lean.Grind.Linarith.Poly.div._sunfold | Lean.Meta.Tactic.Grind.Arith.Linear.Util | Lean.Grind.Linarith.Poly → ℤ → Lean.Grind.Linarith.Poly | false |
Encodable.sortedUniv_nodup._simp_1 | Mathlib.Logic.Equiv.Finset | ∀ (α : Type u_1) [inst : Fintype α] [inst_1 : Encodable α], (Encodable.sortedUniv α).Nodup = True | false |
ContinuousMonoidHom.isClosedEmbedding_toContinuousMap | Mathlib.Topology.Algebra.Group.CompactOpen | ∀ (A : Type u_2) (B : Type u_3) [inst : Monoid A] [inst_1 : Monoid B] [inst_2 : TopologicalSpace A]
[inst_3 : TopologicalSpace B] [ContinuousMul B] [T2Space B],
Topology.IsClosedEmbedding ContinuousMonoidHom.toContinuousMap | true |
_private.Mathlib.Algebra.Ring.Periodic.0.Function.Antiperiodic.periodic._simp_1_1 | Mathlib.Algebra.Ring.Periodic | ∀ {G : Type u_1} [inst : AddSemigroup G] (a b c : G), a + (b + c) = a + b + c | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.