name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Plausible.Gen.oneOf._auto_1 | Plausible.Gen | Lean.Syntax | false |
forall_or_of_or_forall | Mathlib.Logic.Basic | ∀ {α : Sort u_3} {p : α → Prop} {b : Prop}, (b ∨ ∀ (x : α), p x) → ∀ (x : α), b ∨ p x | true |
Mathlib.Meta.NormNum.evalNatSucc | Mathlib.Tactic.NormNum.Basic | Mathlib.Meta.NormNum.NormNumExt | true |
OrderEmbedding.coe_subtype | Mathlib.Order.Hom.Basic | ∀ {α : Type u_2} [inst : Preorder α] (p : α → Prop), ⇑(OrderEmbedding.subtype p) = Subtype.val | true |
CategoryTheory.Abelian.SpectralObject.d_map_fourδ₄Toδ₃._auto_5 | Mathlib.Algebra.Homology.SpectralObject.EpiMono | Lean.Syntax | false |
IsChain.empty._simp_1 | Mathlib.Order.Preorder.Chain | ∀ {α : Type u_1} {r : α → α → Prop}, IsChain r ∅ = True | false |
CategoryTheory.Regular.strongEpiMonoFactorisation._proof_4 | Mathlib.CategoryTheory.RegularCategory.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Regular C] {X Y : C}
(f : X ⟶ Y),
CategoryTheory.StrongEpi
(CategoryTheory.Limits.coequalizer.π (CategoryTheory.Limits.pullback.fst f f)
(CategoryTheory.Limits.pullback.snd f f)) | false |
WeierstrassCurve.VariableChange.map._proof_1 | Mathlib.AlgebraicGeometry.EllipticCurve.VariableChange | ∀ {R : Type u_1} [inst : CommRing R] {A : Type u_2} [inst_1 : CommRing A], MonoidHomClass (R →+* A) R A | false |
PowerSeries.trunc_trunc_mul_trunc | Mathlib.RingTheory.PowerSeries.Trunc | ∀ {R : Type u_2} [inst : CommSemiring R] {n : ℕ} (f g : PowerSeries R),
(PowerSeries.trunc n) (↑((PowerSeries.trunc n) f) * ↑((PowerSeries.trunc n) g)) = (PowerSeries.trunc n) (f * g) | true |
String.Slice.Pattern.SearchStep.endPos_matched | Init.Data.String.Pattern.Basic | ∀ {s : String.Slice} {p q : s.Pos}, (String.Slice.Pattern.SearchStep.matched p q).endPos = q | true |
CategoryTheory.Functor.IsCoverDense.restrictHomEquivHom_naturality_left | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | ∀ {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] {K : CategoryTheory.GrothendieckTopology D} {A : Type u_4}
[inst_2 : CategoryTheory.Category.{v_4, u_4} A] {G : CategoryTheory.Functor C D} [inst_3 : G.IsCoverDense K]
[inst_4 : G.IsLocallyFull K] {ℱ : CategoryTheory.Functor Dᵒᵖ A} {ℱ' : CategoryTheory.Sheaf K A}
{𝒢 : CategoryTheory.Functor Dᵒᵖ A} (f : 𝒢 ⟶ ℱ) (g : G.op.comp ℱ ⟶ G.op.comp ℱ'.obj),
CategoryTheory.Functor.IsCoverDense.restrictHomEquivHom (CategoryTheory.CategoryStruct.comp (G.op.whiskerLeft f) g) =
CategoryTheory.CategoryStruct.comp f (CategoryTheory.Functor.IsCoverDense.restrictHomEquivHom g) | true |
IsSumSq.rec'._proof_1 | Mathlib.Algebra.Ring.SumsOfSquares | ∀ {R : Type u_1} [inst : Mul R] [inst_1 : Add R] [inst_2 : Zero R] {x s : R}, IsSquare x → IsSumSq s → IsSumSq (x + s) | false |
CategoryTheory.CategoryOfElements.isoMk._proof_4 | Mathlib.CategoryTheory.Elements | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {F : CategoryTheory.Functor C (Type u_3)}
(x y : F.Elements) (e : x.fst ≅ y.fst) (he : F.map e.hom x.snd = y.snd),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryOfElements.homMk x y e.hom he)
(CategoryTheory.CategoryOfElements.homMk y x e.inv ⋯) =
CategoryTheory.CategoryStruct.id x | false |
DifferentiableAt.mul | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {x : E} {𝔸 : Type u_5} [inst_3 : NormedRing 𝔸] [inst_4 : NormedAlgebra 𝕜 𝔸] {a b : E → 𝔸},
DifferentiableAt 𝕜 a x → DifferentiableAt 𝕜 b x → DifferentiableAt 𝕜 (a * b) x | true |
CategoryTheory.Comma.isoMk._proof_5 | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} A] {B : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} B] {T : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} T]
{L₁ : CategoryTheory.Functor A T} {R₁ : CategoryTheory.Functor B T} {X Y : CategoryTheory.Comma L₁ R₁}
(l : X.left ≅ Y.left) (r : X.right ≅ Y.right)
(h :
CategoryTheory.CategoryStruct.comp (L₁.map l.hom) Y.hom = CategoryTheory.CategoryStruct.comp X.hom (R₁.map r.hom)),
CategoryTheory.CategoryStruct.comp { left := l.inv, right := r.inv, w := ⋯ }
{ left := l.hom, right := r.hom, w := h } =
CategoryTheory.CategoryStruct.id Y | false |
Lean.Meta.SynthInstance.State.resumeStack | Lean.Meta.SynthInstance | Lean.Meta.SynthInstance.State → Array (Lean.Meta.SynthInstance.ConsumerNode × Lean.Meta.SynthInstance.Answer) | true |
NonUnitalSubring.topologicalClosure._proof_5 | Mathlib.Topology.Algebra.Ring.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : NonUnitalRing R] [inst_2 : IsSemitopologicalRing R]
(S : NonUnitalSubring R) {a b : R},
a ∈ S.toSubsemigroup.topologicalClosure.carrier →
b ∈ S.toSubsemigroup.topologicalClosure.carrier → a * b ∈ S.toSubsemigroup.topologicalClosure.carrier | false |
completelyRegularSpace_iff | Mathlib.Topology.Separation.CompletelyRegular | ∀ (X : Type u) [inst : TopologicalSpace X],
CompletelyRegularSpace X ↔ ∀ (x : X) (K : Set X), IsClosed K → x ∉ K → ∃ f, Continuous f ∧ f x = 0 ∧ Set.EqOn f 1 K | true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.ToInt.0.Lean.Meta.Grind.Arith.Cutsat.reportMissingToIntAdapter | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToInt | Lean.Expr → Lean.Expr → Lean.MetaM Unit | true |
CategoryTheory.Limits.WidePullbackCone.reindex_π | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {ι : Type u_2} {X : C} {Y : ι → C} {f : (i : ι) → Y i ⟶ X}
(s : CategoryTheory.Limits.WidePullbackCone f) {ι' : Type u_3} (e : ι' ≃ ι) (i : ι'), (s.reindex e).π i = s.π (e i) | true |
bernoulli'.eq_1 | Mathlib.NumberTheory.Bernoulli | ∀ (n : ℕ), bernoulli' n = 1 - ∑ k, ↑(n.choose ↑k) / (↑n - ↑↑k + 1) * bernoulli' ↑k | true |
finsum_mem_finset_eq_sum | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : AddCommMonoid M] (f : α → M) (s : Finset α),
∑ᶠ (i : α) (_ : i ∈ s), f i = ∑ i ∈ s, f i | true |
SSet.Subcomplex.topIso_inv_app_coe | Mathlib.AlgebraicTopology.SimplicialSet.Subcomplex | ∀ (X : SSet) (X_1 : SimplexCategoryᵒᵖ) (a : X.obj X_1), ↑((SSet.Subcomplex.topIso X).inv.app X_1 a) = a | true |
Cardinal.commSemiring._proof_4 | Mathlib.SetTheory.Cardinal.Order | ∀ (a b c : Cardinal.{u_1}), a + b + c = a + (b + c) | false |
Std.Internal.List.containsKey_of_containsKey_cons | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] {l : List ((a : α) × β a)} {k a : α} {v : β k},
Std.Internal.List.containsKey a (⟨k, v⟩ :: l) = true → (k == a) = false → Std.Internal.List.containsKey a l = true | true |
MeasureTheory.MeasurePreserving.vaddInvariantMeasure_iterateAddAct | Mathlib.MeasureTheory.Group.Action | ∀ {α : Type w} {f : α → α} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α},
MeasureTheory.MeasurePreserving f μ μ → MeasureTheory.VAddInvariantMeasure (IterateAddAct f) α μ | true |
WfDvdMonoid.wfDvdMonoid_associates | Mathlib.RingTheory.UniqueFactorizationDomain.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [WfDvdMonoid α], WfDvdMonoid (Associates α) | true |
_private.Mathlib.Util.Superscript.0.Mathlib.Tactic.Superscript.scriptFnNoAntiquot.match_5 | Mathlib.Util.Superscript | (motive : MProd (Array (String.Pos.Raw × String.Pos.Raw)) String → Sort u_1) →
(r : MProd (Array (String.Pos.Raw × String.Pos.Raw)) String) →
((aligns : Array (String.Pos.Raw × String.Pos.Raw)) → (newStr : String) → motive ⟨aligns, newStr⟩) → motive r | false |
NormedGroup.ofSeparation | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_5} → [inst : SeminormedGroup E] → (∀ (x : E), ‖x‖ = 0 → x = 1) → NormedGroup E | true |
groupCohomology.map_inv_of_isCocycle₁ | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {G : Type u_1} {A : Type u_2} [inst : Group G] [inst_1 : AddCommGroup A] [inst_2 : MulAction G A] {f : G → A},
groupCohomology.IsCocycle₁ f → ∀ (g : G), g • f g⁻¹ = -f g | true |
Tactic.NormNum.isNat_realSqrt | Mathlib.Tactic.NormNum.RealSqrt | ∀ {x : ℝ} {nx ny : ℕ}, Mathlib.Meta.NormNum.IsNat x nx → ny * ny = nx → Mathlib.Meta.NormNum.IsNat (√x) ny | true |
CategoryTheory.MorphismProperty.Over.pullback_obj_left | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] (P Q : CategoryTheory.MorphismProperty T)
[inst_1 : Q.IsMultiplicative] {X Y : T} (f : X ⟶ Y) [inst_2 : P.HasPullbacksAlong f]
[inst_3 : P.IsStableUnderBaseChangeAlong f] [inst_4 : Q.IsStableUnderBaseChange] (A : P.Over Q Y),
((CategoryTheory.MorphismProperty.Over.pullback P Q f).obj A).left = CategoryTheory.Limits.pullback A.hom f | true |
Std.DHashMap.Raw.getKey! | Std.Data.DHashMap.Raw | {α : Type u} → {β : α → Type v} → [BEq α] → [Hashable α] → [Inhabited α] → Std.DHashMap.Raw α β → α → α | true |
IsCancelAdd | Mathlib.Algebra.Group.Defs | (G : Type u) → [Add G] → Prop | true |
_private.Mathlib.Analysis.Asymptotics.Defs.0.Asymptotics.IsBigO.exists_mem_basis._simp_1_2 | Mathlib.Analysis.Asymptotics.Defs | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | false |
SimpleGraph.Subgraph.IsMatching.exists_of_universalVerts | Mathlib.Combinatorics.SimpleGraph.UniversalVerts | ∀ {V : Type u_1} {G : SimpleGraph V} [Finite V] {s : Set V},
Disjoint G.universalVerts s →
s.ncard ≤ G.universalVerts.ncard → ∃ t ⊆ G.universalVerts, ∃ M, M.verts = s ∪ t ∧ M.IsMatching | true |
List.pairwise_flatMap | Init.Data.List.Pairwise | ∀ {β : Type u_1} {α : Type u_2} {R : β → β → Prop} {l : List α} {f : α → List β},
List.Pairwise R (List.flatMap f l) ↔
(∀ a ∈ l, List.Pairwise R (f a)) ∧ List.Pairwise (fun a₁ a₂ => ∀ x ∈ f a₁, ∀ y ∈ f a₂, R x y) l | true |
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coeff.elim | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {motive_2 : Lean.Meta.Grind.Arith.Linear.EqCnstrProof → Sort u} →
(t : Lean.Meta.Grind.Arith.Linear.EqCnstrProof) →
t.ctorIdx = 4 →
((k : ℕ) →
(c : Lean.Meta.Grind.Arith.Linear.EqCnstr) → motive_2 (Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coeff k c)) →
motive_2 t | false |
String.Legacy.Iterator.Valid.remainingBytes_le | Batteries.Data.String.Lemmas | ∀ {it : String.Legacy.Iterator}, it.Valid → it.remainingBytes ≤ it.s.utf8ByteSize | true |
div_mul_comm | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b c : α), a / b * c = c / b * a | true |
WittVector.IsocrystalEquiv | 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] →
[WittVector.Isocrystal p k V] →
(V₂ : Type u_3) → [inst_6 : AddCommGroup V₂] → [WittVector.Isocrystal p k V₂] → Type (max u_2 u_3) | true |
MulEquiv.toCommGrpIso | Mathlib.Algebra.Category.Grp.Basic | {X Y : CommGrpCat} → ↑X ≃* ↑Y → (X ≅ Y) | true |
MeasurableVAdd.mk._flat_ctor | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {M : Type u_2} {α : Type u_3} [inst : VAdd M α] [inst_1 : MeasurableSpace M] [inst_2 : MeasurableSpace α],
(∀ (c : M), Measurable fun x => c +ᵥ x) → (∀ (x : α), Measurable fun x_1 => x_1 +ᵥ x) → MeasurableVAdd M α | false |
Fintype.card_eq_zero | Mathlib.Data.Fintype.Card | ∀ {α : Type u_1} [inst : Fintype α] [IsEmpty α], Fintype.card α = 0 | true |
LinearMap.IsRefl.liftQ₂._proof_3 | Mathlib.LinearAlgebra.Quotient.Bilinear | ∀ {S : Type u_1} {P : Type u_2} [inst : CommRing S] [inst_1 : AddCommGroup P] [inst_2 : Module S P], SMulCommClass S S P | false |
List.diff | Batteries.Data.List.Basic | {α : Type u_1} → [BEq α] → List α → List α → List α | true |
Array.extract_succ_right | Init.Data.Array.Extract | ∀ {α : Type u_1} {as : Array α} {i j : ℕ},
i < j + 1 → ∀ (h : j < as.size), as.extract i (j + 1) = (as.extract i j).push as[j] | true |
CategoryTheory.PreGaloisCategory.functorToContAction | Mathlib.CategoryTheory.Galois.Equivalence | {C : Type u₁} →
[inst : CategoryTheory.Category.{u₂, u₁} C] →
(F : CategoryTheory.Functor C FintypeCat) → CategoryTheory.Functor C (ContAction FintypeCat (CategoryTheory.Aut F)) | true |
AddMonoidAlgebra.Monic.pow | Mathlib.Algebra.MonoidAlgebra.Degree | ∀ {R : Type u_1} [inst : Semiring R] {A : Type u_8} {B : Type u_9} [inst_1 : AddMonoid A] [inst_2 : AddMonoid B]
[inst_3 : LinearOrder B] [inst_4 : OrderBot B] [AddLeftStrictMono B] [AddRightStrictMono B] {D : A → B}
{p : AddMonoidAlgebra R A} {n : ℕ},
(∀ (a1 a2 : A), D (a1 + a2) = D a1 + D a2) →
Function.Injective D → AddMonoidAlgebra.Monic D p → AddMonoidAlgebra.Monic D (p ^ n) | true |
CompleteLat.dual._proof_1 | Mathlib.Order.Category.CompleteLat | ∀ (X : CompleteLat),
CompleteLatticeHom.dual (CategoryTheory.CategoryStruct.id X) =
CategoryTheory.CategoryStruct.id { carrier := (↑X)ᵒᵈ, str := OrderDual.instCompleteLattice } | false |
CategoryTheory.PreOneHypercover.Hom.mapMulticospan._proof_11 | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{F : CategoryTheory.PreOneHypercover S} (f : E.Hom F) (a : E.multicospanShape.R),
(match CategoryTheory.Limits.WalkingMulticospan.left (E.multicospanShape.snd a),
CategoryTheory.Limits.WalkingMulticospan.right a,
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.WalkingMulticospan.Hom.snd a)
(CategoryTheory.Limits.WalkingMulticospan.Hom.id (CategoryTheory.Limits.WalkingMulticospan.right a)) with
| x, .(x), CategoryTheory.Limits.WalkingMulticospan.Hom.id .(x) =>
CategoryTheory.Limits.WalkingMulticospan.Hom.id
(match x with
| CategoryTheory.Limits.WalkingMulticospan.left i => CategoryTheory.Limits.WalkingMulticospan.left (f.s₀ i)
| CategoryTheory.Limits.WalkingMulticospan.right i => CategoryTheory.Limits.WalkingMulticospan.right (f.s₁' i))
| .(CategoryTheory.Limits.WalkingMulticospan.left (E.multicospanShape.fst i)),
.(CategoryTheory.Limits.WalkingMulticospan.right i), CategoryTheory.Limits.WalkingMulticospan.Hom.fst i =>
CategoryTheory.Limits.WalkingMulticospan.Hom.fst (f.s₁' i)
| .(CategoryTheory.Limits.WalkingMulticospan.left (E.multicospanShape.snd i)),
.(CategoryTheory.Limits.WalkingMulticospan.right i), CategoryTheory.Limits.WalkingMulticospan.Hom.snd i =>
CategoryTheory.Limits.WalkingMulticospan.Hom.snd (f.s₁' i)) =
CategoryTheory.CategoryStruct.comp
(match CategoryTheory.Limits.WalkingMulticospan.left (E.multicospanShape.snd a),
CategoryTheory.Limits.WalkingMulticospan.right a, CategoryTheory.Limits.WalkingMulticospan.Hom.snd a with
| x, .(x), CategoryTheory.Limits.WalkingMulticospan.Hom.id .(x) =>
CategoryTheory.Limits.WalkingMulticospan.Hom.id
(match x with
| CategoryTheory.Limits.WalkingMulticospan.left i => CategoryTheory.Limits.WalkingMulticospan.left (f.s₀ i)
| CategoryTheory.Limits.WalkingMulticospan.right i =>
CategoryTheory.Limits.WalkingMulticospan.right (f.s₁' i))
| .(CategoryTheory.Limits.WalkingMulticospan.left (E.multicospanShape.fst i)),
.(CategoryTheory.Limits.WalkingMulticospan.right i), CategoryTheory.Limits.WalkingMulticospan.Hom.fst i =>
CategoryTheory.Limits.WalkingMulticospan.Hom.fst (f.s₁' i)
| .(CategoryTheory.Limits.WalkingMulticospan.left (E.multicospanShape.snd i)),
.(CategoryTheory.Limits.WalkingMulticospan.right i), CategoryTheory.Limits.WalkingMulticospan.Hom.snd i =>
CategoryTheory.Limits.WalkingMulticospan.Hom.snd (f.s₁' i))
(match CategoryTheory.Limits.WalkingMulticospan.right a, CategoryTheory.Limits.WalkingMulticospan.right a,
CategoryTheory.Limits.WalkingMulticospan.Hom.id (CategoryTheory.Limits.WalkingMulticospan.right a) with
| x, .(x), CategoryTheory.Limits.WalkingMulticospan.Hom.id .(x) =>
CategoryTheory.Limits.WalkingMulticospan.Hom.id
(match x with
| CategoryTheory.Limits.WalkingMulticospan.left i => CategoryTheory.Limits.WalkingMulticospan.left (f.s₀ i)
| CategoryTheory.Limits.WalkingMulticospan.right i =>
CategoryTheory.Limits.WalkingMulticospan.right (f.s₁' i))
| .(CategoryTheory.Limits.WalkingMulticospan.left (E.multicospanShape.fst i)),
.(CategoryTheory.Limits.WalkingMulticospan.right i), CategoryTheory.Limits.WalkingMulticospan.Hom.fst i =>
CategoryTheory.Limits.WalkingMulticospan.Hom.fst (f.s₁' i)
| .(CategoryTheory.Limits.WalkingMulticospan.left (E.multicospanShape.snd i)),
.(CategoryTheory.Limits.WalkingMulticospan.right i), CategoryTheory.Limits.WalkingMulticospan.Hom.snd i =>
CategoryTheory.Limits.WalkingMulticospan.Hom.snd (f.s₁' i)) | false |
CategoryTheory.Bicategory.whiskerLeft_rightUnitor | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.Bicategory.whiskerLeft f (CategoryTheory.Bicategory.rightUnitor g).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator f g (CategoryTheory.CategoryStruct.id c)).inv
(CategoryTheory.Bicategory.rightUnitor (CategoryTheory.CategoryStruct.comp f g)).hom | true |
LinearEquiv.transvection.inv_eq'._auto_1 | Mathlib.LinearAlgebra.Transvection.Basic | Lean.Syntax | false |
Ideal.Quotient.mk | Mathlib.RingTheory.Ideal.Quotient.Defs | {R : Type u} → [inst : Ring R] → (I : Ideal R) → [inst_1 : I.IsTwoSided] → R →+* R ⧸ I | true |
_private.Mathlib.Analysis.SpecialFunctions.Exp.0.Real.tendsto_exp_div_pow_atTop._simp_1_4 | Mathlib.Analysis.SpecialFunctions.Exp | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), b⁻¹ * a = a / b | false |
Homeomorph.homeomorphOfUnique_symm_apply | Mathlib.Topology.Homeomorph.Defs | ∀ (X : Type u_1) (Y : Type u_2) [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [inst_2 : Unique X]
[inst_3 : Unique Y] (a : Y), (Homeomorph.homeomorphOfUnique X Y).symm a = default | true |
generateFrom_iInter_of_generateFrom_eq_self | Mathlib.Topology.Order | ∀ {α : Type u} {ι : Sort v} (f : ι → Set (Set α)),
(∀ (i : ι), {s | IsOpen s} = f i) →
TopologicalSpace.generateFrom (⋂ i, f i) = ⨆ i, TopologicalSpace.generateFrom (f i) | true |
_private.Mathlib.Topology.IsLocalHomeomorph.0.isLocalHomeomorph_iff_isOpenEmbedding_restrict._simp_1_1 | Mathlib.Topology.IsLocalHomeomorph | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
IsLocalHomeomorph f = IsLocalHomeomorphOn f Set.univ | false |
LatticeHom.birkhoffFinset_injective | Mathlib.Order.Birkhoff | ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : Fintype α] [inst_2 : DecidablePred SupIrred],
Function.Injective ⇑LatticeHom.birkhoffFinset | true |
AddSubsemigroup.mk._flat_ctor | Mathlib.Algebra.Group.Subsemigroup.Defs | {M : Type u_3} →
[inst : Add M] → (carrier : Set M) → (∀ {a b : M}, a ∈ carrier → b ∈ carrier → a + b ∈ carrier) → AddSubsemigroup M | false |
_private.Lean.Compiler.LCNF.Types.0.Lean.Compiler.LCNF.toLCNFType.visitForall._sparseCasesOn_3 | Lean.Compiler.LCNF.Types | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
Set.InvOn.extendDomain | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {p : β → Prop} [inst : DecidablePred p] {f : α ≃ Subtype p} {g₁ g₂ : Equiv.Perm α}
{s t : Set α},
Set.InvOn (⇑g₁) (⇑g₂) s t →
Set.InvOn (⇑(g₁.extendDomain f)) (⇑(g₂.extendDomain f)) (Subtype.val ∘ ⇑f '' s) (Subtype.val ∘ ⇑f '' t) | true |
String.Slice.instToFormat | Init.Data.String.Slice | Std.ToFormat String.Slice | true |
ProofWidgets.instRpcEncodableExprPresentationProps | ProofWidgets.Presentation.Expr | Lean.Server.RpcEncodable ProofWidgets.ExprPresentationProps | true |
TensorProduct.AlgebraTensorModule.lift._proof_4 | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N], SMulCommClass R R (TensorProduct R M N) | false |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.code.normFn._sparseCasesOn_3 | Lean.DocString.Parser | {motive_1 : Lean.Syntax → Sort u} →
(t : Lean.Syntax) →
((info : Lean.SourceInfo) → (val : String) → motive_1 (Lean.Syntax.atom info val)) →
(Nat.hasNotBit 4 t.ctorIdx → motive_1 t) → motive_1 t | false |
ENat.toNat | Mathlib.Data.ENat.Basic | ℕ∞ → ℕ | true |
Colex.rec | Mathlib.Order.Lex | {α : Type u_1} → {β : Colex α → Sort u_2} → ((a : α) → β (toColex a)) → (a : Colex α) → β a | true |
Bool.instDecidableExistsOfDecidablePred._proof_3 | Init.Data.Bool | ∀ (p : Bool → Prop), ¬p true → ¬p false → (∃ x, p x) → False | false |
_private.Lean.Compiler.LCNF.Visibility.0.Lean.Compiler.LCNF.checkMeta.go.match_1 | Lean.Compiler.LCNF.Visibility | (motive : Option Lean.ModuleIdx → Sort u_1) →
(x : Option Lean.ModuleIdx) →
((modIdx : Lean.ModuleIdx) → motive (some modIdx)) → ((x : Option Lean.ModuleIdx) → motive x) → motive x | false |
_private.Mathlib.Geometry.Manifold.PartitionOfUnity.0.Metric.exists_contMDiffMap_forall_closedEBall_subset._simp_1_2 | Mathlib.Geometry.Manifold.PartitionOfUnity | ∀ {α : Sort u_1} {p q : α → Prop}, (∀ (x : α), p x ∧ q x) = ((∀ (x : α), p x) ∧ ∀ (x : α), q x) | false |
SemiNormedGrp₁.cokernelLift | Mathlib.Analysis.Normed.Group.SemiNormedGrp.Kernels | {X Y : SemiNormedGrp₁} →
(f : X ⟶ Y) → (s : CategoryTheory.Limits.CokernelCofork f) → (SemiNormedGrp₁.cokernelCocone f).pt ⟶ s.pt | true |
BooleanSubalgebra.inclusion._proof_4 | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_1} [inst : BooleanAlgebra α] {L M : BooleanSubalgebra α} (h : L ≤ M),
Set.inclusion h ⊥ = Set.inclusion h ⊥ | false |
CategoryTheory.Iso.core | Mathlib.CategoryTheory.Core | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] → {F G : CategoryTheory.Functor C D} → (F ≅ G) → (F.core ≅ G.core) | true |
Std.ExtDTreeMap.getKey?_inter_of_not_mem_left | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{k : α}, k ∉ t₁ → (t₁ ∩ t₂).getKey? k = none | true |
_private.Mathlib.Analysis.Calculus.ContDiff.Convolution.0.HasCompactSupport.hasDerivAt_convolution_left._simp_1_1 | Mathlib.Analysis.Calculus.ContDiff.Convolution | ∀ {𝕜 : Type u𝕜} {G : Type uG} {E : Type uE} {E' : Type uE'} {F : Type uF} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup E'] [inst_2 : NormedAddCommGroup F] {f : G → E} {g : G → E'}
[inst_3 : NontriviallyNormedField 𝕜] [inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜 E'] [inst_6 : NormedSpace 𝕜 F]
(L : E →L[𝕜] E' →L[𝕜] F) [inst_7 : MeasurableSpace G] {μ : MeasureTheory.Measure G} [inst_8 : NormedSpace ℝ F]
[inst_9 : AddCommGroup G] [μ.IsAddLeftInvariant] [μ.IsNegInvariant] [MeasurableNeg G] [MeasurableAdd G],
MeasureTheory.convolution f g L μ = MeasureTheory.convolution g f L.flip μ | false |
String.Pos.next_le_iff_lt | Init.Data.String.Lemmas.Order | ∀ {s : String} {p q : s.Pos} {h : p ≠ s.endPos}, p.next h ≤ q ↔ p < q | true |
Matrix.linfty_opNorm_def | Mathlib.Analysis.Matrix.Normed | ∀ {m : Type u_3} {n : Type u_4} {α : Type u_5} [inst : Fintype m] [inst_1 : Fintype n]
[inst_2 : SeminormedAddCommGroup α] (A : Matrix m n α), ‖A‖ = ↑(Finset.univ.sup fun i => ∑ j, ‖A i j‖₊) | true |
QuadraticAlgebra.re | Mathlib.Algebra.QuadraticAlgebra.Defs | {R : Type u} → {a b : R} → QuadraticAlgebra R a b → R | true |
CochainComplex.shiftFunctorAdd_inv_app_f._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ (a b n : ℤ), n + { as := b }.as + { as := a }.as = n + { as := a + b }.as | false |
LieAlgebra.mem_zeroRootSubalgebra | Mathlib.Algebra.Lie.Weights.Cartan | ∀ (R : Type u_1) (L : Type u_2) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(H : LieSubalgebra R L) [inst_3 : LieRing.IsNilpotent ↥H] (x : L),
x ∈ LieAlgebra.zeroRootSubalgebra R L H ↔ ∀ (y : ↥H), ∃ k, ((LieModule.toEnd R (↥H) L) y ^ k) x = 0 | true |
List.isChain_destutter' | Mathlib.Data.List.Destutter | ∀ {α : Type u_1} (R : α → α → Prop) [inst : DecidableRel R] (l : List α) (a : α), List.IsChain R (List.destutter' R a l) | true |
AlgebraicGeometry.IsClosedImmersion.comp | Mathlib.AlgebraicGeometry.Morphisms.ClosedImmersion | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) [AlgebraicGeometry.IsClosedImmersion f]
[AlgebraicGeometry.IsClosedImmersion g], AlgebraicGeometry.IsClosedImmersion (CategoryTheory.CategoryStruct.comp f g) | true |
Ultrafilter.instPure | Mathlib.Order.Filter.Ultrafilter.Defs | Pure Ultrafilter | true |
List.max?_cons | Init.Data.List.MinMax | ∀ {α : Type u_1} {x : α} [inst : Max α] [Std.Associative max] {xs : List α},
(x :: xs).max? = some (xs.max?.elim x (max x)) | true |
CategoryTheory.FreeBicategory.Hom.comp.elim | Mathlib.CategoryTheory.Bicategory.Free | {B : Type u} →
[inst : Quiver B] →
{motive : (a a_1 : B) → CategoryTheory.FreeBicategory.Hom a a_1 → Sort u_1} →
{a a_1 : B} →
(t : CategoryTheory.FreeBicategory.Hom a a_1) →
t.ctorIdx = 2 →
({a b c : B} →
(f : CategoryTheory.FreeBicategory.Hom a b) →
(g : CategoryTheory.FreeBicategory.Hom b c) → motive a c (f.comp g)) →
motive a a_1 t | false |
Mathlib.Tactic.Choose.ElimStatus.noConfusion | Mathlib.Tactic.Choose | {P : Sort u} →
{t t' : Mathlib.Tactic.Choose.ElimStatus} → t = t' → Mathlib.Tactic.Choose.ElimStatus.noConfusionType P t t' | false |
Bialgebra.unitBialgHom._proof_2 | Mathlib.RingTheory.Bialgebra.Hom | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Bialgebra R A],
(Algebra.TensorProduct.map (Algebra.ofId R A) (Algebra.ofId R A)).comp (Bialgebra.comulAlgHom R R) =
(Bialgebra.comulAlgHom R A).comp (Algebra.ofId R A) | false |
IsDedekindDomain.rec | Mathlib.RingTheory.DedekindDomain.Basic | {A : Type u_2} →
[inst : CommRing A] →
{motive : IsDedekindDomain A → Sort u} →
([toIsDomain : IsDomain A] → [toIsDedekindRing : IsDedekindRing A] → motive ⋯) →
(t : IsDedekindDomain A) → motive t | false |
_private.Std.Sat.AIG.RefVec.0.Std.Sat.AIG.RefVec.push._simp_1 | Std.Sat.AIG.RefVec | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {aig : Std.Sat.AIG α} (self : aig.Ref),
(self.gate < aig.decls.size) = True | false |
_private.Mathlib.Analysis.InnerProductSpace.Orthonormal.0.Orthonormal.sum_inner_products_le._simp_1_4 | Mathlib.Analysis.InnerProductSpace.Orthonormal | ∀ {G : Type u_3} [inst : AddGroup G] {a b c : G}, (a - b = a - c) = (b = c) | false |
SetRel.right_subset_comp | Mathlib.Data.Rel | ∀ {α : Type u_1} {β : Type u_2} {R : SetRel α α} [R.IsRefl] {S : SetRel α β}, S ⊆ R.comp S | true |
ExteriorAlgebra.algebraMap_eq_one_iff | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | ∀ {R : Type u1} [inst : CommRing R] (M : Type u2) [inst_1 : AddCommGroup M] [inst_2 : Module R M] (x : R),
(algebraMap R (ExteriorAlgebra R M)) x = 1 ↔ x = 1 | true |
Lean.LBool.undef | Lean.Data.LBool | Lean.LBool | true |
List.head_of_mem_head? | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} {x : α} (hx : x ∈ l.head?), l.head ⋯ = x | true |
LieAlgebra.derivedSeriesOfIdeal_zero | Mathlib.Algebra.Lie.Solvable | ∀ (R : Type u) (L : Type v) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (I : LieIdeal R L),
LieAlgebra.derivedSeriesOfIdeal R L 0 I = I | true |
CommRing.relPic_eq_top | Mathlib.RingTheory.PicardGroup | ∀ (R : Type u) [inst : CommSemiring R] (A : Type u_7) [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
[Subsingleton (CommRing.Pic A)], CommRing.relPic R A = ⊤ | true |
_private.Mathlib.Algebra.GroupWithZero.Action.Pointwise.Finset.0.Finset.inv_smul_finset_distrib₀._simp_1_4 | Mathlib.Algebra.GroupWithZero.Action.Pointwise.Finset | ∀ {α : Type u_1} [inst : Zero α] (a : α), (MulOpposite.op a = 0) = (a = 0) | false |
CategoryTheory.Idempotents.toKaroubi_isEquivalence | Mathlib.CategoryTheory.Idempotents.Karoubi | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [CategoryTheory.IsIdempotentComplete C],
(CategoryTheory.Idempotents.toKaroubi C).IsEquivalence | true |
CategoryTheory.Limits.prod.diag_map_assoc | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasBinaryProduct X X] [inst_2 : CategoryTheory.Limits.HasBinaryProduct Y Y] {Z : C}
(h : Y ⨯ Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.diag X)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.prod.map f f) h) =
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.diag Y) h) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.