name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Std.DTreeMap.Const.ordCompare_minKeyD_modify_eq | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} [inst : Ord α] [Std.TransOrd α] {t : Std.DTreeMap α (fun x => β) compare} {k : α}
{f : β → β} {fallback : α},
compare ((Std.DTreeMap.Const.modify t k f).minKeyD fallback) (t.minKeyD fallback) = Ordering.eq | true |
_private.Mathlib.Algebra.Lie.Submodule.0.LieSubmodule.instIsNoetherianSubtypeMem._proof_1 | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u_1} {L : Type u_3} {M : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] [IsNoetherian R M] (N : LieSubmodule R L M), IsNoetherian R ↥N | false |
OrderDual.instAddLeftCancelSemigroup | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [h : AddLeftCancelSemigroup α] → AddLeftCancelSemigroup αᵒᵈ | true |
CategoryTheory.Limits.Multicofork.isoOfπ_inv_hom | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape}
{I : CategoryTheory.Limits.MultispanIndex J C} (t : CategoryTheory.Limits.Multicofork I),
t.isoOfπ.inv.hom = CategoryTheory.CategoryStruct.id t.pt | true |
Lean.DeclNameGenerator.recOn | Lean.CoreM | {motive : Lean.DeclNameGenerator → Sort u} →
(t : Lean.DeclNameGenerator) →
((namePrefix : Lean.Name) →
(idx : ℕ) → (parentIdxs : List ℕ) → motive { namePrefix := namePrefix, idx := idx, parentIdxs := parentIdxs }) →
motive t | false |
SkewMonoidAlgebra.single_left_inj | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddMonoid k] {a a' : G} {b : k},
b ≠ 0 → (SkewMonoidAlgebra.single a b = SkewMonoidAlgebra.single a' b ↔ a = a') | true |
_private.Lean.Elab.PreDefinition.Structural.IndPred.0.Lean.Elab.Structural.replaceIndPredRecApps.loop._sparseCasesOn_10 | Lean.Elab.PreDefinition.Structural.IndPred | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(... | false |
_private.Init.Data.FloatArray.Basic.0.FloatArray.ext.match_1 | Init.Data.FloatArray.Basic | ∀ (motive : FloatArray → Prop) (h : FloatArray), (∀ (data : Array Float), motive { data := data }) → motive h | false |
Fin.image_natAdd_Ici | Mathlib.Order.Interval.Set.Fin | ∀ {n : ℕ} (m : ℕ) (i : Fin n), Fin.natAdd m '' Set.Ici i = Set.Ici (Fin.natAdd m i) | true |
LinearMap.iInfKerProjEquiv._proof_2 | Mathlib.LinearAlgebra.Pi | ∀ (R : Type u_3) {ι : Type u_2} [inst : Semiring R] (φ : ι → Type u_1) [inst_1 : (i : ι) → AddCommMonoid (φ i)]
[inst_2 : (i : ι) → Module R (φ i)] {I J : Set ι} [inst_3 : DecidablePred fun i => i ∈ I] (hd : Disjoint I J),
(LinearMap.pi fun i => LinearMap.proj ↑i ∘ₗ (⨅ i ∈ J, (LinearMap.proj i).ker).subtype) ∘ₗ
... | false |
Polynomial.eq_of_dvd_of_natDegree_le_of_leadingCoeff | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} [inst : CommRing R] [IsDomain R] {p q : Polynomial R},
p ∣ q → q.natDegree ≤ p.natDegree → p.leadingCoeff = q.leadingCoeff → p = q | true |
tendsto_of_no_upcrossings._auto_3 | Mathlib.Topology.Order.LiminfLimsup | Lean.Syntax | false |
Set.indicator_smul_apply_left | Mathlib.Algebra.Module.Basic | ∀ {α : Type u_1} {R : Type u_2} {M : Type u_3} [inst : Zero R] [inst_1 : Zero M] [inst_2 : SMulWithZero R M] (s : Set α)
(r : α → R) (f : α → M) (a : α), s.indicator (fun a => r a • f a) a = s.indicator r a • f a | true |
Set.preimage_sumElim | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (s : Set γ) (f : α → γ) (g : β → γ),
Sum.elim f g ⁻¹' s = Sum.inl '' (f ⁻¹' s) ∪ Sum.inr '' (g ⁻¹' s) | true |
Std.DTreeMap.Internal.Impl.ExplorationStep.gt.elim | Std.Data.DTreeMap.Internal.Model | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
{k : α → Ordering} →
{motive : Std.DTreeMap.Internal.Impl.ExplorationStep α β k → Sort u_1} →
(t : Std.DTreeMap.Internal.Impl.ExplorationStep α β k) →
t.ctorIdx = 2 →
((a : List ((a : α) × β a)) →
... | false |
_private.Mathlib.MeasureTheory.Covering.Differentiation.0.VitaliFamily.ae_tendsto_div._simp_1_6 | Mathlib.MeasureTheory.Covering.Differentiation | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | false |
Module.finrank_pos | Mathlib.LinearAlgebra.Dimension.Finite | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [StrongRankCondition R]
[Module.Finite R M] [IsDomain R] [Module.IsTorsionFree R M] [h : Nontrivial M], 0 < Module.finrank R M | true |
_private.Lean.Elab.Tactic.Omega.MinNatAbs.0.Lean.Elab.Tactic.Omega.List.minNatAbs.eq_1 | Lean.Elab.Tactic.Omega.MinNatAbs | ∀ (xs : List ℤ),
Lean.Elab.Tactic.Omega.List.minNatAbs xs = Lean.Elab.Tactic.Omega.List.nonzeroMinimum (List.map Int.natAbs xs) | true |
Lean.Lsp.ServerCapabilities.foldingRangeProvider | Lean.Data.Lsp.Capabilities | Lean.Lsp.ServerCapabilities → Bool | true |
GradedRingHom.instMonoid._proof_4 | Mathlib.RingTheory.GradedAlgebra.RingHom | ∀ {ι : Type u_1} {A : Type u_2} {σ : Type u_3} [inst : Semiring A] [inst_1 : SetLike σ A] {𝒜 : ι → σ} (x : ℕ)
(x_1 : 𝒜 →+*ᵍ 𝒜), (npowRec (x + 1) x_1).copy (⇑x_1)^[x + 1] ⋯ = (npowRec x x_1).copy (⇑x_1)^[x] ⋯ * x_1 | false |
Finsupp.smul_apply | Mathlib.Data.Finsupp.SMulWithZero | ∀ {α : Type u_1} {M : Type u_5} {R : Type u_11} [inst : Zero M] [inst_1 : SMulZeroClass R M] (b : R) (v : α →₀ M)
(a : α), (b • v) a = b • v a | true |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.isPatternFnCandidate.match_1 | Lean.Meta.Tactic.Grind.EMatchTheorem | (motive : Lean.Expr → Sort u_1) →
(f : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) → ((x : Lean.Expr) → motive x) → motive f | false |
Lean.Lsp.DocumentChange.edit.injEq | Lean.Data.Lsp.Basic | ∀ (a a_1 : Lean.Lsp.TextDocumentEdit), (Lean.Lsp.DocumentChange.edit a = Lean.Lsp.DocumentChange.edit a_1) = (a = a_1) | true |
BitVec.equivFin | Mathlib.Data.BitVec | {m : ℕ} → BitVec m ≃+* Fin (2 ^ m) | true |
CategoryTheory.Functor.uliftYonedaReprXIso_hom_app | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (F : CategoryTheory.Functor Cᵒᵖ (Type (max v v₁)))
[inst_1 : F.IsRepresentable] (X : Cᵒᵖ) (f : ULift.{v, v₁} (Opposite.unop X ⟶ F.reprX)),
F.uliftYonedaReprXIso.hom.app X f = F.map f.down.op F.reprx | true |
ModularGroup.cases_of_mem_fd_smul_mem_fd | Mathlib.NumberTheory.Modular | ∀ {g : Matrix.SpecialLinearGroup (Fin 2) ℤ} {z : UpperHalfPlane},
z ∈ ModularGroup.fd →
g • z ∈ ModularGroup.fd →
(g = 1 ∨ g = -1) ∨
(g = ModularGroup.T ∨ g = -ModularGroup.T) ∧ z.re = -1 / 2 ∨
(g = ModularGroup.T⁻¹ ∨ g = -ModularGroup.T⁻¹) ∧ z.re = 1 / 2 ∨
(g = ModularGroup.S ... | true |
_private.Mathlib.Data.Fin.Tuple.Reflection.0.FinVec.exists_iff._simp_1_6 | Mathlib.Data.Fin.Tuple.Reflection | ∀ {α : Fin 0 → Sort u_1} {P : ((i : Fin 0) → α i) → Prop}, (∃ x, P x) = P finZeroElim | false |
IsLocalizedModule.mk'_cancel | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Submonoid R} {M : Type u_2} {M' : Type u_3} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M'] [inst_3 : Module R M] [inst_4 : Module R M'] (f : M →ₗ[R] M')
[inst_5 : IsLocalizedModule S f] (m : M) (s : ↥S), IsLocalizedModule.mk' f (s • m) s = f m | true |
Mathlib.Meta.Positivity.compareHyp | Mathlib.Tactic.Positivity.Core | {u : Lean.Level} →
{α : Q(Type u)} →
(zα : Q(Zero «$α»)) →
(pα : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) → Lean.LocalDecl → Lean.MetaM (Mathlib.Meta.Positivity.Strictness zα pα e) | true |
Dyadic.roundDown_le | Init.Data.Dyadic.Round | ∀ {x : Dyadic} {prec : ℤ}, x.roundDown prec ≤ x | true |
Module.Finite.of_isLocalizedModule | Mathlib.RingTheory.Localization.Finiteness | ∀ {R : Type u} [inst : CommSemiring R] (S : Submonoid R) {Rₚ : Type v} [inst_1 : CommSemiring Rₚ]
[inst_2 : Algebra R Rₚ] [IsLocalization S Rₚ] {M : Type w} [inst_4 : AddCommMonoid M] [inst_5 : Module R M]
{Mₚ : Type t} [inst_6 : AddCommMonoid Mₚ] [inst_7 : Module R Mₚ] [inst_8 : Module Rₚ Mₚ] [IsScalarTower R Rₚ M... | true |
_private.Mathlib.MeasureTheory.Function.ConditionalExpectation.Real.0.MeasureTheory.setIntegral_abs_condExp_le._simp_1_1 | Mathlib.MeasureTheory.Function.ConditionalExpectation.Real | ∀ (r : ℝ), |r| = ‖r‖ | false |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.preprocess.norm._f | Lean.Meta.SynthInstance | Lean.Expr → Array ℕ → Lean.Expr → (e : Lean.Expr) → Lean.Expr.below (motive := fun e => ℕ → Lean.Expr) e → ℕ → Lean.Expr | false |
Ordnode.eraseMin | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → Ordnode α → Ordnode α | true |
InfHom.toFun_eq_coe | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Min α] [inst_1 : Min β] (f : InfHom α β), f.toFun = ⇑f | true |
UniformOnFun.ofFun_div | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} [inst : Div β] (f g : α → β),
(UniformOnFun.ofFun 𝔖) (f / g) = (UniformOnFun.ofFun 𝔖) f / (UniformOnFun.ofFun 𝔖) g | true |
Mathlib.Tactic.ToAdditive.initFn._@.Mathlib.Tactic.Translate.ToAdditive.2527625364._hygCtx._hyg.2 | Mathlib.Tactic.Translate.ToAdditive | IO (Lean.NameMapExtension (List ℕ)) | false |
measurableSet_integrable | Mathlib.MeasureTheory.Integral.Prod | ∀ {α : Type u_1} {β : Type u_2} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
{ν : MeasureTheory.Measure β} [inst_2 : NormedAddCommGroup E] [MeasureTheory.SFinite ν] ⦃f : α → β → E⦄,
MeasureTheory.StronglyMeasurable (Function.uncurry f) → MeasurableSet {x | MeasureTheory.Integrable (f x) ν} | true |
_private.Mathlib.LinearAlgebra.Orientation.0.Orientation.eq_or_eq_neg_of_isEmpty._simp_1_1 | Mathlib.LinearAlgebra.Orientation | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : PartialOrder R] [inst_2 : IsStrictOrderedRing R] {M : Type u_2}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] {v₁ v₂ : M} (hv₁ : v₁ ≠ 0) (hv₂ : v₂ ≠ 0),
(rayOfNeZero R v₁ hv₁ = rayOfNeZero R v₂ hv₂) = SameRay R v₁ v₂ | false |
CliffordAlgebra.EquivEven.neg_e0_mul_v | Mathlib.LinearAlgebra.CliffordAlgebra.EvenEquiv | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M) (m : M),
-(CliffordAlgebra.EquivEven.e0 Q * (CliffordAlgebra.EquivEven.v Q) m) =
(CliffordAlgebra.EquivEven.v Q) m * CliffordAlgebra.EquivEven.e0 Q | true |
CategoryTheory.MonoidalCategory.MonoidalRightAction.inv_actionHomLeft | 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.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] {x y : D} (f : x ⟶ y)
[inst_4 : CategoryTheory.IsIso f] (z : C),
CategoryT... | true |
InnerProductGeometry.angle_sub_eq_arccos_of_inner_eq_zero | Mathlib.Geometry.Euclidean.Angle.Unoriented.RightAngle | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x y : V},
inner ℝ x y = 0 → InnerProductGeometry.angle x (x - y) = Real.arccos (‖x‖ / ‖x - y‖) | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.mul_tmod._simp_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ (n m : ℕ), ↑n * ↑m = ↑(n * m) | false |
_private.Mathlib.FieldTheory.PerfectClosure.0.PerfectClosure.mul_aux_left.match_1_1 | Mathlib.FieldTheory.PerfectClosure | ∀ (K : Type u_1) [inst : CommRing K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p]
(motive : (x1 x2 : ℕ × K) → PerfectClosure.R K p x1 x2 → Prop) (x1 x2 : ℕ × K) (H : PerfectClosure.R K p x1 x2),
(∀ (n : ℕ) (x : K), motive (n, x) (n + 1, (frobenius K p) x) ⋯) → motive x1 x2 H | false |
_private.Init.Data.Int.DivMod.Bootstrap.0.Int.natAbs_dvd_natAbs.match_1_3 | Init.Data.Int.DivMod.Bootstrap | ∀ {a b : ℤ} (motive : a ∣ b → Prop) (x : a ∣ b), (∀ (k : ℤ) (hk : b = a * k), motive ⋯) → motive x | false |
_private.Mathlib.GroupTheory.FreeGroup.CyclicallyReduced.0.FreeGroup.instIsMulTorsionFree._proof_3 | Mathlib.GroupTheory.FreeGroup.CyclicallyReduced | ∀ {α : Type u_1} (x y : FreeGroup α),
FreeGroup.reduceCyclically.conjugator x.toWord = FreeGroup.reduceCyclically.conjugator y.toWord →
∀ (n : ℕ),
(fun a n =>
(FreeGroup.reduceCyclically.conjugator a.toWord).length +
(n * (FreeGroup.reduceCyclically a.toWord).length +
... | false |
CategoryTheory.Limits.inr_comp_pushoutSymmetry_inv | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z)
[inst_1 : CategoryTheory.Limits.HasPushout f g],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inr g f)
(CategoryTheory.Limits.pushoutSymmetry f g).inv =
CategoryTheory.Limits.pushout.inl f g | true |
ProbabilityTheory.gammaPDF.eq_1 | Mathlib.Probability.Distributions.Gamma | ∀ (a r x : ℝ), ProbabilityTheory.gammaPDF a r x = ENNReal.ofReal (ProbabilityTheory.gammaPDFReal a r x) | true |
OnePoint.continuousMapNatEquiv._proof_6 | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ (Y : Type u_1) [inst : TopologicalSpace Y] (f : ℕ → Y),
(∃ L, Filter.Tendsto (fun x => f x) Filter.atTop (nhds L)) →
∃ L, Filter.Tendsto (fun x => f x) Filter.cofinite (nhds L) | false |
Std.ExtHashSet.emptyWithCapacity_eq | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [EquivBEq α] [LawfulHashable α] {c : ℕ},
Std.ExtHashSet.emptyWithCapacity c = ∅ | true |
Lean.CodeAction.FindTacticResult.recOn | Lean.Server.CodeActions.Provider | {motive : Lean.CodeAction.FindTacticResult → Sort u} →
(t : Lean.CodeAction.FindTacticResult) →
((a : Lean.Syntax.Stack) → motive (Lean.CodeAction.FindTacticResult.tactic a)) →
((preferred : Bool) →
(insertIdx : ℕ) →
(a : Lean.Syntax.Stack) → motive (Lean.CodeAction.FindTacticResult.ta... | false |
UInt8.ofInt_neg_one | Init.Data.UInt.Lemmas | UInt8.ofInt (-1) = -1 | true |
addAddHom._proof_1 | Mathlib.Algebra.Group.Prod | ∀ {α : Type u_1} [inst : AddCommSemigroup α] (x x_1 : α × α), x.1 + x_1.1 + (x.2 + x_1.2) = x.1 + x.2 + (x_1.1 + x_1.2) | false |
_private.Mathlib.Data.ZMod.Basic.0.ZMod.lift_injective._simp_1_1 | Mathlib.Data.ZMod.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {M : Type u_7} [inst_1 : AddZeroClass M] (f : G →+ M),
Function.Injective ⇑f = (f.ker = ⊥) | false |
_private.Mathlib.Analysis.Convex.Deriv.0.StrictMonoOn.exists_deriv_lt_slope._simp_1_2 | Mathlib.Analysis.Convex.Deriv | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddRightStrictMono α] {a b : α}, (0 < a - b) = (b < a) | false |
CategoryTheory.mkTerminalOfRightAdjoint._proof_2 | Mathlib.CategoryTheory.Adjunction.Comma | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (G : CategoryTheory.Functor D C) {F : CategoryTheory.Functor C D}
(h : F ⊣ G) (A : D)
(B : CategoryTheory.Limits.Cone (CategoryTheory.Functor.empty (CategoryTheory.CostructuredArrow F A)))... | false |
Std.HashSet.contains_congr | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashSet α} [EquivBEq α] [LawfulHashable α] {a b : α},
(a == b) = true → m.contains a = m.contains b | true |
CategoryTheory.GlueData'.noConfusion | Mathlib.CategoryTheory.GlueData | {P : Sort u} →
{C : Type u₁} →
{inst : CategoryTheory.Category.{v, u₁} C} →
{t : CategoryTheory.GlueData' C} →
{C' : Type u₁} →
{inst' : CategoryTheory.Category.{v, u₁} C'} →
{t' : CategoryTheory.GlueData' C'} →
C = C' → inst ≍ inst' → t ≍ t' → CategoryTheory.Glue... | false |
StandardEtalePair.mk.noConfusion | Mathlib.RingTheory.Etale.StandardEtale | {R : Type u_1} →
{inst : CommRing R} →
{P : Sort u} →
{f : Polynomial R} →
{monic_f : f.Monic} →
{g : Polynomial R} →
{cond : ∃ p₁ p₂ n, Polynomial.derivative f * p₁ + f * p₂ = g ^ n} →
{f' : Polynomial R} →
{monic_f' : f'.Monic} →
... | false |
LinearMap.toContinuousLinearMap._proof_11 | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u_1} [hnorm : NontriviallyNormedField 𝕜] {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
[inst_2 : TopologicalSpace E] [inst_3 : IsTopologicalAddGroup E] [inst_4 : ContinuousSMul 𝕜 E] {F' : Type u_3}
[inst_5 : AddCommGroup F'] [inst_6 : Module 𝕜 F'] [inst_7 : TopologicalSpace F'] [inst... | false |
AlgebraicGeometry.ExistsHomHomCompEqCompAux.𝒰D₀._proof_3 | Mathlib.AlgebraicGeometry.AffineTransitionLimit | ∀ {I : Type u_1} [inst : CategoryTheory.Category.{u_1, u_1} I] {S X : AlgebraicGeometry.Scheme}
{D : CategoryTheory.Functor I AlgebraicGeometry.Scheme} {t : D ⟶ (CategoryTheory.Functor.const I).obj S} {f : X ⟶ S}
[inst_1 : ∀ (i : I), CompactSpace ↥(D.obj i)] [inst_2 : CategoryTheory.IsCofiltered I]
[inst_3 : ∀ {i... | false |
RingPreordering.mem_toSubsemiring | Mathlib.Algebra.Order.Ring.Ordering.Defs | ∀ {R : Type u_1} [inst : CommRing R] {P : RingPreordering R} {x : R}, x ∈ ↑P ↔ x ∈ P | true |
instPolynormableSpace | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ {𝕜 : Type u_2} {E : Type u_6} [inst : NormedField 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E],
PolynormableSpace 𝕜 E | true |
_private.Mathlib.MeasureTheory.Group.FundamentalDomain.0.MeasureTheory.IsFundamentalDomain.quotientMeasure_eq._simp_1_1 | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | false |
Std.Tactic.BVDecide.BVExpr.decEq._proof_51 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} (lval : BitVec w) (w_1 start : ℕ) (expr : Std.Tactic.BVDecide.BVExpr w_1),
¬Std.Tactic.BVDecide.BVExpr.const lval = Std.Tactic.BVDecide.BVExpr.extract start w expr | false |
System.Platform.sixteen_le_numBits._simp_1 | Init.System.Platform | (16 ≤ System.Platform.numBits) = True | false |
CategoryTheory.instPreadditiveOppositeShift | Mathlib.CategoryTheory.Shift.Opposite | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
(A : Type u_2) →
[inst_1 : AddMonoid A] →
[inst_2 : CategoryTheory.HasShift C A] →
[CategoryTheory.Preadditive C] → CategoryTheory.Preadditive (CategoryTheory.OppositeShift C A) | true |
CategoryTheory.Triangulated.TStructure.triangleLEGE_obj_mor₃ | 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 |
CategoryTheory.Adjunction.unit_app_shift_commShiftIso_inv_app | Mathlib.CategoryTheory.Shift.Adjunction | ∀ {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] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : F ⊣ G) (A : Type u_3) [inst_2 : AddMonoid A] [inst_3 : CategoryTheory.HasShift C A]
[inst_4 : CategoryTheory.HasShi... | true |
Multipliable.le_tprod' | Mathlib.Topology.Algebra.InfiniteSum.Order | ∀ {ι : Type u_1} {α : Type u_3} [inst : CommMonoid α] [inst_1 : PartialOrder α] [IsOrderedMonoid α]
[CanonicallyOrderedMul α] [inst_4 : TopologicalSpace α] [OrderClosedTopology α] {f : ι → α},
Multipliable f → ∀ (i : ι), f i ≤ ∏' (i : ι), f i | true |
TrivSqZeroExt.isUnit_iff_isUnit_fst | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u} {M : Type v} [inst : AddCommGroup M] [inst_1 : Semiring R] [inst_2 : Module Rᵐᵒᵖ M] [inst_3 : Module R M]
[inst_4 : SMulCommClass R Rᵐᵒᵖ M] {x : TrivSqZeroExt R M}, IsUnit x ↔ IsUnit x.fst | true |
Multiset.sub_cons | Mathlib.Data.Multiset.AddSub | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s t : Multiset α), s - a ::ₘ t = s.erase a - t | true |
_private.Mathlib.Analysis.Normed.Lp.PiLp.0.PiLp.lipschitzWith_ofLp_aux._simp_1_2 | Mathlib.Analysis.Normed.Lp.PiLp | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True | false |
inv_smul_le_iff_of_neg | Mathlib.Algebra.Order.Module.Field | ∀ {𝕜 : Type u_1} {G : Type u_2} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : AddCommGroup G] [inst_4 : PartialOrder G] [IsOrderedAddMonoid G] [inst_6 : Module 𝕜 G] {a : 𝕜} {b₁ b₂ : G}
[PosSMulMono 𝕜 G], a < 0 → (a⁻¹ • b₁ ≤ b₂ ↔ a • b₂ ≤ b₁) | true |
Set.image_inv_of_apply_inv_eq | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : InvolutiveInv α] {s : Set α} {f g : α → β},
(∀ x ∈ s, f x⁻¹ = g x) → f '' s⁻¹ = g '' s | true |
Std.Tactic.BVDecide.BVExpr.eval_shiftLeft | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {assign : Std.Tactic.BVDecide.BVExpr.Assignment} {a : ℕ} {lhs : Std.Tactic.BVDecide.BVExpr a} {a_1 : ℕ}
{rhs : Std.Tactic.BVDecide.BVExpr a_1},
Std.Tactic.BVDecide.BVExpr.eval assign (lhs.shiftLeft rhs) =
Std.Tactic.BVDecide.BVExpr.eval assign lhs <<< Std.Tactic.BVDecide.BVExpr.eval assign rhs | true |
MeasureTheory.ae_le_of_forall_setIntegral_le | Mathlib.MeasureTheory.Function.AEEqOfIntegral | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → ℝ},
MeasureTheory.Integrable f μ →
MeasureTheory.Integrable g μ →
(∀ (s : Set α), MeasurableSet s → μ s < ⊤ → ∫ (x : α) in s, f x ∂μ ≤ ∫ (x : α) in s, g x ∂μ) → f ≤ᵐ[μ] g | true |
CategoryTheory.Oplax.OplaxTrans.naturality_naturality._autoParam | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | Lean.Syntax | false |
FintypeCat | Mathlib.CategoryTheory.FintypeCat | Type (u_1 + 1) | true |
_private.Mathlib.CategoryTheory.Sites.Coverage.0.CategoryTheory.Presheaf.isSheaf_iff_isLimit_coverage._simp_1_4 | Mathlib.CategoryTheory.Sites.Coverage | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : C}
(R : CategoryTheory.Presieve X),
CategoryTheory.Presieve.IsSheafFor P (CategoryTheory.Sieve.generate R).arrows = CategoryTheory.Presieve.IsSheafFor P R | false |
ContinuousAffineEquiv.Simps.apply | Mathlib.Topology.Algebra.ContinuousAffineEquiv | {k : Type u_1} →
{P₁ : Type u_2} →
{P₂ : Type u_3} →
{V₁ : Type u_6} →
{V₂ : Type u_7} →
[inst : Ring k] →
[inst_1 : AddCommGroup V₁] →
[inst_2 : Module k V₁] →
[inst_3 : AddTorsor V₁ P₁] →
[inst_4 : TopologicalSpace P₁] →
... | true |
CategoryTheory.Limits.biprod.add_eq_lift_desc_id | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C} (f g : X ⟶ Y)
[inst_2 : CategoryTheory.Limits.HasBinaryBiproduct Y Y],
f + g =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.lift f g)
(CategoryTheory.Limits.biprod.desc (CategoryT... | true |
CategoryTheory.WithTerminal.liftUnique | Mathlib.CategoryTheory.WithTerminal.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type u_1} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] →
{Z : D} →
(F : CategoryTheory.Functor C D) →
(M : (x : C) → F.obj x ⟶ Z) →
(hM : ∀ (x y : C) (f : x ⟶ y), CategoryTheory.CategoryStruct.co... | true |
CommMonCat.coyonedaType_obj_obj_coe | Mathlib.Algebra.Category.MonCat.Yoneda | ∀ (X : Type uᵒᵖ) (M : CommMonCat), ↑((CommMonCat.coyonedaType.obj X).obj M) = (Opposite.unop X → ↑M) | true |
RingTheory.Sequence.IsWeaklyRegular.recIterModByRegularWithRing._unary._proof_31 | Mathlib.RingTheory.Regular.RegularSequence | ∀ (R : Type u_1) (inst : CommRing R)
(M :
(x : Type u_2) ×'
(x_1 : AddCommGroup x) ×' (x_2 : Module R x) ×' (x_3 : List R) ×' RingTheory.Sequence.IsWeaklyRegular x x_3),
RingTheory.Sequence.IsWeaklyRegular ⟨R, ⟨inst, M⟩⟩.2.2.1 ⟨R, ⟨inst, M⟩⟩.2.2.2.2.2.1 | false |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.SynthInstance.getSubgoals._sparseCasesOn_1 | Lean.Meta.SynthInstance | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
(Nat.hasNotBit 128 t.ctorIdx → motive t) → motive t | false |
FintypeCat.uSwitchEquiv.eq_1 | Mathlib.CategoryTheory.FintypeCat | ∀ (X : FintypeCat), X.uSwitchEquiv = Equiv.ulift.trans (Fintype.equivFin X.obj).symm | true |
Set.star_singleton | Mathlib.Algebra.Star.Pointwise | ∀ {β : Type u_2} [inst : InvolutiveStar β] (x : β), star {x} = {star x} | true |
_private.Mathlib.Topology.Algebra.Valued.NormedValued.0.Valuation.norm_eq_zero._simp_1_2 | Mathlib.Topology.Algebra.Valued.NormedValued | ∀ {r : NNReal}, (↑r = 0) = (r = 0) | false |
_private.Mathlib.Tactic.Linter.Header.0.Mathlib.Linter.copyrightHeaderChecks.match_1 | Mathlib.Tactic.Linter.Header | (motive : String → String → Sort u_1) →
(openComment closeComment : String) →
(Unit → motive "/-" "-/") →
((x : String) → motive "/-" x) → ((x x_1 : String) → motive x x_1) → motive openComment closeComment | false |
mulActionSphereClosedBall | Mathlib.Analysis.Normed.Module.Ball.Action | {𝕜 : Type u_1} →
{E : Type u_3} →
[inst : NormedField 𝕜] →
[inst_1 : SeminormedAddCommGroup E] →
[NormedSpace 𝕜 E] → {r : ℝ} → MulAction ↑(Metric.sphere 0 1) ↑(Metric.closedBall 0 r) | true |
_private.Mathlib.NumberTheory.Rayleigh.0.Beatty.no_anticollision._simp_1_3 | Mathlib.NumberTheory.Rayleigh | ∀ {R : Type v} [inst : Mul R] [inst_1 : Add R] [RightDistribClass R] (a b c : R), a * c + b * c = (a + b) * c | false |
Algebra.TensorProduct.cancelBaseChange._proof_6 | Mathlib.RingTheory.TensorProduct.Maps | ∀ (R : Type u_1) [inst : CommSemiring R] (A : Type u_2) [inst_1 : CommSemiring A] [inst_2 : Algebra R A],
IsScalarTower R A A | false |
ULift.seminormedAddCommGroup._proof_3 | Mathlib.Analysis.Normed.Group.Constructions | ∀ {E : Type u_2} [inst : SeminormedAddCommGroup E] (x x_1 : ULift.{u_1, u_2} E), (x + x_1).down = (x + x_1).down | false |
SemilinearMapClass.toAddHomClass | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {F : Type u_14} {R : outParam (Type u_15)} {S : outParam (Type u_16)} {inst : Semiring R} {inst_1 : Semiring S}
{σ : outParam (R →+* S)} {M : outParam (Type u_17)} {M₂ : outParam (Type u_18)} {inst_2 : AddCommMonoid M}
{inst_3 : AddCommMonoid M₂} {inst_4 : Module R M} {inst_5 : Module S M₂} {inst_6 : FunLike F M ... | true |
_private.Lean.Environment.0.Lean.AsyncContext.realizingStack | Lean.Environment | Lean.AsyncContext✝ → List Lean.Name | true |
MeasureTheory.condExp_stopping_time_ae_eq_restrict_eq_of_countable | Mathlib.Probability.Process.Stopping | ∀ {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : LinearOrder ι] {μ : MeasureTheory.Measure Ω}
{ℱ : MeasureTheory.Filtration ι m} {τ : Ω → WithTop ι} {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] [inst_3 : CompleteSpace E] {f : Ω → E} [Countable ι]
[MeasureTheory.SigmaFin... | true |
_private.Mathlib.SetTheory.ZFC.PSet.0.PSet.Subset.congr_left.match_1_5 | Mathlib.SetTheory.ZFC.PSet | ∀ (α : Type u_1) (A : α → PSet.{u_1}) (α_1 : Type u_1) (A_1 : α_1 → PSet.{u_1}) (a : (PSet.mk α A).Type)
(motive : (∃ b, (A a).Equiv (A_1 b)) → Prop) (x : ∃ b, (A a).Equiv (A_1 b)),
(∀ (b : α_1) (ab : (A a).Equiv (A_1 b)), motive ⋯) → motive x | false |
ContinuousLinearEquiv.symm | Mathlib.Topology.Algebra.Module.Equiv | {R₁ : Type u_1} →
{R₂ : Type u_2} →
[inst : Semiring R₁] →
[inst_1 : Semiring R₂] →
{σ₁₂ : R₁ →+* R₂} →
{σ₂₁ : R₂ →+* R₁} →
[inst_2 : RingHomInvPair σ₁₂ σ₂₁] →
[inst_3 : RingHomInvPair σ₂₁ σ₁₂] →
{M₁ : Type u_4} →
[inst_4 : Topolo... | true |
Std.DTreeMap.isEmpty_diff_iff | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [Std.TransCmp cmp],
(t₁ \ t₂).isEmpty = true ↔ ∀ k ∈ t₁, k ∈ t₂ | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.