name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnModule.mul_smul'.match_1_1 | Mathlib.RingTheory.HahnSeries.Multiplication | {Γ : Type u_1} →
{Γ' : Type u_2} →
(motive : (_ : Γ × Γ') × Γ × Γ → Sort u_3) →
(x : (_ : Γ × Γ') × Γ × Γ) → ((_i : Γ) → (j : Γ') → (k l : Γ) → motive ⟨(_i, j), (k, l)⟩) → motive x | false |
String.Slice.Pattern.Model.SlicesFrom.mk.noConfusion | Init.Data.String.Lemmas.Pattern.Split | {s : String.Slice} →
{startPos : s.Pos} →
{P : Sort u} →
{l : List s.Subslice} →
{any_head? : Option.any (fun x => decide (x.startInclusive = startPos)) l.head? = true} →
{l' : List s.Subslice} →
{any_head?' : Option.any (fun x => decide (x.startInclusive = startPos)) l'.head? ... | false |
_private.Lean.Meta.Tactic.Grind.Canon.0.Lean.Meta.Grind.Canon.shouldCanon | Lean.Meta.Tactic.Grind.Canon | Array Lean.Meta.ParamInfo → ℕ → Lean.Expr → Lean.MetaM Lean.Meta.Grind.Canon.ShouldCanonResult✝ | true |
algEquivIsoAlgebraIso._proof_2 | Mathlib.Algebra.Category.AlgCat.Basic | ∀ {R : Type u_1} [inst : CommRing R] {X Y : Type u_1} [inst_1 : Ring X] [inst_2 : Ring Y] [inst_3 : Algebra R X]
[inst_4 : Algebra R Y],
(CategoryTheory.CategoryStruct.comp (fun i => i.toAlgEquiv) fun e => e.toAlgebraIso) =
CategoryTheory.CategoryStruct.id (AlgCat.of R X ≅ AlgCat.of R Y) | false |
AddSubgroup.characteristic_iff_comap_eq | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G},
H.Characteristic ↔ ∀ (ϕ : G ≃+ G), AddSubgroup.comap ϕ.toAddMonoidHom H = H | true |
_private.Aesop.RulePattern.0.Aesop.RulePattern.elab.fvarsToMVars | Aesop.RulePattern | Array Lean.Expr → Lean.Expr → Lean.MetaM (Lean.Expr × Array Lean.MVarId) | true |
Lean.Server.FileWorker.SignatureHelp.CandidateKind.rec | Lean.Server.FileWorker.SignatureHelp | {motive : Lean.Server.FileWorker.SignatureHelp.CandidateKind → Sort u} →
motive Lean.Server.FileWorker.SignatureHelp.CandidateKind.pipeArg →
motive Lean.Server.FileWorker.SignatureHelp.CandidateKind.termArg →
motive Lean.Server.FileWorker.SignatureHelp.CandidateKind.appArg →
(t : Lean.Server.FileWor... | false |
CategoryTheory.Limits.IsColimit.uniq._autoParam | Mathlib.CategoryTheory.Limits.IsLimit | Lean.Syntax | false |
le_mul_of_le_one_right | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : Preorder R] {a b : R} [ExistsAddOfLE R] [PosMulMono R] [AddRightMono R]
[AddRightReflectLE R], a ≤ 0 → b ≤ 1 → a ≤ a * b | true |
Std.Iterators.Types.TakeWhile._sizeOf_inst | Std.Data.Iterators.Combinators.Monadic.TakeWhile | (α : Type w) →
(m : Type w → Type w') →
(β : Type w) →
(P : β → Std.Iterators.PostconditionT m (ULift.{w, 0} Bool)) →
[SizeOf α] → [(a : Type w) → SizeOf (m a)] → [SizeOf β] → SizeOf (Std.Iterators.Types.TakeWhile α m β P) | false |
CategoryTheory.Free | Mathlib.Algebra.Category.ModuleCat.Adjunctions | Type u_1 → Type u → Type u | true |
CategoryTheory.sheafificationNatIso._proof_3 | Mathlib.CategoryTheory.Sites.Sheafification | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] (J : CategoryTheory.GrothendieckTopology C)
(D : Type u_4) [inst_1 : CategoryTheory.Category.{u_2, u_4} D] [inst_2 : CategoryTheory.HasWeakSheafify J D]
{X Y : CategoryTheory.Sheaf J D} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.... | false |
BddDistLat.dualEquiv._proof_1 | Mathlib.Order.Category.BddDistLat | ∀ {X Y : BddDistLat} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id BddDistLat).map f)
((fun X => BddDistLat.Iso.mk (OrderIso.dualDual ↑X.toDistLat)) Y).hom =
CategoryTheory.CategoryStruct.comp ((fun X => BddDistLat.Iso.mk (OrderIso.dualDual ↑X.toDistLat)) X).hom
((BddDist... | false |
CategoryTheory.MorphismProperty.RespectsIso.unop | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.MorphismProperty Cᵒᵖ) [P.RespectsIso],
P.unop.RespectsIso | true |
List.take_iterate | Mathlib.Data.List.Iterate | ∀ {α : Type u_1} (f : α → α) (a : α) (m n : ℕ), List.take m (List.iterate f a n) = List.iterate f a (min m n) | true |
Set.indicator_indicator | Mathlib.Algebra.Notation.Indicator | ∀ {α : Type u_1} {M : Type u_3} [inst : Zero M] (s t : Set α) (f : α → M),
s.indicator (t.indicator f) = (s ∩ t).indicator f | true |
Lean.Meta.Grind.NewRawFact.mk.inj | Lean.Meta.Tactic.Grind.Types | ∀ {proof prop : Lean.Expr} {generation : ℕ} {splitSource : Lean.Meta.Grind.SplitSource} {proof_1 prop_1 : Lean.Expr}
{generation_1 : ℕ} {splitSource_1 : Lean.Meta.Grind.SplitSource},
{ proof := proof, prop := prop, generation := generation, splitSource := splitSource } =
{ proof := proof_1, prop := prop_1, ge... | true |
Std.TreeSet.Raw.get!_filter | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] [inst : Inhabited α]
{f : α → Bool} {k : α}, t.WF → (Std.TreeSet.Raw.filter f t).get! k = (Option.filter f (t.get? k)).get! | true |
le_of_le_min_left | Mathlib.Order.MinMax | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, c ≤ min a b → c ≤ a | true |
_private.Mathlib.Order.OmegaCompletePartialOrder.0.OmegaCompletePartialOrder.ωSup_eq_of_isLUB._simp_1_3 | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Sort u_2} {β : Sort u_1} {f : α → β} {p : β → Prop}, (∀ (b : β) (a : α), f a = b → p b) = ∀ (a : α), p (f a) | false |
WeierstrassCurve.Ψ_even | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | ∀ {R : Type r} [inst : CommRing R] (W : WeierstrassCurve R) (m : ℤ),
W.Ψ (2 * m) * W.ψ₂ = W.Ψ (m - 1) ^ 2 * W.Ψ m * W.Ψ (m + 2) - W.Ψ (m - 2) * W.Ψ m * W.Ψ (m + 1) ^ 2 | true |
Subsemigroup.comap_map_eq_of_injective | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] {f : M →ₙ* N},
Function.Injective ⇑f → ∀ (S : Subsemigroup M), Subsemigroup.comap f (Subsemigroup.map f S) = S | true |
Set.restrictPreimage | Mathlib.Data.Set.Operations | {α : Type u} → {β : Type v} → (t : Set β) → (f : α → β) → ↑(f ⁻¹' t) → ↑t | true |
CategoryTheory.Oplax.StrongTrans.naturality_naturality | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} (self : CategoryTheory.Oplax.StrongTrans F G) {a b : B} {f g : a ⟶ b}
(η : f ⟶ g),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight (F.map₂ η)... | true |
Polynomial.evalEval_dvd | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u_1} [inst : CommSemiring R] (x y : R) {p q : Polynomial (Polynomial R)},
p ∣ q → Polynomial.evalEval x y p ∣ Polynomial.evalEval x y q | true |
MeasureTheory.OuterMeasure.toMeasure_eq_zero | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {ms : MeasurableSpace α} {μ : MeasureTheory.OuterMeasure α} (h : ms ≤ μ.caratheodory),
μ.toMeasure h = 0 ↔ μ = 0 | true |
MvPowerSeries.coeff_mul_right_one_sub_of_lt_order | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {σ : Type u_1} {R : Type u_3} [inst : Ring R] {f g : MvPowerSeries σ R} (d : σ →₀ ℕ),
↑(Finsupp.degree d) < g.order → (MvPowerSeries.coeff d) ((1 - g) * f) = (MvPowerSeries.coeff d) f | true |
ProofWidgets.InteractiveMessageProps.mk.noConfusion | ProofWidgets.Component.Basic | {P : Sort u} →
{msg msg' : Lean.Server.WithRpcRef Lean.MessageData} → { msg := msg } = { msg := msg' } → (msg = msg' → P) → P | false |
NumberField.InfinitePlace.nrComplexPlaces_eq_zero_of_finrank_eq_one | Mathlib.NumberTheory.NumberField.InfinitePlace.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K],
Module.finrank ℚ K = 1 → NumberField.InfinitePlace.nrComplexPlaces K = 0 | true |
SheafOfModules.toSheaf_map_hom | Mathlib.Algebra.Category.ModuleCat.Sheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
(R : CategoryTheory.Sheaf J RingCat) {X Y : SheafOfModules R} (f : X ⟶ Y),
((SheafOfModules.toSheaf R).map f).hom = ((SheafOfModules.forget R).comp (PresheafOfModules.toPresheaf R.obj)).map f | true |
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.All.trivial.match_1_1 | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} (motive : Batteries.RBNode α → Prop) (x : Batteries.RBNode α),
(∀ (a : Unit), motive Batteries.RBNode.nil) →
(∀ (c : Batteries.RBColor) (l : Batteries.RBNode α) (v : α) (r : Batteries.RBNode α),
motive (Batteries.RBNode.node c l v r)) →
motive x | false |
ContinuousAlternatingMap.prodLIE._proof_6 | Mathlib.Analysis.Normed.Module.Alternating.Basic | ∀ (𝕜 : Type u_1) (F : Type u_3) (G : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : SeminormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] [inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G], SMulCommClass 𝕜 𝕜 (F × G) | false |
Lean.Syntax.isQuot | Lean.Syntax | Lean.Syntax → Bool | true |
hasFDerivAt_integral_of_dominated_loc_of_lip | Mathlib.Analysis.Calculus.ParametricIntegral | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {𝕜 : Type u_2} [inst_1 : RCLike 𝕜]
{E : Type u_3} [inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace ℝ E] [inst_4 : NormedSpace 𝕜 E] {H : Type u_4}
[inst_5 : NormedAddCommGroup H] [inst_6 : NormedSpace 𝕜 H] {F : H → α → E} {x₀ : H} {bo... | true |
CategoryTheory.Pretriangulated.isoTriangleOfIso₁₃._proof_4 | Mathlib.CategoryTheory.Triangulated.Pretriangulated | -1 + 1 = 0 | false |
LinearEquiv.uniqueProd | Mathlib.LinearAlgebra.Prod | {R : Type u} →
{M : Type v} →
{M₂ : Type w} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid M₂] → [inst_3 : Module R M] → [inst_4 : Module R M₂] → [Unique M₂] → (M₂ × M) ≃ₗ[R] M | true |
CategoryTheory.CatEnrichedOrdinary.instBicategory._proof_12 | Mathlib.CategoryTheory.Bicategory.CatEnriched | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C]
[inst_1 : CategoryTheory.EnrichedOrdinaryCategory CategoryTheory.Cat C] {a b : CategoryTheory.CatEnrichedOrdinary C}
{f g : a ⟶ b} (η : f ⟶ g),
CategoryTheory.CatEnrichedOrdinary.hComp η (CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct... | false |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram.sup._proof_2 | Mathlib.CategoryTheory.Presentable.Directed | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] {κ : Cardinal.{u_1}}
(D₁ D₂ : CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram J κ) {i j : J} {f : i ⟶ j},
(D₁.W ⊔ D₂.W) f → (D₁.P ⊔ D₂.P) j | false |
_private.Mathlib.Topology.ShrinkingLemma.0.ShrinkingLemma.PartialRefinement.ext.match_1 | Mathlib.Topology.ShrinkingLemma | ∀ {ι : Type u_1} {X : Type u_2} {inst : TopologicalSpace X} {u : ι → Set X} {s : Set X} {p : Set X → Prop}
(motive : ShrinkingLemma.PartialRefinement u s p → Prop) (h : ShrinkingLemma.PartialRefinement u s p),
(∀ (toFun : ι → Set X) (carrier : Set ι) (isOpen : ∀ (i : ι), IsOpen (toFun i)) (subset_iUnion : s ⊆ ⋃ i, ... | false |
CategoryTheory.WithTerminal.opEquiv._proof_34 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] {X Y : CategoryTheory.WithInitial Cᵒᵖ} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(({
obj := fun x =>
match x with
| CategoryTheory.WithInitial.of x => Opposite.op (CategoryTheory.WithTerminal... | false |
_private.Batteries.Classes.SatisfiesM.0.SatisfiesM_EStateM_eq.match_1_1 | Batteries.Classes.SatisfiesM | ∀ {ε σ α : Type u_1} {p : α → Prop} (motive : EStateM.Result ε σ { a // p a } → Prop)
(x : EStateM.Result ε σ { a // p a }),
(∀ (a : { a // p a }) (s' : σ), x = EStateM.Result.ok a s' → motive (EStateM.Result.ok a s')) →
(∀ (e : ε) (s' : σ), x = EStateM.Result.error e s' → motive (EStateM.Result.error e s')) → ... | false |
orderOf_submonoid | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : Monoid G] {H : Submonoid G} (y : ↥H), orderOf ↑y = orderOf y | true |
Aesop.SimpResult.simplified.injEq | Aesop.Search.Expansion.Simp | ∀ (newGoal : Lean.MVarId) (usedTheorems : Lean.Meta.Simp.UsedSimps) (newGoal_1 : Lean.MVarId)
(usedTheorems_1 : Lean.Meta.Simp.UsedSimps),
(Aesop.SimpResult.simplified newGoal usedTheorems = Aesop.SimpResult.simplified newGoal_1 usedTheorems_1) =
(newGoal = newGoal_1 ∧ usedTheorems = usedTheorems_1) | true |
Quotient.instMeasurableSpace | Mathlib.MeasureTheory.MeasurableSpace.Constructions | {α : Type u_6} → {s : Setoid α} → [m : MeasurableSpace α] → MeasurableSpace (Quotient s) | true |
Lean.Elab.Command.Structure.StructParentInfo.mk.sizeOf_spec | Lean.Elab.Structure | ∀ (ref : Lean.Syntax) (addTermInfo : Bool) (fvar : Lean.Expr) (structName name declName : Lean.Name) (subobject : Bool),
sizeOf
{ ref := ref, addTermInfo := addTermInfo, fvar := fvar, structName := structName, name := name,
declName := declName, subobject := subobject } =
1 + sizeOf ref + sizeOf add... | true |
tprod_eq_finprod | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α} {L : SummationFilter β}
[L.LeAtTop], Function.HasFiniteMulSupport f → ∏'[L] (b : β), f b = ∏ᶠ (b : β), f b | true |
List.zipWith4._sunfold | Mathlib.Data.List.Defs | {α : Type u_1} →
{β : Type u_2} →
{γ : Type u_3} → {δ : Type u_4} → {ε : Type u_5} → (α → β → γ → δ → ε) → List α → List β → List γ → List δ → List ε | false |
Int.sub_mul_fdiv_right | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ) {c : ℤ}, c ≠ 0 → (a - b * c).fdiv c = a.fdiv c - b | true |
Std.HashMap.Raw.getElem!_filter_of_getKey?_eq_some | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α] [inst_4 : Inhabited β] {f : α → β → Bool} {k k' : α},
m.WF → m.getKey? k = some k' → (Std.HashMap.Raw.filter f m)[k]! = (Option.filter (fun x => f k' x) m[k]?).get! | true |
VectorPrebundle.toFiberBundle | Mathlib.Topology.VectorBundle.Basic | {R : Type u_1} →
{B : Type u_2} →
{F : Type u_3} →
{E : B → Type u_4} →
[inst : NontriviallyNormedField R] →
[inst_1 : (x : B) → AddCommMonoid (E x)] →
[inst_2 : (x : B) → Module R (E x)] →
[inst_3 : NormedAddCommGroup F] →
[inst_4 : NormedSpace R ... | true |
star_inj | Mathlib.Algebra.Star.Basic | ∀ {R : Type u} [inst : InvolutiveStar R] {x y : R}, star x = star y ↔ x = y | true |
NumberField.RingOfIntegers.mapAlgEquiv | Mathlib.NumberTheory.NumberField.Basic | {k : Type u_3} →
{K : Type u_4} →
{L : Type u_5} →
{E : Type u_6} →
[inst : Field k] →
[inst_1 : Field K] →
[inst_2 : Field L] →
[inst_3 : Algebra k K] →
[inst_4 : Algebra k L] →
[inst_5 : EquivLike E K L] →
[A... | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.equiv_iff_toList_perm._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
FiniteMulArchimedeanClass.ballSubgroup | Mathlib.Algebra.Order.Archimedean.Class | {M : Type u_1} →
[inst : CommGroup M] →
[inst_1 : LinearOrder M] → [inst_2 : IsOrderedMonoid M] → FiniteMulArchimedeanClass M → Subgroup M | true |
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.mk._flat_ctor | Mathlib.CategoryTheory.Monoidal.Action.Basic | {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] →
[inst_2 : CategoryTheory.MonoidalCategoryStruct C] →
(actionObj : D → C → D) →
((d : D) → {c c' : C} → (c ⟶ c') → (actionObj d c ⟶ actionObj d c')... | false |
SheafOfModules.pushforwardCongr._proof_1 | Mathlib.Algebra.Category.ModuleCat.Sheaf.PushforwardContinuous | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {D : Type u_5}
[inst_1 : CategoryTheory.Category.{u_4, u_5} D] {J : CategoryTheory.GrothendieckTopology C}
{K : CategoryTheory.GrothendieckTopology D} {F : CategoryTheory.Functor C D} {S : CategoryTheory.Sheaf J RingCat}
{R : CategoryTheory.Sheaf K Ri... | false |
CategoryTheory.Limits.Cofork.isColimitCoforkPushoutEquivIsColimitForkOpPullback._proof_11 | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : X ⟶ Y}, f.op = f.op | false |
Ideal.univ_eq_iUnion_image_add | Mathlib.RingTheory.Ideal.Quotient.Basic | ∀ {R : Type u_3} [inst : Ring R] (I : Ideal R), Set.univ = ⋃ x, Quotient.out x +ᵥ ↑I | true |
ULift.ring._proof_7 | Mathlib.Algebra.Ring.ULift | ∀ {R : Type u_1} [inst : Ring R] (n : ℕ), IntCast.intCast (Int.negSucc n) = -↑(n + 1) | false |
BooleanSubalgebra.instTop | Mathlib.Order.BooleanSubalgebra | {α : Type u_2} → [inst : BooleanAlgebra α] → Top (BooleanSubalgebra α) | true |
IntervalIntegrable.comp_add_right_iff._auto_1 | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | Lean.Syntax | false |
FGModuleCat.ulift._proof_4 | Mathlib.Algebra.Category.FGModuleCat.Basic | ∀ (R : Type u_1) [inst : Ring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | false |
KaehlerDifferential.tensorKaehlerEquivOfFormallyEtale._proof_1 | Mathlib.RingTheory.Etale.Kaehler | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S], SMulCommClass R S S | false |
Monoid.Coprod.snd_toProd | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : Monoid M] [inst_1 : Monoid N] (x : Monoid.Coprod M N),
(Monoid.Coprod.toProd x).2 = Monoid.Coprod.snd x | true |
starNormedAddGroupHom._proof_2 | Mathlib.Analysis.CStarAlgebra.Basic | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] [inst_1 : StarAddMonoid E] [NormedStarGroup E],
∃ C, ∀ (v : E), ‖starAddEquiv.toFun v‖ ≤ C * ‖v‖ | false |
SubgroupClass.toSubmonoidClass | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {S : Type u_3} {G : outParam (Type u_4)} {inst : DivInvMonoid G} {inst_1 : SetLike S G} [self : SubgroupClass S G],
SubmonoidClass S G | true |
_private.Mathlib.RingTheory.Spectrum.Prime.Topology.0.PrimeSpectrum.isLocalization_away_iff_atPrime_of_basicOpen_eq_singleton._simp_1_1 | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {α : Type u} [inst : CommSemiring α] {x y : α}, (y ∣ x) = (x ∈ Ideal.span {y}) | false |
Std.Do.«termWp⟦_:_⟧» | Std.Do.WP.Basic | Lean.ParserDescr | true |
Aesop._aux_Aesop_Util_Tactic_Unfold___elabRules_Aesop_tacticAesop_unfold_At__1 | Aesop.Util.Tactic.Unfold | Lean.Elab.Tactic.Tactic | false |
OrderEmbedding.locallyFiniteOrder._proof_3 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : LocallyFiniteOrder β] (f : α ↪o β)
(a b x : α), x ∈ (Finset.Ioc (f a) (f b)).preimage ⇑f ⋯ ↔ a < x ∧ x ≤ b | false |
_private.Mathlib.Order.Filter.Bases.Basic.0.Filter.hasBasis_iSup._simp_1_4 | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u} {ι : Sort x} {x : Set α} {f : ι → Filter α}, (x ∈ iSup f) = ∀ (i : ι), x ∈ f i | false |
_private.Mathlib.Analysis.Complex.Order.0.Mathlib.Meta.Positivity.evalComplexOfReal.match_1 | Mathlib.Analysis.Complex.Order | (motive :
(u : Lean.Level) →
{α : Q(Type u)} →
(x : Q(Zero «$α»)) →
(x_1 : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness x x_1 e) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness x x_1 e) → Sort u_1) →
(u : ... | false |
Std.DTreeMap.Internal.Impl.getKeyD_union!_of_contains_eq_false_right | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
m₁.WF →
m₂.WF →
∀ {k fallback : α},
Std.DTreeMap.Internal.Impl.contains k m₂ = false → (m₁.union! m₂).getKeyD k fallback = m₁.getKeyD k fallback | true |
Std.Iterators.Types.TakeWhile.instFinite | Std.Data.Iterators.Combinators.Monadic.TakeWhile | ∀ {α : Type w} {m : Type w → Type w'} {β : Type w} [inst : Monad m] [inst_1 : Std.Iterator α m β]
[Std.Iterators.Finite α m] {P : β → Std.Iterators.PostconditionT m (ULift.{w, 0} Bool)},
Std.Iterators.Finite (Std.Iterators.Types.TakeWhile α m β P) m | true |
Lean.Language.SnapshotTask.ReportingRange.casesOn | Lean.Language.Basic | {motive : Lean.Language.SnapshotTask.ReportingRange → Sort u} →
(t : Lean.Language.SnapshotTask.ReportingRange) →
motive Lean.Language.SnapshotTask.ReportingRange.inherit →
((range : Lean.Syntax.Range) → motive (Lean.Language.SnapshotTask.ReportingRange.some range)) →
motive Lean.Language.SnapshotTa... | false |
Lean.Grind.CommRing.Stepwise.div_certC | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Poly → ℤ → Lean.Grind.CommRing.Poly → ℕ → Bool | true |
IsAlgClosed.cardinal_eq_cardinal_transcendence_basis_of_aleph0_lt' | Mathlib.FieldTheory.IsAlgClosed.Classification | ∀ {R : Type u} [inst : CommRing R] {K' : Type u} [inst_1 : Field K'] [inst_2 : Algebra R K'] [IsAlgClosed K']
{ι' : Type u} (v' : ι' → K') [Nontrivial R],
IsTranscendenceBasis R v' →
Cardinal.mk R ≤ Cardinal.aleph0 → Cardinal.aleph0 < Cardinal.mk K' → Cardinal.mk K' = Cardinal.mk ι' | true |
Lean.MacroScopesView.isPrefixOf | Lean.Data.NameMap.Basic | Lean.MacroScopesView → Lean.MacroScopesView → Bool | true |
Aesop.RegularRule._sizeOf_inst | Aesop.Rule | SizeOf Aesop.RegularRule | false |
CategoryTheory.Functor.Monoidal.μIso | Mathlib.CategoryTheory.Monoidal.Functor | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategory D] →
(F : CategoryTheory.Functor C D) →
[F.Monoid... | true |
CategoryTheory.MorphismProperty.HasLocalization.ctorIdx | Mathlib.CategoryTheory.Localization.HasLocalization | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} → {W : CategoryTheory.MorphismProperty C} → W.HasLocalization → ℕ | false |
ApproximatesLinearOn.surjective | Mathlib.Analysis.Calculus.InverseFunctionTheorem.ApproximatesLinearOn | ∀ {𝕜 : 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}
{f' : E ≃L[𝕜] F} {c : NNReal} [CompleteSpace E],
ApproximatesLinearOn f (↑f') Set.univ c → Subsin... | true |
Std.Rco.HasRcoIntersection.casesOn | Init.Data.Range.Polymorphic.PRange | {α : Type w} →
{motive : Std.Rco.HasRcoIntersection α → Sort u} →
(t : Std.Rco.HasRcoIntersection α) →
((intersection : Std.Rco α → Std.Rco α → Std.Rco α) → motive { intersection := intersection }) → motive t | false |
_private.Mathlib.Topology.EMetricSpace.BoundedVariation.0.BoundedVariationOn.exists_tendsto_left._simp_1_2 | Mathlib.Topology.EMetricSpace.BoundedVariation | ∀ {α : Sort u_3} {P : Prop}, (∃ x, P) = (Nonempty α ∧ P) | false |
Lean.Elab.Tactic.evalMatch._regBuiltin.Lean.Elab.Tactic.evalMatch.declRange_3 | Lean.Elab.Tactic.Match | IO Unit | false |
CategoryTheory.SmallObject.SuccStruct.Iteration.trunc._proof_3 | Mathlib.CategoryTheory.SmallObject.Iteration.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} C] {J : Type u_1}
{Φ : CategoryTheory.SmallObject.SuccStruct C} [inst_1 : LinearOrder J] [inst_2 : SuccOrder J] [inst_3 : OrderBot J]
[inst_4 : CategoryTheory.Limits.HasIterationOfShape J C] [inst_5 : WellFoundedLT J] {j : J} (iter : Φ.Iteration j)
{j' :... | false |
_private.Mathlib.Algebra.MonoidAlgebra.NoZeroDivisors.0.MonoidAlgebra.mul_apply_mul_eq_mul_of_uniqueMul._simp_1_1 | Mathlib.Algebra.MonoidAlgebra.NoZeroDivisors | ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_5} [inst : AddCommMonoid β] (s : Finset γ) (t : Finset α) (f : γ → α → β),
∑ x ∈ s, ∑ y ∈ t, f x y = ∑ x ∈ s ×ˢ t, f x.1 x.2 | false |
Fin.castSucc_ne_zero_of_lt | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} {p i : Fin n}, p < i → i.castSucc ≠ 0 | true |
Array.append_eq_append_iff_of_size_eq_right | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {ws xs ys zs : Array α}, ys.size = zs.size → (ws ++ ys = xs ++ zs ↔ ws = xs ∧ ys = zs) | true |
Lean.Grind.Order.lt_eq_false_of_lt | Init.Grind.Order | ∀ {α : Type u_1} [inst : LE α] [inst_1 : LT α] [Std.LawfulOrderLT α] [Std.IsPreorder α] {a b : α},
a < b → (b < a) = False | true |
Lean.NameTrie | Lean.Data.NameTrie | Type u → Type u | true |
InnerProductSpaceable.inner_.conj_symm | Mathlib.Analysis.InnerProductSpace.OfNorm | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] (x y : E),
(starRingEnd 𝕜) (inner_✝ 𝕜 y x) = inner_✝¹ 𝕜 x y | true |
_private.Mathlib.Data.Set.Card.0.Set.encard_le_one_iff.match_1_1 | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Set α} (motive : s.Nonempty → Prop) (x : s.Nonempty),
(∀ (x : α) (hx : x ∈ s), motive ⋯) → motive x | false |
Array.PrefixTable.mk | Batteries.Data.Array.Match | {α : Type u_1} → (toArray : Array (α × ℕ)) → (∀ {i : ℕ} (h : i < toArray.size), toArray[i].2 ≤ i) → Array.PrefixTable α | true |
UV.mem_compression | Mathlib.Combinatorics.SetFamily.Compression.UV | ∀ {α : Type u_1} [inst : GeneralizedBooleanAlgebra α] [inst_1 : DecidableRel Disjoint] [inst_2 : DecidableLE α]
{s : Finset α} {u v a : α} [inst_3 : DecidableEq α],
a ∈ UV.compression u v s ↔ a ∈ s ∧ UV.compress u v a ∈ s ∨ a ∉ s ∧ ∃ b ∈ s, UV.compress u v b = a | true |
Aesop.initFn._@.Aesop.Options.Public.1566740328._hygCtx._hyg.4 | Aesop.Options.Public | IO (Lean.Option Bool) | false |
Subgroup.instMulDistribMulActionSubtypeMemNormalizerCoe._proof_2 | Mathlib.GroupTheory.Subgroup.Centralizer | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) (g : ↥H), 1 • g = g | false |
Lean.Lsp.RenameParams.toTextDocumentPositionParams | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.RenameParams → Lean.Lsp.TextDocumentPositionParams | true |
_private.Lean.Meta.Tactic.Replace.0.Lean.Meta.replaceLocalDeclCore.findMaxFVar | Lean.Meta.Tactic.Replace | Lean.Expr → StateRefT' IO.RealWorld Lean.LocalDecl Lean.MetaM Unit | true |
ErgodicVAdd.mk._flat_ctor | Mathlib.Dynamics.Ergodic.Action.Basic | ∀ {G : Type u_1} {α : Type u_2} [inst : VAdd G α] {x : MeasurableSpace α} {μ : MeasureTheory.Measure α},
(∀ (c : G) ⦃s : Set α⦄, MeasurableSet s → μ ((fun x => c +ᵥ x) ⁻¹' s) = μ s) →
(∀ {s : Set α},
MeasurableSet s →
(∀ (g : G), (fun x => g +ᵥ x) ⁻¹' s =ᵐ[μ] s) → Filter.EventuallyConst s (Measu... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.