name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
MonoidHom.op._proof_5 | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_2} {N : Type u_1} [inst : MulOneClass M] [inst_1 : MulOneClass N] (f : Mᵐᵒᵖ →* Nᵐᵒᵖ),
MulOpposite.unop ((⇑f ∘ MulOpposite.op) 1) = MulOpposite.unop { unop' := 1 } | false |
Std.DHashMap.Internal.Raw.Const.ofList_eq | Std.Data.DHashMap.Internal.Raw | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {l : List (α × β)},
Std.DHashMap.Raw.Const.ofList l =
↑↑(Std.DHashMap.Internal.Raw₀.Const.insertMany Std.DHashMap.Internal.Raw₀.emptyWithCapacity l) | true |
definition._@.Mathlib.MeasureTheory.Measure.Typeclasses.Finite.588747923._hygCtx._hyg.2 | Mathlib.MeasureTheory.Measure.Typeclasses.Finite | {α : Type u_1} →
[inst : TopologicalSpace α] →
[SecondCountableTopology α] →
{m : MeasurableSpace α} →
(μ : MeasureTheory.Measure α) → [MeasureTheory.IsLocallyFiniteMeasure μ] → μ.FiniteSpanningSetsIn {K | IsOpen K} | false |
IsBaseChange.endHom._proof_2 | Mathlib.RingTheory.TensorProduct.IsBaseChangeHom | ∀ {S : Type u_1} [inst : CommSemiring S] {P : Type u_2} [inst_1 : AddCommMonoid P] [inst_2 : Module S P],
SMulCommClass S S (P →ₗ[S] P) | false |
CategoryTheory.Limits.Fan.combPairHoms | Mathlib.CategoryTheory.Limits.Shapes.CombinedProducts | {C : Type u₁} →
[inst : CategoryTheory.Category.{u₂, u₁} C] →
{ι₁ : Type u_1} →
{ι₂ : Type u_2} →
{f₁ : ι₁ → C} →
{f₂ : ι₂ → C} →
(c₁ : CategoryTheory.Limits.Fan f₁) →
(c₂ : CategoryTheory.Limits.Fan f₂) →
(bc : CategoryTheory.Limits.BinaryFan c₁.p... | true |
Lean.Elab.Term.Quotation.elabMatchSyntax._regBuiltin.Lean.Elab.Term.Quotation.elabMatchSyntax.declRange_3 | Lean.Elab.Quotation | IO Unit | false |
IncidenceAlgebra.instNonAssocSemiring | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | {𝕜 : Type u_2} →
{α : Type u_5} →
[inst : Preorder α] →
[LocallyFiniteOrder α] → [DecidableEq α] → [inst_3 : NonAssocSemiring 𝕜] → NonAssocSemiring (IncidenceAlgebra 𝕜 α) | true |
Matrix.of_symm_apply | Mathlib.LinearAlgebra.Matrix.Defs | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} (f : Matrix m n α) (i : m) (j : n), Matrix.of.symm f i j = f i j | true |
Mathlib.Meta.Positivity.prod_ne_zero | Mathlib.Algebra.Order.BigOperators.Ring.Finset | ∀ {ι : Type u_1} {M₀ : Type u_4} [inst : CommMonoidWithZero M₀] {f : ι → M₀} {s : Finset ι} [Nontrivial M₀]
[NoZeroDivisors M₀], (∀ a ∈ s, f a ≠ 0) → ∏ x ∈ s, f x ≠ 0 | true |
instAddCancelMonoidLex | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [h : AddCancelMonoid α] → AddCancelMonoid (Lex α) | true |
Aesop.Iteration | Aesop.Tree.Data | Type | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.equiv_iff_toList_perm._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
NFA.eval | Mathlib.Computability.NFA | {α : Type u} → {σ : Type v} → NFA α σ → List α → Set σ | true |
Units.oneSub.eq_1 | Mathlib.Analysis.Analytic.Constructions | ∀ {R : Type u_4} [inst : NormedRing R] [inst_1 : HasSummableGeomSeries R] (t : R) (h : ‖t‖ < 1),
Units.oneSub t h = { val := 1 - t, inv := ∑' (n : ℕ), t ^ n, val_inv := ⋯, inv_val := ⋯ } | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics.0.tendsto_rpow_div_mul_add._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Ioi b) = (b < x) | false |
instOneMulHom._proof_1 | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_2} {N : Type u_1} [inst : MulOneClass N] (x x : M), 1 = 1 * 1 | false |
AddGroupExtension.quotientKerRightHomEquivRight.eq_1 | Mathlib.GroupTheory.GroupExtension.Basic | ∀ {N : Type u_1} {G : Type u_2} [inst : AddGroup N] [inst_1 : AddGroup G] {E : Type u_3} [inst_2 : AddGroup E]
(S : AddGroupExtension N E G),
S.quotientKerRightHomEquivRight = QuotientAddGroup.quotientKerEquivOfSurjective S.rightHom ⋯ | true |
_private.Mathlib.Algebra.Homology.ExactSequence.0.CategoryTheory.ComposableArrows.isComplex₂_iff._proof_3 | Mathlib.Algebra.Homology.ExactSequence | ¬1 ≤ 2 → False | false |
Lean.Elab.Term.Do.ToCodeBlock.doReassignArrowToCode | Lean.Elab.Do.Legacy | Lean.Syntax → List Lean.Syntax → Lean.Elab.Term.Do.ToCodeBlock.M Lean.Elab.Term.Do.CodeBlock | true |
SSet.RelativeMorphism.Homotopy.mk | Mathlib.AlgebraicTopology.SimplicialSet.RelativeMorphism | {X Y : SSet} →
{A : X.Subcomplex} →
{B : Y.Subcomplex} →
{φ : A.toSSet ⟶ B.toSSet} →
{f g : SSet.RelativeMorphism A B φ} →
(h : CategoryTheory.MonoidalCategoryStruct.tensorObj X (SSet.stdSimplex.obj (SimplexCategory.mk 1)) ⟶ Y) →
autoParam (CategoryTheory.CategoryStruct.comp SS... | true |
MeasureTheory.Measure.MutuallySingular.compProd_of_left | Mathlib.Probability.Kernel.Composition.MeasureCompProd | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {μ ν : MeasureTheory.Measure α},
μ.MutuallySingular ν → ∀ (κ η : ProbabilityTheory.Kernel α β), (μ.compProd κ).MutuallySingular (ν.compProd η) | true |
_private.Mathlib.Combinatorics.SimpleGraph.Trails.0.SimpleGraph.Walk.IsTrail.even_countP_edges_iff._simp_1_4 | Mathlib.Combinatorics.SimpleGraph.Trails | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | false |
WittVector.one_coeff_zero | Mathlib.RingTheory.WittVector.Defs | ∀ (p : ℕ) (R : Type u_1) [hp : Fact (Nat.Prime p)] [inst : CommRing R], WittVector.coeff 1 0 = 1 | true |
CategoryTheory.ShortComplex.epi_homologyMap_of_epi_cyclesMap' | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology],
CategoryTheory.Epi (CategoryTheory.ShortComplex.cyclesMap φ) →
CategoryTheory.Epi (CategoryTheor... | true |
_private.Mathlib.Analysis.CStarAlgebra.ApproximateUnit.0.Set.InvOn.one_sub_one_add_inv._simp_1_6 | Mathlib.Analysis.CStarAlgebra.ApproximateUnit | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | false |
dense_of_nonempty_smul_invariant | Mathlib.Dynamics.Minimal | ∀ (M : Type u_1) {α : Type u_3} [inst : Monoid M] [inst_1 : TopologicalSpace α] [inst_2 : MulAction M α]
[MulAction.IsMinimal M α] {s : Set α}, s.Nonempty → (∀ (c : M), c • s ⊆ s) → Dense s | true |
List.drop_modifyHead_of_pos | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} {f : α → α} {l : List α} {i : ℕ}, 0 < i → List.drop i (List.modifyHead f l) = List.drop i l | true |
div_eq_inv_self | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : Group G] {a b : G}, a / b = b⁻¹ ↔ a = 1 | true |
Finset.min_mem_image_coe | Mathlib.Data.Finset.Max | ∀ {α : Type u_2} [inst : LinearOrder α] {s : Finset α}, s.Nonempty → s.min ∈ Finset.image WithTop.some s | true |
_private.Init.Data.Rat.Lemmas.0.Rat.divInt.match_3.eq_1 | Init.Data.Rat.Lemmas | ∀ (motive : ℤ → ℤ → Sort u_1) (n : ℤ) (d : ℕ) (h_1 : (n : ℤ) → (d : ℕ) → motive n (Int.ofNat d))
(h_2 : (n : ℤ) → (d : ℕ) → motive n (Int.negSucc d)),
(match n, Int.ofNat d with
| n, Int.ofNat d => h_1 n d
| n, Int.negSucc d => h_2 n d) =
h_1 n d | true |
Rep.coindFunctor_map | Mathlib.RepresentationTheory.Coinduced | ∀ (k : Type u) {G : Type v} {H : Type w} [inst : CommRing k] [inst_1 : Monoid G] [inst_2 : Monoid H] (φ : G →* H)
{X Y : Rep.{t, u, v} k G} (f : X ⟶ Y), (Rep.coindFunctor k φ).map f = Rep.coindMap φ f | true |
_private.Mathlib.Algebra.Ring.Subring.Defs.0.intCast_mem._simp_1_1 | Mathlib.Algebra.Ring.Subring.Defs | ∀ {R : Type u_1} [inst : AddGroupWithOne R] (n : ℤ), ↑n = n • 1 | false |
Algebra.Extension | Mathlib.RingTheory.Extension.Basic | (R : Type u) → (S : Type v) → [inst : CommRing R] → [inst_1 : CommRing S] → [Algebra R S] → Type (max (max u v) (w + 1)) | true |
isOfFinAddOrder_ofMul_iff | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : Monoid G] {x : G}, IsOfFinAddOrder (Additive.ofMul x) ↔ IsOfFinOrder x | true |
SeparationQuotient.preimage_image_mk_closed | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X},
IsClosed s → SeparationQuotient.mk ⁻¹' (SeparationQuotient.mk '' s) = s | true |
IsCompact.compl_mem_coclosedCompact_of_isClosed | Mathlib.Topology.Compactness.Compact | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsCompact s → IsClosed s → sᶜ ∈ Filter.coclosedCompact X | true |
Lean.Elab.Tactic.BVDecide.Frontend.BVDecideConfig.maxSteps._default | Std.Tactic.BVDecide.Syntax | ℕ | false |
ContinuousLinearEquiv.continuousAlternatingMapCongrLeft._proof_1 | Mathlib.Topology.Algebra.Module.Alternating.Topology | ∀ {𝕜 : Type u_1} {E : Type u_2} {E' : Type u_5} {F : Type u_3} {ι : Type u_4} [inst : NormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E] [inst_3 : TopologicalSpace E] [inst_4 : AddCommGroup E']
[inst_5 : Module 𝕜 E'] [inst_6 : TopologicalSpace E'] [inst_7 : AddCommGroup F] [inst_8 : Module 𝕜 F]
[... | false |
Sigma.curry_update | Mathlib.Data.Sigma.Basic | ∀ {α : Type u_1} {β : α → Type u_4} {γ : (a : α) → β a → Type u_7} [inst : DecidableEq α]
[inst_1 : (a : α) → DecidableEq (β a)] (i : (a : α) × β a) (f : (i : (a : α) × β a) → γ i.fst i.snd)
(x : γ i.fst i.snd),
Sigma.curry (Function.update f i x) =
Function.update (Sigma.curry f) i.fst (Function.update (Sigm... | true |
Matrix.cRank_one | Mathlib.LinearAlgebra.Matrix.Rank | ∀ {m : Type um} {R : Type uR} [inst : CommRing R] [Nontrivial R] [inst_2 : DecidableEq m],
Matrix.cRank 1 = Cardinal.lift.{uR, um} (Cardinal.mk m) | true |
NonUnitalRing.sub._inherited_default | Mathlib.Algebra.Ring.Defs | {α : Type u_1} →
(add : α → α → α) →
(∀ (a b c : α), a + b + c = a + (b + c)) →
(zero : α) →
(∀ (a : α), 0 + a = a) →
(∀ (a : α), a + 0 = a) →
(nsmul : ℕ → α → α) →
(∀ (x : α), nsmul 0 x = 0) → (∀ (n : ℕ) (x : α), nsmul (n + 1) x = nsmul n x + x) → (α → α) → α → α... | false |
ContDiff.fun_comp_contDiffOn | Mathlib.Analysis.Calculus.ContDiff.Comp | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {n : WithTop ℕ∞} {s : Set E} {g : F →... | true |
IsLowerSet.isOpen | Mathlib.Topology.Order.Basic | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [WellFoundedLT α] {s : Set α},
IsLowerSet s → IsOpen s | true |
_private.Mathlib.Combinatorics.SimpleGraph.Subgraph.0.SimpleGraph.Subgraph.subgraphOfAdj_eq_induce._simp_1_4 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {α : Type u_1} {a b : α}, (a ∈ {b}) = (a = b) | false |
ProbabilityTheory.Kernel.ae_comp_of_ae_ae | Mathlib.Probability.Kernel.Composition.Comp | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} {κ : ProbabilityTheory.Kernel α β} {η : ProbabilityTheory.Kernel β γ} {a : α} {p : γ → Prop},
MeasurableSet {z | p z} → (∀ᵐ (y : β) ∂κ a, ∀ᵐ (z : γ) ∂η y, p z) → ∀ᵐ (z : γ) ∂(η.comp κ) a, p z | true |
_private.Mathlib.MeasureTheory.Integral.Bochner.Basic.0.Mathlib.Meta.Positivity.evalIntegral.match_1 | Mathlib.MeasureTheory.Integral.Bochner.Basic | (motive :
(u : Lean.Level) →
{α : Q(Type u)} →
(zα : Q(Zero «$α»)) →
(pα : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness zα pα e) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness zα pα e) → Sort u_1) →
(u : ... | false |
Filter.mem_zero | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Zero α] {s : Set α}, s ∈ 0 ↔ 0 ∈ s | true |
Std.DTreeMap.Internal.Impl.Const.get?_union_of_contains_eq_false_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
(h₁ : m₁.WF) (h₂ : m₂.WF) {k : α},
Std.DTreeMap.Internal.Impl.contains k m₁ = false →
Std.DTreeMap.Internal.Impl.Const.get? (m₁.union m₂ ⋯ ⋯) k = Std.DTreeMap.Internal.Impl.Const.get? m₂ k | true |
CategoryTheory.AddMon.Hom.mk | Mathlib.CategoryTheory.Monoidal.Mon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{M N : CategoryTheory.AddMon C} → (hom : M.X ⟶ N.X) → [isAddMonHom_hom : CategoryTheory.IsAddMonHom hom] → M.Hom N | true |
Lean.Doc.Data.instTypeNameTactic | Lean.Elab.DocString.Builtin | TypeName Lean.Doc.Data.Tactic | true |
LieRinehartAlgebra.Hom.comp._proof_1 | Mathlib.Algebra.LieRinehartAlgebra.Defs | ∀ {R : Type u_3} {A₁ : Type u_7} {L₁ : Type u_2} {A₂ : Type u_5} {L₂ : Type u_4} {A₃ : Type u_6} {L₃ : Type u_1}
[inst : CommRing R] [inst_1 : CommRing A₁] [inst_2 : LieRing L₁] [inst_3 : Module A₁ L₁]
[inst_4 : LieRingModule L₁ A₁] [inst_5 : CommRing A₂] [inst_6 : LieRing L₂] [inst_7 : Module A₂ L₂]
[inst_8 : Li... | false |
multipliable_of_exists_eq_zero | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CommMonoidWithZero α] [inst_1 : TopologicalSpace α] {f : β → α}
{L : SummationFilter β}, (∃ b, f b = 0) → ∀ [L.LeAtTop], Multipliable f L | true |
_private.Init.Data.String.Lemmas.FindPos.0.String.Slice.posGE_le_iff._simp_1_3 | Init.Data.String.Lemmas.FindPos | ∀ {s : String.Slice} {l r : s.Pos}, (l ≤ r) = (l.offset ≤ r.offset) | false |
CharTwo.add_cancel_right | Mathlib.Algebra.CharP.Two | ∀ {R : Type u_1} [inst : Semiring R] [CharP R 2] (a b : R), a + b + b = a | true |
Mathlib.Tactic.Contrapose.contrapose.negate_iff | Mathlib.Tactic.Contrapose | Lean.Option Bool | true |
_private.Mathlib.GroupTheory.Coxeter.Basic.0.CoxeterSystem.getElem_alternatingWord._proof_1_5 | Mathlib.GroupTheory.Coxeter.Basic | ∀ {B : Type u_1} (i j : B) (n k : ℕ), k ≤ n → ¬k = 0 → k - 1 < (CoxeterSystem.alternatingWord i j n).length | false |
convex_halfSpace_le | Mathlib.Analysis.Convex.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_4} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E] [inst_4 : AddCommMonoid β] [inst_5 : PartialOrder β] [IsOrderedAddMonoid β]
[inst_7 : Module 𝕜 β] [PosSMulMono 𝕜 β] {f : E → β}, IsLinearMap 𝕜 f → ∀ (r : β), Convex 𝕜... | true |
Sym2.sortEquiv_apply_coe | Mathlib.Data.Sym.Sym2.Order | ∀ {α : Type u_1} [inst : LinearOrder α] (s : Sym2 α), ↑(Sym2.sortEquiv s) = (s.inf, s.sup) | true |
CategoryTheory.Limits.ProductsFromFiniteCofiltered.finiteSubproductsCone._proof_1 | Mathlib.CategoryTheory.Limits.Constructions.Filtered | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {α : Type u_1}
[CategoryTheory.Limits.HasFiniteProducts C] (f : α → C) (S : (Finset (CategoryTheory.Discrete α))ᵒᵖ),
CategoryTheory.Limits.HasLimit (CategoryTheory.Discrete.functor fun x => (CategoryTheory.Discrete.functor f).obj ↑x) | false |
Antisymmetrization.induction_on | Mathlib.Order.Antisymmetrization | ∀ {α : Type u_1} (r : α → α → Prop) [inst : IsPreorder α r] {p : Antisymmetrization α r → Prop}
(a : Antisymmetrization α r), (∀ (a : α), p (toAntisymmetrization r a)) → p a | true |
Std.Tactic.BVDecide.BVUnOp.ctorElimType | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {motive : Std.Tactic.BVDecide.BVUnOp → Sort u} → ℕ → Sort (max 1 u) | false |
_private.Mathlib.CategoryTheory.Sites.Coherent.Comparison.0.CategoryTheory.extensive_regular_generate_coherent.match_1_4 | Mathlib.CategoryTheory.Sites.Coherent.Comparison | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.FinitaryPreExtensive C] (Y : C)
(T : CategoryTheory.Presieve Y) (motive : T ∈ (CategoryTheory.extensiveCoverage C).coverings Y → Prop)
(x : T ∈ (CategoryTheory.extensiveCoverage C).coverings Y),
(∀ (α : Type) (x : Finite α) (X... | false |
_private.Mathlib.Testing.Plausible.Functions.0.Plausible.TotalFunction.zeroDefault.match_1.splitter | Mathlib.Testing.Plausible.Functions | {α : Type u_1} →
{β : Type u_2} →
(motive : Plausible.TotalFunction α β → Sort u_3) →
(x : Plausible.TotalFunction α β) →
((A : List ((_ : α) × β)) → (a : β) → motive (Plausible.TotalFunction.withDefault A a)) → motive x | true |
Std.DTreeMap.Const.mergeWith._proof_1 | Std.Data.DTreeMap.Basic | ∀ {α : Type u_1} {cmp : α → α → Ordering} {β : Type u_2} (mergeFn : α → β → β → β)
(t₁ t₂ : Std.DTreeMap α (fun x => β) cmp),
(Std.DTreeMap.Internal.Impl.Const.mergeWith mergeFn t₁.inner t₂.inner ⋯).impl.WF | false |
NormedSpace.exp_op | Mathlib.Analysis.Normed.Algebra.Exponential | ∀ {𝔸 : Type u_2} [inst : Ring 𝔸] [inst_1 : TopologicalSpace 𝔸] [inst_2 : IsTopologicalRing 𝔸] [T2Space 𝔸] (x : 𝔸),
NormedSpace.exp (MulOpposite.op x) = MulOpposite.op (NormedSpace.exp x) | true |
Module.Basis.linearMap | Mathlib.LinearAlgebra.Matrix.ToLin | {R : Type u_1} →
{M₁ : Type u_3} →
{M₂ : Type u_4} →
{ι₁ : Type u_6} →
{ι₂ : Type u_7} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M₁] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : Module R M₁] →
[inst_4 : Module R M₂] →
... | true |
Topology.IsLower.tendsto_nhds_iff_not_le | Mathlib.Topology.Order.LowerUpperTopology | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : TopologicalSpace α] [Topology.IsLower α] {β : Type u_3} {f : β → α}
{l : Filter β} {x : α}, Filter.Tendsto f l (nhds x) ↔ ∀ (y : α), ¬y ≤ x → ∀ᶠ (z : β) in l, ¬y ≤ f z | true |
_private.Mathlib.Algebra.Order.Round.0.round_eq_div._simp_1_3 | Mathlib.Algebra.Order.Round | ∀ {α : Type u} [inst : NonAssocSemiring α] (n : α), n + n = 2 * n | false |
ContinuousAlternatingMap.instContinuousEval | Mathlib.Analysis.Normed.Module.Alternating.Basic | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : Type u_3} {F : Type u_4} [inst : NormedField 𝕜] [Finite ι]
[inst_2 : SeminormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] [inst_4 : TopologicalSpace F] [inst_5 : AddCommGroup F]
[inst_6 : IsTopologicalAddGroup F] [inst_7 : Module 𝕜 F], ContinuousEval (E [⋀^ι]→L[𝕜] F) (ι → E... | true |
MeasureTheory.setIntegral_abs_condExp_le | Mathlib.MeasureTheory.Function.ConditionalExpectation.Real | ∀ {α : Type u_1} {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
MeasurableSet s → ∀ (f : α → ℝ), ∫ (x : α) in s, |μ[f | m] x| ∂μ ≤ ∫ (x : α) in s, |f x| ∂μ | true |
Lean.Elab.Do.map1TermElabM | Lean.Elab.Do.Basic | {β : Sort u_1} →
({α : Type} → (β → Lean.Elab.TermElabM α) → Lean.Elab.TermElabM α) →
{α : Type} → (β → Lean.Elab.Do.DoElabM α) → Lean.Elab.Do.DoElabM α | true |
CompactT2.Projective | Mathlib.Topology.ExtremallyDisconnected | (X : Type u) → [TopologicalSpace X] → Prop | true |
Pi.zero_mono | Mathlib.Algebra.Group.Pi.Lemmas | ∀ {α : Type u_4} {β : Type u_5} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Zero β], Monotone 0 | true |
Lean.IR.LitVal.str.elim | Lean.Compiler.IR.Basic | {motive : Lean.IR.LitVal → Sort u} →
(t : Lean.IR.LitVal) → t.ctorIdx = 1 → ((v : String) → motive (Lean.IR.LitVal.str v)) → motive t | false |
LinearMap.tensorEqLocus_coe | Mathlib.RingTheory.Flat.Equalizer | ∀ {R : Type u_1} (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (M : Type u_3)
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M] {N : Type u_4}
{P : Type u_5} [inst_7 : AddCommGroup N] [inst_8 : AddCommGroup P] [inst_9 : Module R N]... | true |
CategoryTheory.Factorisation.casesOn | Mathlib.CategoryTheory.Category.Factorisation | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f : X ⟶ Y} →
{motive : CategoryTheory.Factorisation f → Sort u_1} →
(t : CategoryTheory.Factorisation f) →
((mid : C) →
(ι : X ⟶ mid) →
(π : mid ⟶ Y) →
... | false |
Subgroup.inv_mem | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) {x : G}, x ∈ H → x⁻¹ ∈ H | true |
RingQuot.mkRingHom_def | Mathlib.Algebra.RingQuot | ∀ {R : Type u_1} [inst : Semiring R] (r : R → R → Prop),
RingQuot.mkRingHom r =
{ toFun := fun x => { toQuot := Quot.mk (RingQuot.Rel r) x }, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
map_add' := ⋯ } | true |
Std.IterM.step_intermediateDropWhile._proof_4 | Std.Data.Iterators.Lemmas.Combinators.Monadic.DropWhile | ∀ {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Monad m] {P : β → Bool} (out : β),
P out = false → ((pure ∘ ULift.up ∘ P) out).Property { down := false } | false |
Multiplicative.ofAdd.eq_1 | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {α : Type u}, Multiplicative.ofAdd = { toFun := fun x => x, invFun := fun x => x, left_inv := ⋯, right_inv := ⋯ } | true |
Lean.Grind.Nat.lo_lo | Init.Grind.Offset | ∀ (u w v k₁ k₂ : ℕ), u + k₁ ≤ w → w + k₂ ≤ v → u + (k₁ + k₂) ≤ v | true |
Int.instLocallyFiniteOrder._proof_6 | Mathlib.Data.Int.Interval | ∀ (a b x : ℤ),
x ∈ Finset.map (Nat.castEmbedding.trans (addLeftEmbedding a)) (Finset.range (b + 1 - a).toNat) ↔ a ≤ x ∧ x ≤ b | false |
_private.Init.Data.String.Decode.0.String.toBitVec_getElem_utf8EncodeChar_zero_of_utf8Size_eq_two | Init.Data.String.Decode | ∀ {c : Char} (h : c.utf8Size = 2), (String.utf8EncodeChar c)[0].toBitVec = 6#3 ++ BitVec.extractLsb' 6 5 c.val.toBitVec | true |
List.Shortlex.of_length_lt | Mathlib.Data.List.Shortlex | ∀ {α : Type u_1} {r : α → α → Prop} {s t : List α}, s.length < t.length → List.Shortlex r s t | true |
LinearEquiv.cast | Mathlib.Algebra.Module.Equiv.Defs | {R : Type u_1} →
[inst : Semiring R] →
{ι : Type u_14} →
{M : ι → Type u_15} →
[inst_1 : (i : ι) → AddCommMonoid (M i)] →
[inst_2 : (i : ι) → Module R (M i)] → {i j : ι} → i = j → M i ≃ₗ[R] M j | true |
_private.Lean.Structure.0.Lean.findParentProjStruct?.go._unsafe_rec | Lean.Structure | Lean.Environment → Lean.Name → Lean.Name → StateM Lean.NameSet (Option Lean.Name) | false |
Filter.map_mapsTo_Iic_iff_tendsto | Mathlib.Order.Filter.Tendsto | ∀ {α : Type u_1} {β : Type u_2} {F : Filter α} {G : Filter β} {m : α → β},
Set.MapsTo (Filter.map m) (Set.Iic F) (Set.Iic G) ↔ Filter.Tendsto m F G | true |
Lean.Lsp.ResolvableCompletionItemData.mk._flat_ctor | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.DocumentUri →
Lean.Lsp.Position → Option ℕ → Option Lean.Lsp.CompletionIdentifier → Lean.Lsp.ResolvableCompletionItemData | false |
_private.Mathlib.AlgebraicGeometry.Morphisms.ClosedImmersion.0.AlgebraicGeometry.isDominant_of_of_appTop_injective._simp_1_1 | Mathlib.AlgebraicGeometry.Morphisms.ClosedImmersion | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Ring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
[rc : RingHomClass F R S] (f : F), (RingHom.ker f = ⊥) = Function.Injective ⇑f | false |
Lean.Parser.Term.whereDecls._regBuiltin.Lean.Parser.Term.whereFinally.formatter_7 | Lean.Parser.Term | IO Unit | false |
smoothSheafCommGroup.eq_1 | Mathlib.Geometry.Manifold.Sheaf.Smooth | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {EM : Type u_2} [inst_1 : NormedAddCommGroup EM]
[inst_2 : NormedSpace 𝕜 EM] {HM : Type u_3} [inst_3 : TopologicalSpace HM] (IM : ModelWithCorners 𝕜 EM HM)
{E : Type u_4} [inst_4 : NormedAddCommGroup E] [inst_5 : NormedSpace 𝕜 E] {H : Type u_5} [inst_6 : Topo... | true |
_private.Mathlib.RingTheory.Radical.NatInt.0.Nat.one_lt_radical_iff.match_1_1 | Mathlib.RingTheory.Radical.NatInt | ∀ {n : ℕ} (motive : (∃ x ∈ n.primeFactors, 1 < x) → Prop) (x : ∃ x ∈ n.primeFactors, 1 < x),
(∀ (p : ℕ) (h : p ∈ n.primeFactors ∧ 1 < p), motive ⋯) → motive x | false |
AddMonoidHom.ofLeftInverse_symm_apply | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] {f : G →+ N} {g : N →+ G}
(h : Function.LeftInverse ⇑g ⇑f) (x : ↥f.range), (AddMonoidHom.ofLeftInverse h).symm x = g ↑x | true |
Positive.addSemigroup | Mathlib.Algebra.Order.Positive.Ring | {M : Type u_1} → [inst : AddMonoid M] → [inst_1 : Preorder M] → [AddLeftStrictMono M] → AddSemigroup { x // 0 < x } | true |
CategoryTheory.Functor.PreservesEffectiveEpiFamilies.casesOn | Mathlib.CategoryTheory.EffectiveEpi.Preserves | {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] →
{F : CategoryTheory.Functor C D} →
{motive : F.PreservesEffectiveEpiFamilies → Sort u_3} →
(t : F.PreservesEffectiveEpiFamilies) →
(... | false |
EuclideanGeometry.oangle_eq_zero_iff_oangle_rev_eq_zero | Mathlib.Geometry.Euclidean.Angle.Oriented.Affine | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
{p₁ p₂ p₃ : P}, EuclideanGeometry.oangle p₁ p₂ p₃ = 0 ↔ EuclideanGeometry.oangle p₃ p₂ p... | true |
CategoryTheory.Sieve.overEquiv_functorPullback_map | Mathlib.CategoryTheory.Sites.Over | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) (U : CategoryTheory.Over X)
(S : CategoryTheory.Sieve ((CategoryTheory.Over.map f).obj U)),
(CategoryTheory.Sieve.overEquiv U) (CategoryTheory.Sieve.functorPullback (CategoryTheory.Over.map f) S) =
(CategoryTheory.Sieve.overEquiv ((C... | true |
Cardinal.powerlt_le | Mathlib.SetTheory.Cardinal.Basic | ∀ {a b c : Cardinal.{u}}, a ^< b ≤ c ↔ ∀ x < b, a ^ x ≤ c | true |
NonUnitalSubring.neg_mem | Mathlib.RingTheory.NonUnitalSubring.Defs | ∀ {R : Type u} [inst : NonUnitalNonAssocRing R] (s : NonUnitalSubring R) {x : R}, x ∈ s → -x ∈ s | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.getElem?_toList_ric._simp_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m < n.succ) = (m ≤ n) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.