name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
WithBot.unbot_mono | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LE α] {x y : WithBot α} (hx : x ≠ ⊥) (hy : y ≠ ⊥), x ≤ y → x.unbot hx ≤ y.unbot hy | true |
Algebra.traceMatrix._proof_1 | Mathlib.RingTheory.Trace.Basic | ∀ (A : Type u_1) [inst : CommRing A], SMulCommClass A A A | false |
Real.strictAntiOn_rpow_Ioi_of_exponent_neg | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {r : ℝ}, r < 0 → StrictAntiOn (fun x => x ^ r) (Set.Ioi 0) | true |
antisymm_of | Mathlib.Order.Defs.Unbundled | ∀ {α : Type u_1} (r : α → α → Prop) [Std.Antisymm r] {a b : α}, r a b → r b a → a = b | true |
isPurelyInseparable_iff | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ {F : Type u_1} {E : Type u_2} [inst : CommRing F] [inst_1 : Ring E] [inst_2 : Algebra F E],
IsPurelyInseparable F E ↔ ∀ (x : E), IsIntegral F x ∧ (IsSeparable F x → x ∈ (algebraMap F E).range) | true |
RatFunc.num_inv_dvd | Mathlib.FieldTheory.RatFunc.Basic | ∀ {K : Type u} [inst : Field K] {x : RatFunc K}, x ≠ 0 → x⁻¹.num ∣ x.denom | true |
instCommRingCorner._proof_12 | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} (e : R) [inst : NonUnitalCommRing R] (idem : IsIdempotentElem e) (n : ℕ), ↑(n + 1) = ↑n + 1 | false |
Cardinal.mk_finsupp_lift_of_infinite' | Mathlib.SetTheory.Cardinal.Finsupp | ∀ (α : Type u) (β : Type v) [Nonempty α] [inst : Zero β] [Infinite β],
Cardinal.mk (α →₀ β) = max (Cardinal.lift.{v, u} (Cardinal.mk α)) (Cardinal.lift.{u, v} (Cardinal.mk β)) | true |
Batteries.PairingHeap.headI | Batteries.Data.PairingHeap | {α : Type u} → {le : α → α → Bool} → [Inhabited α] → Batteries.PairingHeap α le → α | true |
ContinuousMap.instStar | Mathlib.Topology.ContinuousMap.Star | {α : Type u_2} →
{β : Type u_3} →
[inst : TopologicalSpace α] → [inst_1 : TopologicalSpace β] → [inst_2 : Star β] → [ContinuousStar β] → Star C(α, β) | true |
antitoneOn_of_le_sub_one | Mathlib.Algebra.Order.SuccPred | ∀ {α : Type u_2} {β : Type u_3} [inst : PartialOrder α] [inst_1 : Preorder β] [inst_2 : Sub α] [inst_3 : One α]
[inst_4 : PredSubOrder α] [IsPredArchimedean α] {s : Set α} {f : α → β},
s.OrdConnected → (∀ (a : α), ¬IsMin a → a ∈ s → a - 1 ∈ s → f a ≤ f (a - 1)) → AntitoneOn f s | true |
CommGroup.toDistribLattice._proof_1 | Mathlib.Algebra.Order.Group.Lattice | ∀ (α : Type u_1) [inst : Lattice α] [inst_1 : CommGroup α] [MulLeftMono α] (x y z : α), (x ⊔ y) ⊓ (x ⊔ z) ≤ x ⊔ y ⊓ z | false |
Lean.Elab.Term.ToDepElimPattern.State._sizeOf_inst | Lean.Elab.Match | SizeOf Lean.Elab.Term.ToDepElimPattern.State | false |
SimpleGraph.Hom.ofLE_apply | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {G₁ G₂ : SimpleGraph V} (h : G₁ ≤ G₂) (v : V), (SimpleGraph.Hom.ofLE h) v = v | true |
AdjoinRoot.instNumberFieldRat | Mathlib.NumberTheory.NumberField.Basic | ∀ {f : Polynomial ℚ} [hf : Fact (Irreducible f)], NumberField (AdjoinRoot f) | true |
Int.le_add_of_sub_left_le | Init.Data.Int.Order | ∀ {a b c : ℤ}, a - b ≤ c → a ≤ b + c | true |
Lean.ResolveName.resolveNamespaceUsingOpenDecls | Lean.ResolveName | Lean.Environment → Lean.Name → List Lean.OpenDecl → List Lean.Name | true |
_private.Mathlib.Algebra.DirectSum.Basic.0.DirectSum.map_eq_iff._simp_1_1 | Mathlib.Algebra.DirectSum.Basic | ∀ {ι : Type v} {β : ι → Type w} [inst : (i : ι) → AddCommMonoid (β i)] {x y : DirectSum ι β},
(x = y) = ∀ (i : ι), x i = y i | false |
SkewMonoidAlgebra.algHom_ext | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : Monoid G] [inst_1 : CommSemiring k] {A : Type u_3} [inst_2 : Semiring A]
[inst_3 : Algebra k A] [inst_4 : MulSemiringAction G k] [inst_5 : SMulCommClass G k k]
⦃φ₁ φ₂ : SkewMonoidAlgebra k G →ₐ[k] A⦄,
(∀ (x : G), φ₁ (SkewMonoidAlgebra.single x 1) = φ₂ (SkewMonoidAlgebra.single x 1)) → φ₁ = φ₂ | true |
Mathlib.Meta.FunProp.LambdaTheoremArgs.ctorIdx | Mathlib.Tactic.FunProp.Theorems | Mathlib.Meta.FunProp.LambdaTheoremArgs → ℕ | false |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex.0.Complex.cos_eq_cos_iff._simp_1_3 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex | ∀ {G : Type u_3} [inst : AddGroup G] {a b c : G}, (a - b = c) = (a = c + b) | false |
Algebra.FormallyUnramified.localization_base | Mathlib.RingTheory.Unramified.Basic | ∀ {R : Type u_1} {Rₘ : Type u_3} {Sₘ : Type u_4} [inst : CommRing R] [inst_1 : CommRing Rₘ] [inst_2 : CommRing Sₘ]
(M : Submonoid R) [inst_3 : Algebra R Sₘ] [inst_4 : Algebra R Rₘ] [inst_5 : Algebra Rₘ Sₘ] [IsScalarTower R Rₘ Sₘ]
[Algebra.FormallyUnramified R Sₘ], Algebra.FormallyUnramified Rₘ Sₘ | true |
_private.Batteries.Data.MLList.Basic.0.MLList.specImpl | Batteries.Data.MLList.Basic | (m : Type u_1 → Type u_1) → MLList.Spec✝ m | true |
Lean.Omega.LinearCombo.sub | Init.Omega.LinearCombo | Lean.Omega.LinearCombo → Lean.Omega.LinearCombo → Lean.Omega.LinearCombo | true |
AddCommMonCat.FilteredColimits.M | Mathlib.Algebra.Category.MonCat.FilteredColimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
[CategoryTheory.IsFiltered J] → CategoryTheory.Functor J AddCommMonCat → AddMonCat | true |
Vector.findFinIdx?_singleton._proof_1 | Init.Data.Vector.Find | ∀ {α : Type u_1} {a : α}, 0 < #[a].size | false |
_private.Std.Time.Date.ValidDate.0.Std.Time.ValidDate.ofOrdinal._proof_6 | Std.Time.Date.ValidDate | ∀ (idx : Std.Time.Month.Ordinal) (acc : ℤ),
12 ≤ ↑idx → ∀ (ordinal : Std.Time.Day.Ordinal.OfYear true), ↑ordinal ≤ 366 → 366 < ↑ordinal → False | false |
_private.Mathlib.Data.Nat.Cast.NeZero.0.NeZero.one_le._proof_1_1 | Mathlib.Data.Nat.Cast.NeZero | ∀ {n : ℕ}, n ≠ 0 → 1 ≤ n | false |
CategoryTheory.Preadditive.toCommGrp_obj_grp | Mathlib.CategoryTheory.Preadditive.CommGrp_ | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.CartesianMonoidalCategory C] [inst_3 : CategoryTheory.BraidedCategory C] (X : C),
((CategoryTheory.Preadditive.toCommGrp C).obj X).grp = CategoryTheory.Preadditive.instGrpObj X | true |
Plausible.Gen.oneOfWithDefault | Plausible.Gen | {α : Type} → Plausible.Gen α → List (Plausible.Gen α) → Plausible.Gen α | true |
CategoryTheory.FinCategory.objAsTypeToAsType | Mathlib.CategoryTheory.FinCategory.AsType | (α : Type u_1) →
[inst : Fintype α] →
[inst_1 : CategoryTheory.SmallCategory α] →
[inst_2 : CategoryTheory.FinCategory α] →
CategoryTheory.Functor (CategoryTheory.FinCategory.ObjAsType α) (CategoryTheory.FinCategory.AsType α) | true |
CategoryTheory.Limits.FormalCoproduct.homPullbackEquiv._proof_4 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {X Y Z : CategoryTheory.Limits.FormalCoproduct C}
(f : X ⟶ Z) (g : Y ⟶ Z) (T : CategoryTheory.Limits.FormalCoproduct C)
(s : { p // CategoryTheory.CategoryStruct.comp p.1 f = CategoryTheory.CategoryStruct.comp p.2 g }) (i : T.I),
Z.obj (f.f (↑⟨((↑s).1.f i, (↑s).2.f i), ⋯⟩).1) = Z.obj (g.f (↑⟨((↑s).1.f i, (↑s).2.f i), ⋯⟩).2) | false |
Lean.Server.FileWorker.WorkerState.importCachingTask? | Lean.Server.FileWorker | Lean.Server.FileWorker.WorkerState →
Option (Lean.Server.ServerTask (Except IO.Error Lean.Server.FileWorker.AvailableImportsCache)) | true |
LinearOrder.mkOfAddGroupCone.eq_1 | Mathlib.Algebra.Order.Group.Cone | ∀ {S : Type u_1} {G : Type u_2} [inst : AddCommGroup G] [inst_1 : SetLike S G] (C : S) [inst_2 : AddGroupConeClass S G]
[inst_3 : HasMemOrNegMem C] [inst_4 : DecidablePred fun x => x ∈ C],
LinearOrder.mkOfAddGroupCone C =
{ toPartialOrder := PartialOrder.mkOfAddGroupCone C, min := fun a b => if a ≤ b then a else b,
max := fun a b => if a ≤ b then b else a, compare := fun a b => compareOfLessAndEq a b, le_total := ⋯,
toDecidableLE := fun x b => inst_4 (b - x), toDecidableEq := decidableEqOfDecidableLE,
toDecidableLT := decidableLTOfDecidableLE, min_def := ⋯, max_def := ⋯, compare_eq_compareOfLessAndEq := ⋯ } | true |
PEquiv.trans_assoc | Mathlib.Data.PEquiv | ∀ {α : Type u} {β : Type v} {γ : Type w} {δ : Type x} (f : α ≃. β) (g : β ≃. γ) (h : γ ≃. δ),
(f.trans g).trans h = f.trans (g.trans h) | true |
Path.Homotopic.proj.eq_1 | Mathlib.Topology.Homotopy.Product | ∀ {ι : Type u_1} {X : ι → Type u_2} [inst : (i : ι) → TopologicalSpace (X i)] {as bs : (i : ι) → X i} (i : ι)
(p : Path.Homotopic.Quotient as bs), Path.Homotopic.proj i p = p.map { toFun := fun p => p i, continuous_toFun := ⋯ } | true |
UInt16.ofInt_one | Init.Data.UInt.Lemmas | UInt16.ofInt 1 = 1 | true |
FormalMultilinearSeries.id._proof_4 | Mathlib.Analysis.Analytic.Composition | ∀ (𝕜 : Type u_1) (E : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E], ContinuousConstSMul 𝕜 E | false |
Equiv.Perm.Basis.toCentralizer_apply | Mathlib.GroupTheory.Perm.Centralizer | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {g : Equiv.Perm α} (a : g.Basis)
(τ : ↥(Equiv.Perm.OnCycleFactors.range_toPermHom' g)) (x : α), ↑(a.toCentralizer τ) x = a.ofPermHomFun τ x | true |
_private.Lean.Meta.InferType.0.Lean.Meta.isProofQuickApp | Lean.Meta.InferType | Lean.Expr → ℕ → Lean.MetaM Lean.LBool | true |
ClopenUpperSet.ext_iff | Mathlib.Topology.Sets.Order | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LE α] {s t : ClopenUpperSet α}, s = t ↔ ↑s = ↑t | true |
Equiv.ext_iff | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u} {β : Sort v} {f g : α ≃ β}, f = g ↔ ∀ (x : α), f x = g x | true |
_private.Mathlib.Algebra.Polynomial.Derivative.0.Polynomial.iterate_derivative_prod_X_sub_C.match_1_4 | Mathlib.Algebra.Polynomial.Derivative | {R : Type u_1} →
{S : Finset R} →
(k : ℕ) →
(motive :
(x : Finset R × R) →
x ∈
{x ∈ Finset.powersetCard (S.card - k) S ×ˢ S |
match x with
| (T, i) => i ∈ T} →
Sort u_2) →
(x : Finset R × R) →
(x_1 :
x ∈
{x ∈ Finset.powersetCard (S.card - k) S ×ˢ S |
match x with
| (T, i) => i ∈ T}) →
((T : Finset R) →
(i : R) →
(x :
(T, i) ∈
{x ∈ Finset.powersetCard (S.card - k) S ×ˢ S |
match x with
| (T, i) => i ∈ T}) →
motive (T, i) x) →
motive x x_1 | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastMul.blast | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] → {w : ℕ} → (aig : Std.Sat.AIG α) → aig.BinaryRefVec w → Std.Sat.AIG.RefVecEntry α w | true |
Std.Internal.List.Const.getKeyD_modifyKey_self | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {k fallback : α} {f : β → β} (l : List ((_ : α) × β)),
Std.Internal.List.DistinctKeys l →
Std.Internal.List.getKeyD k (Std.Internal.List.Const.modifyKey k f l) fallback =
if Std.Internal.List.containsKey k l = true then k else fallback | true |
String.Slice.Pattern.ForwardSliceSearcher.instToForwardSearcher | Init.Data.String.Pattern.String | {pat : String.Slice} → String.Slice.Pattern.ToForwardSearcher pat String.Slice.Pattern.ForwardSliceSearcher | true |
TopCat.GlueData.MkCore.cocycle | Mathlib.Topology.Gluing | ∀ (self : TopCat.GlueData.MkCore) (i j k : self.J) (x : ↥(self.V i j)) (h : ↑x ∈ self.V i k),
↑((CategoryTheory.ConcreteCategory.hom (self.t j k)) ⟨↑((CategoryTheory.ConcreteCategory.hom (self.t i j)) x), ⋯⟩) =
↑((CategoryTheory.ConcreteCategory.hom (self.t i k)) ⟨↑x, h⟩) | true |
MonCat.Colimits.monoidColimitType._proof_2 | Mathlib.Algebra.Category.MonCat.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J] (F : CategoryTheory.Functor J MonCat) (n : ℕ)
(x : MonCat.Colimits.ColimitType F), npowRecAuto (n + 1) x = npowRecAuto n x * x | false |
_private.Mathlib.Data.Countable.Defs.0.Finite.to_countable.match_1 | Mathlib.Data.Countable.Defs | ∀ {α : Sort u_1} (motive : (∃ n, Nonempty (α ≃ Fin n)) → Prop) (x : ∃ n, Nonempty (α ≃ Fin n)),
(∀ (w : ℕ) (e : α ≃ Fin w), motive ⋯) → motive x | false |
LocallyConstant.instAddGroup._proof_6 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : AddGroup Y] (x : LocallyConstant X Y) (x_1 : ℤ),
⇑(x_1 • x) = ⇑(x_1 • x) | false |
NormedAddGroupHom.toAddMonoidHomClass | Mathlib.Analysis.Normed.Group.Hom | ∀ {V₁ : Type u_2} {V₂ : Type u_3} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂],
AddMonoidHomClass (NormedAddGroupHom V₁ V₂) V₁ V₂ | true |
WType.instEncodable | Mathlib.Data.W.Basic | {α : Type u_1} →
{β : α → Type u_2} → [(a : α) → Fintype (β a)] → [(a : α) → Encodable (β a)] → [Encodable α] → Encodable (WType β) | true |
PredOrder.ofPredLeIff | Mathlib.Order.SuccPred.Basic | {α : Type u_1} → [inst : Preorder α] → (pred : α → α) → (∀ {a b : α}, b ≤ pred a ↔ b < a) → PredOrder α | true |
Module.supportDim_le_of_surjective | Mathlib.RingTheory.KrullDimension.Module | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommGroup N] [inst_4 : Module R N] (f : M →ₗ[R] N),
Function.Surjective ⇑f → Module.supportDim R N ≤ Module.supportDim R M | true |
Matroid.cRk_map_eq | Mathlib.Combinatorics.Matroid.Rank.Cardinal | ∀ {α β : Type u} {f : α → β} {X : Set β} (M : Matroid α) (hf : Set.InjOn f M.E), (M.map f hf).cRk X = M.cRk (f ⁻¹' X) | true |
Subarray.size_le_array_size | Init.Data.Array.Subarray | ∀ {α : Type u_1} {s : Subarray α}, Std.Slice.size s ≤ s.array.size | true |
_private.Batteries.Data.Array.Scan.0.Array.scanrM.loop_toList._proof_1_4 | Batteries.Data.Array.Scan | ∀ {α : Type u_1} {as : Array α} (n : ℕ) {stop start : ℕ}, start - stop = n + 1 → ¬stop < start → False | false |
Equiv.sumSigmaDistrib_symm_apply | Mathlib.Logic.Equiv.Sum | ∀ {α : Type u_10} {β : Type u_11} (t : α ⊕ β → Type u_9) (a : (i : α) × t (Sum.inl i) ⊕ (i : β) × t (Sum.inr i)),
(Equiv.sumSigmaDistrib t).symm a = Sum.elim (fun a => ⟨Sum.inl a.fst, a.snd⟩) (fun b => ⟨Sum.inr b.fst, b.snd⟩) a | true |
MonoidWithZeroHom.ValueGroup₀.instIsOrderedMonoid | Mathlib.Algebra.Order.GroupWithZero.Range | ∀ {A : Type u_1} {B : Type u_2} [inst : MonoidWithZero A] [inst_1 : LinearOrderedCommGroupWithZero B] {f : A →*₀ B},
IsOrderedMonoid (MonoidWithZeroHom.ValueGroup₀ f) | true |
_private.Mathlib.Order.Atoms.0.IsAtomic.Set.Iic.isAtomic.match_1 | Mathlib.Order.Atoms | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] (y : α) (motive : (∃ a, IsAtom a ∧ a ≤ y) → Prop)
(x : ∃ a, IsAtom a ∧ a ≤ y), (∀ (a : α) (ha : IsAtom a) (hay : a ≤ y), motive ⋯) → motive x | false |
Lean.Elab.Tactic.BVDecide.Frontend.TacticContext.ctorIdx | Lean.Elab.Tactic.BVDecide.Frontend.LRAT | Lean.Elab.Tactic.BVDecide.Frontend.TacticContext → ℕ | false |
Lean.Widget.RpcEncodablePacket.«_@».Lean.Widget.InteractiveGoal.562241082._hygCtx._hyg.1.rec | Lean.Widget.InteractiveGoal | {motive : Lean.Widget.RpcEncodablePacket✝ → Sort u} →
((names fvarIds type : Lean.Json) →
(val? isInstance? isType? isInserted? isRemoved? : Option Lean.Json) →
motive
{ names := names, fvarIds := fvarIds, type := type, val? := val?, isInstance? := isInstance?,
isType? := isType?, isInserted? := isInserted?, isRemoved? := isRemoved? }) →
(t : Lean.Widget.RpcEncodablePacket✝) → motive t | false |
Int.sub_lt_self | Init.Data.Int.Order | ∀ (a : ℤ) {b : ℤ}, 0 < b → a - b < a | true |
Commute.eq | Mathlib.Algebra.Group.Commute.Defs | ∀ {S : Type u_3} [inst : Mul S] {a b : S}, Commute a b → a * b = b * a | true |
TopologicalSpace.Opens.frameMinimalAxioms._proof_4 | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_1} [inst : TopologicalSpace α] (a b c : TopologicalSpace.Opens α), a ≤ b → a ≤ c → a ≤ Lattice.inf b c | false |
AddSubmonoid.addUnitsEquivAddUnitsType._proof_3 | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : AddMonoid M] (S : AddSubmonoid M),
Function.LeftInverse (fun x => ⟨{ val := ↑↑x, neg := ↑↑(-x), val_neg := ⋯, neg_val := ⋯ }, ⋯⟩) fun x =>
match x with
| ⟨val, h⟩ =>
{ val := ⟨(AddUnits.coeHom M) val, ⋯⟩, neg := ⟨(AddUnits.coeHom M) (-val), ⋯⟩, val_neg := ⋯, neg_val := ⋯ } | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get?_eq_some_iff._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 |
_private.Batteries.Data.List.Lemmas.0.List.getElem_filter_eq_getElem_getElem_findIdxs_sub._proof_1_30 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (head : α) (tail : List α) {i : ℕ} (s : ℕ),
i < (List.filter p (head :: tail)).length → p head = true → -1 * ↑i + 1 ≤ 0 → i - 1 < (List.filter p tail).length | false |
TensorProduct.smul_tmul | Mathlib.LinearAlgebra.TensorProduct.Defs | ∀ {R : Type u_1} {R' : Type u_4} [inst : CommSemiring R] [inst_1 : Monoid R'] {M : Type u_7} {N : Type u_8}
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid N] [inst_4 : DistribMulAction R' M] [inst_5 : Module R M]
[inst_6 : Module R N] [inst_7 : DistribMulAction R' N] [TensorProduct.CompatibleSMul R R' M N] (r : R') (m : M)
(n : N), (r • m) ⊗ₜ[R] n = m ⊗ₜ[R] (r • n) | true |
_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.resultant_add_mul_monomial_right._proof_1_25 | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ (m n k : ℕ) (j₁ : Fin (m + n)) (j₂ : Fin m),
(↑j₂ ≤ ↑j₁ ∧ ↑j₁ ≤ ↑j₂ + n) ∧ k ≤ ↑j₁ - ↑j₂ → ¬(↑j₂ + k ≤ ↑j₁ ∧ ↑j₁ ≤ ↑j₂ + (k + m)) → m < ↑j₁ - ↑j₂ - k | false |
Mathlib.Tactic.Translate.TranslationInfo.recOn | Mathlib.Tactic.Translate.Core | {motive : Mathlib.Tactic.Translate.TranslationInfo → Sort u} →
(t : Mathlib.Tactic.Translate.TranslationInfo) →
((translation : Lean.Name) →
(reorder : Mathlib.Tactic.Translate.Reorder) →
(relevantArg : Mathlib.Tactic.Translate.RelevantArg) →
motive { translation := translation, reorder := reorder, relevantArg := relevantArg }) →
motive t | false |
MeasurableSet.mem | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} {s : Set α} [inst : MeasurableSpace α], MeasurableSet s → Measurable fun x => x ∈ s | true |
dist_pi_const_le | Mathlib.Topology.MetricSpace.Pseudo.Pi | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoMetricSpace α] [inst_1 : Fintype β] (a b : α),
(dist (fun x => a) fun x => b) ≤ dist a b | true |
_private.Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension.0.IsOpen.exists_contDiff_support_eq._simp_1_15 | Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] {p : α → Prop} [Nonempty α],
(∀ᶠ (x : α) in Filter.atTop, p x) = ∃ a, ∀ b ≥ a, p b | false |
_private.Mathlib.Topology.Algebra.Polynomial.0.Polynomial.coeff_le_of_roots_le._simp_1_1 | Mathlib.Topology.Algebra.Polynomial | ∀ {α : Type u_1} {β : Type v} {f : α → β} {b : β} {s : Multiset α}, (b ∈ Multiset.map f s) = ∃ a ∈ s, f a = b | false |
_private.Mathlib.Analysis.InnerProductSpace.Defs.0.InnerProductSpace.Core.«_aux_Mathlib_Analysis_InnerProductSpace_Defs___macroRules__private_Mathlib_Analysis_InnerProductSpace_Defs_0_InnerProductSpace_Core_term_†_1» | Mathlib.Analysis.InnerProductSpace.Defs | Lean.Macro | false |
Real.sign_eq_zero_iff._simp_1 | Mathlib.Data.Real.Sign | ∀ {r : ℝ}, (r.sign = 0) = (r = 0) | false |
minimal_nonempty_open_eq_singleton | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] [T0Space X] {s : Set X},
IsOpen s → s.Nonempty → (∀ t ⊆ s, t.Nonempty → IsOpen t → t = s) → ∃ x, s = {x} | true |
left_iff_dite_iff | Init.PropLemmas | ∀ {p : Prop} [inst : Decidable p] {x : Prop} {y : ¬p → Prop}, (x ↔ if h : p then x else y h) ↔ ∀ (h : ¬p), x ↔ y h | true |
GradedMonoid.list_prod_map_eq_dProd | Mathlib.Algebra.GradedMonoid | ∀ {ι : Type u_1} {α : Type u_2} {A : ι → Type u_3} [inst : AddMonoid ι] [inst_1 : GradedMonoid.GMonoid A] (l : List α)
(f : α → GradedMonoid A),
(List.map f l).prod =
GradedMonoid.mk (l.dProdIndex fun i => (f i).fst) (l.dProd (fun i => (f i).fst) fun i => (f i).snd) | true |
CategoryTheory.IsPullback.of_hasPullback | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Defs | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
[inst_1 : CategoryTheory.Limits.HasPullback f g],
CategoryTheory.IsPullback (CategoryTheory.Limits.pullback.fst f g) (CategoryTheory.Limits.pullback.snd f g) f g | true |
ProbabilityTheory.Kernel.IndepFun.comp | Mathlib.Probability.Independence.Kernel.IndepFun | ∀ {α : Type u_1} {Ω : Type u_2} {β : Type u_4} {β' : Type u_5} {γ : Type u_6} {γ' : Type u_7} {mα : MeasurableSpace α}
{mΩ : MeasurableSpace Ω} {κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α} {f : Ω → β} {g : Ω → β'}
{mβ : MeasurableSpace β} {mβ' : MeasurableSpace β'} {mγ : MeasurableSpace γ} {mγ' : MeasurableSpace γ'} {φ : β → γ}
{ψ : β' → γ'},
ProbabilityTheory.Kernel.IndepFun f g κ μ →
Measurable φ → Measurable ψ → ProbabilityTheory.Kernel.IndepFun (φ ∘ f) (ψ ∘ g) κ μ | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.getKey_eraseKey._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] {l : List ((a : α) × β a)} {a : α}
(h : Std.Internal.List.containsKey a l = true), some (Std.Internal.List.getKey a l h) = Std.Internal.List.getKey? a l | false |
CategoryTheory.Under.pushout_obj | Mathlib.CategoryTheory.Comma.Over.Pullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasPushoutsAlong f] (x : CategoryTheory.Under X),
(CategoryTheory.Under.pushout f).obj x = CategoryTheory.Under.mk (CategoryTheory.Limits.pushout.inr x.hom f) | true |
Order.height_toDual | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] (x : α), Order.height (OrderDual.toDual x) = Order.coheight x | true |
AddLocalization.ind | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {p : AddLocalization S → Prop},
(∀ (y : M × ↥S), p (AddLocalization.mk y.1 y.2)) → ∀ (x : AddLocalization S), p x | true |
ProbabilityTheory.Kernel.partialTraj_comp_partialTraj | Mathlib.Probability.Kernel.IonescuTulcea.PartialTraj | ∀ {X : ℕ → Type u_1} {mX : (n : ℕ) → MeasurableSpace (X n)} {a b c : ℕ}
{κ : (n : ℕ) → ProbabilityTheory.Kernel ((i : ↥(Finset.Iic n)) → X ↑i) (X (n + 1))},
a ≤ b →
b ≤ c →
(ProbabilityTheory.Kernel.partialTraj κ b c).comp (ProbabilityTheory.Kernel.partialTraj κ a b) =
ProbabilityTheory.Kernel.partialTraj κ a c | true |
Ordinal.bsup_le | Mathlib.SetTheory.Ordinal.Family | ∀ {o : Ordinal.{u}} {f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v}} {a : Ordinal.{max u v}},
(∀ (i : Ordinal.{u}) (h : i < o), f i h ≤ a) → o.bsup f ≤ a | true |
Lean.Elab.TacticInfo.goalsBefore | Lean.Elab.InfoTree.Types | Lean.Elab.TacticInfo → List Lean.MVarId | true |
RingOfIntegers.exponent | Mathlib.NumberTheory.NumberField.Ideal.KummerDedekind | {K : Type u_1} → [inst : Field K] → NumberField.RingOfIntegers K → ℕ | true |
ContMDiff.piecewise | Mathlib.Geometry.Manifold.ContMDiff.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] {E' : Type u_5} [inst_5 : NormedAddCommGroup E'] [inst_6 : NormedSpace 𝕜 E']
{H' : Type u_6} [inst_7 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'} {M' : Type u_7}
[inst_8 : TopologicalSpace M'] [inst_9 : ChartedSpace H M] [inst_10 : ChartedSpace H' M'] {n : WithTop ℕ∞}
{f g : M → M'} {s : Set M} [inst_11 : DecidablePred fun x => x ∈ s],
ContMDiff I I' n f → ContMDiff I I' n g → (∀ x ∈ frontier s, f =ᶠ[nhds x] g) → ContMDiff I I' n (s.piecewise f g) | true |
FirstOrder.Language.mk.injEq | Mathlib.ModelTheory.Basic | ∀ (Functions : ℕ → Type u) (Relations : ℕ → Type v) (Functions_1 : ℕ → Type u) (Relations_1 : ℕ → Type v),
({ Functions := Functions, Relations := Relations } = { Functions := Functions_1, Relations := Relations_1 }) =
(Functions = Functions_1 ∧ Relations = Relations_1) | true |
Mathlib.Tactic.Linarith.LinarithConfig.splitHypotheses._default | Mathlib.Tactic.Linarith.Frontend | Bool | false |
TopologicalAddGroup.IsSES.pushforward_def | Mathlib.MeasureTheory.Measure.Haar.Extension | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} {E : Type u_4} [inst : AddGroup A] [inst_1 : AddGroup B]
[inst_2 : AddGroup C] [inst_3 : TopologicalSpace A] [inst_4 : TopologicalSpace B] [inst_5 : TopologicalSpace C]
{φ : A →+ B} {ψ : B →+ C} (H : TopologicalAddGroup.IsSES φ ψ) [inst_6 : IsTopologicalAddGroup A]
[inst_7 : IsTopologicalAddGroup B] [inst_8 : NormedAddCommGroup E] [inst_9 : MeasurableSpace A]
[inst_10 : BorelSpace A] (μA : MeasureTheory.Measure A) [hμA : μA.IsAddHaarMeasure] [inst_11 : NormedSpace ℝ E]
[inst_12 : IsTopologicalAddGroup C] [inst_13 : LocallyCompactSpace B] (f : CompactlySupportedContinuousMap B E)
(c : C), ((H.pushforward μA) f) c = ∫ (a : A), (H.pullback f (Function.invFun (⇑ψ) c)) a ∂μA | true |
LLVM.Visibility._sizeOf_1 | Lean.Compiler.IR.LLVMBindings | LLVM.Visibility → ℕ | false |
NonUnitalCommRing.toNonUnitalCommSemiring._proof_2 | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u_1} [s : NonUnitalCommRing α] (a b c : α), a * (b + c) = a * b + a * c | false |
Lean.removeRoot | Lean.Data.OpenDecl | Lean.Name → Lean.Name | true |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.Const.alter.match_1.eq_1 | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {β : Type u_1} (motive : Option β → Sort u_2) (h_1 : Unit → motive none) (h_2 : (b : β) → motive (some b)),
(match none with
| none => h_1 ()
| some b => h_2 b) =
h_1 () | true |
_private.Mathlib.Algebra.Homology.ExactSequenceFour.0.CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles_hom_fac._proof_15 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {n : ℕ} (k : ℕ),
autoParam (k ≤ n) CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles_hom_fac._auto_1 → k + 1 + 2 < n + 3 + 1 | false |
CategoryTheory.inclusion | Mathlib.CategoryTheory.ConnectedComponents | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
(j : CategoryTheory.ConnectedComponents J) → CategoryTheory.Functor j.Component (CategoryTheory.Decomposed J) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.