name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AddMonoidHom.instDomMulActModule._proof_2 | Mathlib.Algebra.Module.Hom | ∀ {S : Type u_3} {M : Type u_1} {M₂ : Type u_2} [inst : Semiring S] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₂] [inst_3 : Module S M] (x : M →+ M₂), 0 • x = 0 | null | false |
CategoryTheory.Limits.colimitCurrySwapCompColimIsoColimitCurryCompColim_ι_ι_hom | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_1} {K : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} K] {C : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
(G : CategoryTheory.Functor (J × K) C) [inst_3 : CategoryTheory.Limits.HasColimitsOfShape K C]
[inst_4 : CategoryTheory.Limit... | null | true |
ContinuousGeneratedByCat._sizeOf_inst | Mathlib.Topology.Convenient.Category | {ι : Type t} →
(X : ι → Type u) →
{inst : (i : ι) → TopologicalSpace (X i)} →
[SizeOf ι] → [(a : ι) → SizeOf (X a)] → SizeOf (ContinuousGeneratedByCat X) | null | false |
Squarefree.dvd_of_squarefree_of_mul_dvd_mul_left | Mathlib.Algebra.Squarefree.Basic | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] [IsCancelMulZero R] {x y d : R} [DecompositionMonoid R],
Squarefree y → d * d ∣ x * y → d ∣ x | null | true |
_private.Mathlib.Algebra.Order.BigOperators.Expect.0.Mathlib.Meta.Positivity.evalFinsetExpect._sparseCasesOn_11 | Mathlib.Algebra.Order.BigOperators.Expect | {α : Type u} →
{motive : Lean.LOption α → Sort u_1} →
(t : Lean.LOption α) → ((a : α) → motive (Lean.LOption.some a)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Std.DTreeMap.Const.get?_eq_some_iff_exists_compare_eq_eq_and_mem_toList | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp] {k : α}
{v : β}, Std.DTreeMap.Const.get? t k = some v ↔ ∃ k', cmp k k' = Ordering.eq ∧ (k', v) ∈ Std.DTreeMap.Const.toList t | null | true |
Relation.map_apply | Mathlib.Logic.Relation | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {r : α → β → Prop} {f : α → γ} {g : β → δ} {c : γ}
{d : δ}, Relation.Map r f g c d ↔ ∃ a b, r a b ∧ f a = c ∧ g b = d | null | true |
List.Vector.traverse_def | Mathlib.Data.Vector.Basic | ∀ {n : ℕ} {F : Type u → Type u} [inst : Applicative F] {α β : Type u} (f : α → F β) (x : α) (xs : List.Vector α n),
List.Vector.traverse f (x ::ᵥ xs) = List.Vector.cons <$> f x <*> List.Vector.traverse f xs | null | true |
CovBy.lt_iff_le_right | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : LinearOrder α] {x y : α}, y ⋖ x → ∀ {z : α}, y < z ↔ x ≤ z | **Alias** of the forward direction of `covBy_iff_lt_iff_le_right`. | true |
ArchimedeanClass.instFieldFiniteResidueField._proof_64 | Mathlib.Algebra.Order.Ring.StandardPart | ∀ (K : Type u_1) [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K], 0⁻¹ = 0 | null | false |
_private.Lean.Elab.InfoTree.Util.0.Lean.Elab.InfoTree.goalsAt?.hasNestedTactic._sparseCasesOn_3 | Lean.Elab.InfoTree.Util | {motive_1 : Lean.Elab.InfoTree → Sort u} →
(t : Lean.Elab.InfoTree) →
((i : Lean.Elab.Info) →
(children : Lean.PersistentArray Lean.Elab.InfoTree) → motive_1 (Lean.Elab.InfoTree.node i children)) →
(Nat.hasNotBit 2 t.ctorIdx → motive_1 t) → motive_1 t | null | false |
_private.Mathlib.CategoryTheory.Limits.Preserves.Creates.Opposites.0.CategoryTheory.Limits.createsLimitLeftOp._proof_1 | Mathlib.CategoryTheory.Limits.Preserves.Creates.Opposites | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_3, u_5} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_4, u_6} D] {J : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} J]
(K : CategoryTheory.Functor J Cᵒᵖ) (F : CategoryTheory.Functor C Dᵒᵖ) [CategoryTheory.CreatesColimit K.leftOp F],
CategoryThe... | null | false |
MonoidHom.snd._proof_1 | Mathlib.Algebra.Group.Prod | ∀ (M : Type u_2) (N : Type u_1) [inst : MulOneClass M] [inst_1 : MulOneClass N], 1.2 = 1.2 | null | false |
CategoryTheory.Subgroupoid.IsNormal.mk._flat_ctor | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] {S : CategoryTheory.Subgroupoid C},
(∀ (c : C), CategoryTheory.CategoryStruct.id c ∈ S.arrows c c) →
(∀ {c d : C} (p : c ⟶ d) {γ : c ⟶ c},
γ ∈ S.arrows c c →
CategoryTheory.CategoryStruct.comp (CategoryTheory.Groupoid.inv p) (CategoryTheory.Categ... | null | false |
Std.HashMap.unitOfList_cons | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {hd : α} {tl : List α},
Std.HashMap.unitOfList (hd :: tl) = (∅.insertIfNew hd ()).insertManyIfNewUnit tl | null | true |
MeasureTheory.AEStronglyMeasurable.iUnion | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} [Countable ι] [inst : TopologicalSpace β] {m₀ : MeasurableSpace α}
{μ : MeasureTheory.Measure α} {f : α → β} [TopologicalSpace.PseudoMetrizableSpace β] {s : ι → Set α},
(∀ (i : ι), MeasureTheory.AEStronglyMeasurable f (μ.restrict (s i))) →
MeasureTheory.AEStronglyM... | null | true |
_private.Mathlib.Topology.UniformSpace.ProdApproximation.0.ContinuousMap.exists_finite_sum_smul_approximation_of_mem_uniformity._simp_1_4 | Mathlib.Topology.UniformSpace.ProdApproximation | ∀ {α : Type u_1} [UsesSetNotationForOrder α] [inst : Preorder α] (a : α), (a ⊆ a) = True | null | false |
ENNReal.coe_ne_coe | Mathlib.Basic.ENNReal.Basic | ∀ {p q : NNReal}, ↑p ≠ ↑q ↔ p ≠ q | null | true |
Module.Basis.finTwoProd | Mathlib.LinearAlgebra.Basis.Fin | (R : Type u_7) → [inst : Semiring R] → Module.Basis (Fin 2) R (R × R) | The basis of `R × R` given by the two vectors `(1, 0)` and `(0, 1)`. | true |
MeasureTheory.eLpNormEssSup_indicator_const_le | Mathlib.MeasureTheory.Function.LpSeminorm.Indicator | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {ε : Type u_6} [inst : TopologicalSpace ε]
[inst_1 : ESeminormedAddMonoid ε] (s : Set α) (c : ε), MeasureTheory.eLpNormEssSup (s.indicator fun x => c) μ ≤ ‖c‖ₑ | null | true |
_private.Mathlib.Algebra.Group.Basic.0.zsmul_zero.match_1_1 | Mathlib.Algebra.Group.Basic | ∀ (motive : ℤ → Prop) (x : ℤ), (∀ (n : ℕ), motive (Int.ofNat n)) → (∀ (n : ℕ), motive (Int.negSucc n)) → motive x | null | false |
CategoryTheory.Lax.OplaxTrans.ctorIdx | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} →
{inst_1 : CategoryTheory.Bicategory C} →
{F G : CategoryTheory.LaxFunctor B C} → CategoryTheory.Lax.OplaxTrans F G → ℕ | null | false |
Lean.TransformStep.toStep | Lean.Meta.Tactic.Simp.Types | Lean.TransformStep → Lean.Meta.Simp.Step | null | true |
_private.Lean.Meta.Constructions.SparseCasesOn.0.Lean.Meta.SparseCasesOnKey.rec | Lean.Meta.Constructions.SparseCasesOn | {motive : Lean.Meta.SparseCasesOnKey✝ → Sort u} →
((indName : Lean.Name) →
(ctors : Array Lean.Name) →
(isPrivate : Bool) → motive { indName := indName, ctors := ctors, isPrivate := isPrivate }) →
(t : Lean.Meta.SparseCasesOnKey✝) → motive t | null | false |
_private.Mathlib.Algebra.Order.Monovary.0.monovary_iff_forall_smul_nonneg._simp_1_2 | Mathlib.Algebra.Order.Monovary | ∀ (p : True → Prop), (∀ (x : True), p x) = p True.intro | null | false |
MeasureTheory.Filtration.HasLimitProcess.of_smul₀ | Mathlib.Probability.Process.LimitProcess | ∀ {ι : Type u_1} {Ω : Type u_2} {E : Type u_3} [inst : Preorder ι] {mΩ : MeasurableSpace Ω}
[inst_1 : TopologicalSpace E] {P : MeasureTheory.Measure Ω} {𝓕 : MeasureTheory.Filtration ι mΩ} {X : ι → Ω → E}
{G : Type u_6} [inst_2 : GroupWithZero G] [inst_3 : MulAction G E] [ContinuousConstSMul G E] {c : G},
c ≠ 0 →... | **Alias** of the forward direction of `MeasureTheory.Filtration.hasLimitProcess_smul_iff₀`. | true |
Lean.Parser.many1.formatter | Lean.Parser.Extra | Lean.PrettyPrinter.Formatter → Lean.PrettyPrinter.Formatter | null | true |
_private.Mathlib.Analysis.AbsoluteValue.Equivalence.0.AbsoluteValue.exists_one_lt_lt_one_pi_of_one_lt._simp_1_2 | Mathlib.Analysis.AbsoluteValue.Equivalence | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] [Nonempty α] {s : Set α},
(s ∈ Filter.atTop) = ∃ a, ∀ (b : α), a ≤ b → b ∈ s | null | false |
ConvexOn.monotoneOn_deriv | Mathlib.Analysis.Convex.Deriv | ∀ {S : Set ℝ} {f : ℝ → ℝ}, ConvexOn ℝ S f → (∀ x ∈ S, DifferentiableAt ℝ f x) → MonotoneOn (deriv f) S | If `f` is convex on `S` and differentiable at all points of `S`, then its derivative is monotone
on `S`. | true |
Std.DTreeMap.minKey!_insertIfNew_of_isEmpty | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α] {k : α} {v : β k}, t.isEmpty = true → (t.insertIfNew k v).minKey! = k | null | true |
Algebra.TensorProduct.tensorQuotientEquiv._proof_9 | Mathlib.RingTheory.TensorProduct.Quotient | ∀ {R : Type u_2} (S : Type u_1) (T : Type u_3) (A : Type u_4) [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : CommRing A] [inst_6 : Algebra R A]
[inst_7 : Algebra S A] [inst_8 : IsScalarTower R S A], SMulCommClass S R (TensorProduct R A T) | null | false |
CategoryTheory.StructuredArrow.map₂_obj_right | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{A : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} A] {B : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} B] {L : D} {R : CategoryTheory.Functor C D} {L' : B}
{R' : CategoryTheory.Fun... | null | true |
Aesop.Goal.setMVars | Aesop.Tree.Data | Aesop.UnorderedArraySet Lean.MVarId → Aesop.Goal → Aesop.Goal | null | true |
Positive.addRightCancelSemigroup._proof_1 | Mathlib.Algebra.Order.Positive.Ring | ∀ {M : Type u_1} [inst : AddRightCancelMonoid M] [inst_1 : Preorder M] [inst_2 : AddLeftStrictMono M],
IsRightCancelAdd { x // 0 < x } | null | false |
FunLike.distribMulAction._proof_1 | Mathlib.Algebra.Module.FunLike | ∀ {M : Type u_4} {F : Type u_3} {α : Type u_1} {β : Type u_2} [i : FunLike F α β] [inst : Monoid M]
[inst_1 : AddMonoid β] [inst_2 : DistribMulAction M β] [inst_3 : SMul M F] [IsSMulApply M F α β] (n : M) (f : F),
⇑(n • f) = n • ⇑f | null | false |
Lean.Meta.Grind.Goal | Lean.Meta.Tactic.Grind.Types | Type | A `grind` goal, combining shared state with a specific metavariable.
See `GoalState` for details on why the state is factored out.
**Note**: The `Goal` internal representation is just a pair `GoalState` and `MVarId`.
| true |
Std.TreeSet.Raw.compare_get?_self | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α}, Option.all (fun x => decide (cmp x k = Ordering.eq)) (t.get? k) = true | null | true |
_private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnSeries.map_mul._simp_1_3 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] (x : HahnSeries Γ R) (a : Γ),
(a ∈ x.support) = (x.coeff a ≠ 0) | null | false |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.bullet.go | Lean.DocString.Parser | List Lean.Doc.Parser.UnorderedListType → Lean.Parser.ParserFn | null | true |
MeasureTheory.le_eLpNorm_of_bddBelow | Mathlib.MeasureTheory.Function.LpSeminorm.Monotonicity | ∀ {α : Type u_1} {F : Type u_3} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup F],
p ≠ 0 →
p ≠ ⊤ →
∀ {f : α → F} (C : NNReal) {s : Set α},
(∀ᵐ (x : α) ∂μ, x ∈ s → C ≤ ‖f x‖₊) → C • μ s ^ (1 / p.toReal) ≤ MeasureTheory.eLpNorm f p μ | null | true |
groupHomology.boundaries₂ | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | {k G : Type u} → [inst : CommRing k] → [inst_1 : Group G] → (A : Rep.{u, u, u} k G) → Submodule k (G × G →₀ ↑A) | The 2-boundaries `B₂(G, A)` of `A : Rep k G`, defined as the image of the map
`(G³ →₀ A) → (G² →₀ A)` defined by
`a·(g₁, g₂, g₃) ↦ ρ_A(g₁⁻¹)(a)·(g₂, g₃) - a·(g₁g₂, g₃) + a·(g₁, g₂g₃) - a·(g₁, g₂)`. | true |
AddSubgroup.lowerCentralSeries_characteristic | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : AddGroup G] (S : AddSubgroup G) [S.Characteristic] (n : ℕ),
(S.lowerCentralSeries n).Characteristic | null | true |
Asymptotics.IsLittleOTVS.fun_add | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommGroup F]
[inst_5 : TopologicalSpace F] [inst_6 : Module 𝕜 F] [ContinuousAdd E] [ContinuousSMul 𝕜 E] {f₁ f₂ : α → E} {g ... | Eta-expanded form of `Asymptotics.IsLittleOTVS.add` | true |
Nat.instNeZeroCardOfNonemptyOfFinite | Mathlib.SetTheory.Cardinal.Finite | ∀ {α : Type u_1} [Nonempty α] [Finite α], NeZero (Nat.card α) | null | true |
AddMonoidHom.independent_range_of_coprime_order | Mathlib.GroupTheory.NoncommPiCoprod | ∀ {G : Type u_1} [inst : AddGroup G] {ι : Type u_2} {H : ι → Type u_3} [inst_1 : (i : ι) → AddGroup (H i)]
(ϕ : (i : ι) → H i →+ G),
(Pairwise fun i j => ∀ (x : H i) (y : H j), AddCommute ((ϕ i) x) ((ϕ j) y)) →
∀ [Finite ι] [inst_3 : (i : ι) → Fintype (H i)],
(Pairwise fun i j => (Fintype.card (H i)).Copr... | null | true |
LinearOrderedAddCommGroup.wellFoundedOn_setOf_le_lt_iff_nonempty_discrete | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {G : Type u_2} [inst : AddCommGroup G] [inst_1 : LinearOrder G] [IsOrderedAddMonoid G] [Nontrivial G] {g : G},
({x | g ≤ x}.WellFoundedOn fun x1 x2 => x1 < x2) ↔ Nonempty (G ≃+o ℤ) | **Alias** of `LinearOrderedAddCommGroup.wellFoundedOn_setOfPred_le_lt_iff_nonempty_discrete`. | true |
ContinuousLinearMap.toSpanSingletonLE._proof_2 | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Basic | ∀ (R : Type u_2) (M : Type u_1) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : TopologicalSpace M] [inst_4 : TopologicalSpace R] [inst_5 : ContinuousSMul R M] (x : M),
(fun f => f 1) (ContinuousLinearMap.toSpanSingleton R x) = x | null | false |
ContinuousLinearMap.lTensor_id | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {𝕜 : Type u_1} {E : Type u_2} (G : Type u_4) [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup G] [inst_4 : InnerProductSpace 𝕜 G],
ContinuousLinearMap.lTensor G (ContinuousLinearMap.id 𝕜 E) = ContinuousLinearMap.id 𝕜 (TensorProduct 𝕜 G E) | null | true |
_private.Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs.0.AffineSubspace.mem_direction_iff_eq_vsub_left.match_1_1 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_3} {V : Type u_1} {P : Type u_2} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {s : AffineSubspace k P} {p : P} (v : V) (motive : v ∈ (fun x => p -ᵥ x) '' ↑s → Prop)
(x : v ∈ (fun x => p -ᵥ x) '' ↑s), (∀ (p₂ : P) (hp₂ : p₂ ∈ ↑s) (hv : (fun x => p -ᵥ x) p₂ = v... | null | false |
Nat.Internal.Linear.Expr.mulR.inj | Init.Data.Nat.Internal.Linear | ∀ {a : Nat.Internal.Linear.Expr} {k : ℕ} {a_1 : Nat.Internal.Linear.Expr} {k_1 : ℕ},
a.mulR k = a_1.mulR k_1 → a = a_1 ∧ k = k_1 | null | true |
MeromorphicOn.meromorphicOn_comp_sub_const_iff_meromorphicOn | Mathlib.Analysis.Meromorphic.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {c : 𝕜} {U : Set 𝕜},
MeromorphicOn (f ∘ fun x => x - c) U ↔ MeromorphicOn f (U - {c}) | `MeromorphicOn` is invariant under translation. | true |
Digraph.sdiff_adj | Mathlib.Combinatorics.Digraph.Basic | ∀ {V : Type u_2} (x y : Digraph V) (v w : V), (x \ y).Adj v w ↔ x.Adj v w ∧ ¬y.Adj v w | null | true |
smul_add | Mathlib.Algebra.GroupWithZero.Action.Defs | ∀ {M : Type u_1} {A : Type u_7} [inst : AddZeroClass A] [inst_1 : DistribSMul M A] (a : M) (b₁ b₂ : A),
a • (b₁ + b₂) = a • b₁ + a • b₂ | null | true |
HomotopicalAlgebra.LeftHomotopyRel.rightHomotopy._proof_4 | Mathlib.AlgebraicTopology.ModelCategory.Homotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : HomotopicalAlgebra.ModelCategory C] {X Y : C}
{f g : X ⟶ Y} [inst_2 : HomotopicalAlgebra.IsCofibrant X] (h : HomotopicalAlgebra.LeftHomotopyRel f g)
(Q : HomotopicalAlgebra.PathObject Y) [inst_3 : Q.IsGood] (h_1 : ⋯.choose.LeftHomotopy f g) (h... | null | false |
PNat.caseStrongInductionOn | Mathlib.Data.PNat.Basic | {p : ℕ+ → Sort u_1} → (a : ℕ+) → p 1 → ((n : ℕ+) → ((m : ℕ+) → m ≤ n → p m) → p (n + 1)) → p a | Strong induction on `ℕ+`, with `n = 1` treated separately. | true |
Std.DTreeMap.Internal.Impl.View.mk._flat_ctor | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
{size : ℕ} → (k : α) → β k → Std.DTreeMap.Internal.Impl.Tree α β size → Std.DTreeMap.Internal.Impl.View α β size | null | false |
Function.not_lt_argmin | Mathlib.Order.WellFounded | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) [inst : LT β] [inst_1 : WellFoundedLT β] [inst_2 : Nonempty α] (a : α),
¬f a < f (Function.argmin f) | null | true |
Ordinal.le_nfp | Mathlib.SetTheory.Ordinal.FixedPoint | ∀ (f : Ordinal.{u_1} → Ordinal.{u_1}) (a : Ordinal.{u_1}), a ≤ Ordinal.nfp f a | null | true |
Finset.product_disjUnion | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t t' : Finset β} (ht : Disjoint t t'),
s ×ˢ t.disjUnion t' ht = (s ×ˢ t).disjUnion (s ×ˢ t') ⋯ | null | true |
_private.Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber.0.CircleDeg1Lift.coe_pow.match_1_1 | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (_ : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | null | false |
Bundle.zeroSection_snd | Mathlib.Topology.VectorBundle.Basic | ∀ {B : Type u_2} (F : Type u_3) (E : B → Type u_4) [inst : (x : B) → Zero (E x)] (x : B),
(Bundle.zeroSection F E x).snd = 0 | null | true |
Std.ExtDTreeMap.Const.getKey!_insertManyIfNewUnit_list_of_mem | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α (fun x => Unit) cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {l : List α} {k : α},
k ∈ t → (Std.ExtDTreeMap.Const.insertManyIfNewUnit t l).getKey! k = t.getKey! k | null | true |
MeasureTheory.measurePreserving_prod_div_swap | Mathlib.MeasureTheory.Group.Prod | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : Group G] [MeasurableMul₂ G] (μ ν : MeasureTheory.Measure G)
[MeasureTheory.SFinite ν] [MeasureTheory.SFinite μ] [MeasurableInv G] [μ.IsMulRightInvariant],
MeasureTheory.MeasurePreserving (fun z => (z.2, z.1 / z.2)) (μ.prod ν) (ν.prod μ) | The map `(x, y) ↦ (y, x / y)` sends `μ × ν` to `ν × μ`. | true |
Nat.Subtype.orderIsoOfNat | Mathlib.Order.OrderIsoNat | (s : Set ℕ) → [Infinite ↑s] → ℕ ≃o ↑s | `Nat.Subtype.ofNat` as an order isomorphism between `ℕ` and an infinite subset. See also
`Nat.nth` for a version where the subset may be finite. | true |
_private.Mathlib.Algebra.MvPolynomial.Rename.0.MvPolynomial.killCompl_map._simp_1_1 | Mathlib.Algebra.MvPolynomial.Rename | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B), ⇑f = ⇑↑f | null | false |
CompleteSublattice.mem_sSup | Mathlib.Order.CompleteLattice.SetLike | ∀ {X : Type u_1} {L : CompleteSublattice (Set X)} {𝒮 : Set ↥L} {x : X}, x ∈ sSup 𝒮 ↔ ∃ T ∈ 𝒮, x ∈ T | null | true |
Multiset.coe_attach | Mathlib.Data.Multiset.Defs | ∀ {α : Type u_1} (l : List α), (↑l).attach = ↑l.attach | null | true |
SemilinearIsometryEquivClass.mk | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {𝓕 : Type u_9} {R : outParam (Type u_10)} {R₂ : outParam (Type u_11)} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : outParam (R →+* R₂)} {σ₂₁ : outParam (R₂ →+* R)} [inst_2 : RingHomInvPair σ₁₂ σ₂₁]
[inst_3 : RingHomInvPair σ₂₁ σ₁₂] {E : outParam (Type u_12)} {E₂ : outParam (Type u_13)}
[inst_4 : Seminorme... | null | true |
StieltjesFunction.measure_univ | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (f : StieltjesFunction R)
[inst_2 : OrderTopology R] [inst_3 : CompactIccSpace R] [inst_4 : MeasurableSpace R] [inst_5 : BorelSpace R]
[inst_6 : SecondCountableTopology R] [inst_7 : DenselyOrdered R] [Nonempty R] {l u : ℝ},
Filter.Tendsto (↑f) ... | null | true |
Lean.ParseImports.keyword | Lean.Elab.ParseImportsFast | String → Lean.ParseImports.Parser | null | true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.letExpr._regBuiltin.Lean.Parser.Term.letExpr.formatter_7 | Lean.Parser.Term | IO Unit | null | false |
Std.Http.Protocol.H1.Writer.isComplete | Std.Http.Protocol.H1.Writer | {dir : Std.Http.Protocol.H1.Direction} → Std.Http.Protocol.H1.Writer dir → Bool | Checks if the writer has completed processing a request.
| true |
CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso_inv_app_hom₁ | Mathlib.CategoryTheory.Triangulated.Opposite.Triangle | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ]
(X : CategoryTheory.Pretriangulated.Triangle Cᵒᵖ),
((CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso C).inv.app X).hom₁ =
CategoryTheory.CategoryStruct.id X.obj₁ | null | true |
CategoryTheory.Limits.weakPullback.lift.congr_simp | Mathlib.CategoryTheory.Limits.WeakLimits.WeakPullbacks | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
[inst_1 : CategoryTheory.Limits.HasWeakPullback f g] (h h_1 : W ⟶ X) (e_h : h = h_1) (k k_1 : W ⟶ Y) (e_k : k = k_1)
(w : CategoryTheory.CategoryStruct.comp h f = CategoryTheory.CategoryStruct.comp k g),
CategoryT... | null | true |
Preorder.frestrictLe₂.congr_simp | Mathlib.Probability.Kernel.IonescuTulcea.Maps | ∀ {α : Type u_1} [inst : Preorder α] {π : α → Type u_2} [inst_1 : LocallyFiniteOrderBot α] {a b : α} (hab : a ≤ b)
(f f_1 : (i : ↥(Finset.Iic b)) → π ↑i),
f = f_1 → ∀ (i : ↥(Finset.Iic a)), Preorder.frestrictLe₂ hab f i = Preorder.frestrictLe₂ hab f_1 i | null | true |
_private.Mathlib.CategoryTheory.Monoidal.Cartesian.FunctorCategory.0.CategoryTheory.Functor.cartesianMonoidalCategory._simp_5 | Mathlib.CategoryTheory.Monoidal.Cartesian.FunctorCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f f' : X ⟶ Y) (g : Y ≅ Z),
(CategoryTheory.CategoryStruct.comp f g.hom = CategoryTheory.CategoryStruct.comp f' g.hom) = (f = f') | null | false |
Matroid.uniqueBaseOn_restrict | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {E I : Set α},
I ⊆ E → ∀ (R : Set α), (Matroid.uniqueBaseOn I E).restrict R = Matroid.uniqueBaseOn (I ∩ R) R | null | true |
FirstOrder.Language.Term.realize_var | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} (v : α → M) (k : α),
FirstOrder.Language.Term.realize v (FirstOrder.Language.var k) = v k | null | true |
MaxTropical.add_pow | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u} [inst : LinearOrder R] [inst_1 : AddMonoid R] [AddLeftMono R] [AddRightMono R] (x y : MaxTropical R)
(n : ℕ), (x + y) ^ n = x ^ n + y ^ n | null | true |
GromovHausdorff.instInhabitedGHSpace._proof_2 | Mathlib.Topology.MetricSpace.GromovHausdorff | {0}.Nonempty | null | false |
Substring.Raw.ValidFor.dropWhile | Batteries.Data.String.Lemmas | ∀ {l m r : List Char} (p : Char → Bool) {s : Substring.Raw},
Substring.Raw.ValidFor l m r s →
Substring.Raw.ValidFor (l ++ List.takeWhile p m) (List.dropWhile p m) r (s.dropWhile p) | null | true |
CategoryTheory.GrothendieckTopology.plusMap_toPlus | Mathlib.CategoryTheory.Sites.Plus | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type w}
[inst_1 : CategoryTheory.Category.{w', w} D]
[inst_2 :
∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)]
(P : CategoryTheory.Functo... | `(P ⟶ P⁺)⁺ = P⁺ ⟶ P⁺⁺` | true |
ZMod.eq_one_or_isUnit_sub_one | Mathlib.FieldTheory.Finite.Basic | ∀ {n p k : ℕ} [Fact (Nat.Prime p)], n = p ^ k → ∀ (a : ZMod n), (orderOf a).Coprime n → a = 1 ∨ IsUnit (a - 1) | null | true |
Lean.Compiler.LCNF.SpecEntry.alreadySpecialized | Lean.Compiler.LCNF.SpecInfo | Lean.Compiler.LCNF.SpecEntry → Bool | True if `declName` was already specialized before. This is relevant because we specialize
declarations that have already been specialized less aggressively than declarations that have not.
| true |
NumberField.IsCMField.starRing._proof_2 | Mathlib.NumberTheory.NumberField.CMField | ∀ (K : Type u_1) [inst : Field K] [inst_1 : CharZero K] [inst_2 : NumberField.IsCMField K]
[inst_3 : Algebra.IsIntegral ℚ K] (x x_1 : K),
(NumberField.IsCMField.complexConj K) (x + x_1) =
(NumberField.IsCMField.complexConj K) x + (NumberField.IsCMField.complexConj K) x_1 | null | false |
MeasurableSpace.DynkinSystem.ext | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_3} {d₁ d₂ : MeasurableSpace.DynkinSystem α}, (∀ (s : Set α), d₁.Has s ↔ d₂.Has s) → d₁ = d₂ | null | true |
CategoryTheory.Abelian.PreservesCoimageImageComparison.iso_inv_left | Mathlib.CategoryTheory.Limits.Preserves.Shapes.AbelianImages | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D]
(F : CategoryTheory.Functor C D) [inst_4 : F.PreservesZeroMorphisms] {X Y : C} (f : X ⟶ Y)
... | null | true |
CategoryTheory.Idempotents.Karoubi.decompId_i_f | Mathlib.CategoryTheory.Idempotents.Karoubi | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P : CategoryTheory.Idempotents.Karoubi C),
P.decompId_i.f = P.p | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.VertexCover.0.SimpleGraph.isVertexCover_empty._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.VertexCover | ∀ {V : Type u} {G : SimpleGraph V}, (G = ⊥) = ∀ (a b : V), ¬G.Adj a b | null | false |
CategoryTheory.ShortComplex.opcyclesMap'_neg | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ : S₁ ⟶ S₂} (h₁ : S₁.RightHomologyData) (h₂ : S₂.RightHomologyData),
CategoryTheory.ShortComplex.opcyclesMap' (-φ) h₁ h₂ = -CategoryTheory.ShortComplex.opcyclesMap' φ h₁ h... | null | true |
Mathlib.Tactic.Monoidal.Context | Mathlib.Tactic.CategoryTheory.Monoidal.Datatypes | Type | The context for evaluating expressions. | true |
toModuleCatFromModuleCatLinearEquiv._proof_3 | Mathlib.RingTheory.Morita.Matrix | ∀ (R : Type u_3) {ι : Type u_1} [inst : Ring R] [inst_1 : Fintype ι] [inst_2 : DecidableEq ι]
(M : ModuleCat (Matrix ι ι R)) (j : ι) (x x_1 : ↑M),
(fun i => ⟨Matrix.single j i 1 • (x + x_1), ⋯⟩) =
(fun i => ⟨Matrix.single j i 1 • x, ⋯⟩) + fun i => ⟨Matrix.single j i 1 • x_1, ⋯⟩ | null | false |
ContinuousLinearMap.isometry_iff_adjoint_comp_self | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {H : Type u_5} [inst_1 : NormedAddCommGroup H] [inst_2 : InnerProductSpace 𝕜 H]
[inst_3 : CompleteSpace H] {K : Type u_6} [inst_4 : NormedAddCommGroup K] [inst_5 : InnerProductSpace 𝕜 K]
[inst_6 : CompleteSpace K] (u : H →L[𝕜] K), Isometry ⇑u ↔ ContinuousLinearMap.adjoint u ∘... | null | true |
_private.Batteries.Data.List.Basic.0.List.scanAuxM.go.match_1 | Batteries.Data.List.Basic | {β : Type u_2} →
{α : Type u_1} →
(motive : List α → β → List β → Sort u_3) →
(x : List α) →
(x_1 : β) →
(x_2 : List β) →
((last : β) → (acc : List β) → motive [] last acc) →
((x : α) → (xs : List α) → (last : β) → (acc : List β) → motive (x :: xs) last acc) → mot... | null | false |
_private.Lean.Compiler.IR.EmitUtil.0.Lean.IR.CollectUsedDecls.collectFnBody._sparseCasesOn_4 | Lean.Compiler.IR.EmitUtil | {motive_2 : Lean.IR.FnBody → Sort u} →
(t : Lean.IR.FnBody) →
((x : Lean.IR.VarId) →
(ty : Lean.IR.IRType) → (e : Lean.IR.Expr) → (b : Lean.IR.FnBody) → motive_2 (Lean.IR.FnBody.vdecl x ty e b)) →
((j : Lean.IR.JoinPointId) →
(xs : Array Lean.IR.Param) → (v b : Lean.IR.FnBody) → motive_2 (... | null | false |
OrderDual.instIsLeftCancelAdd | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : Add α] [IsLeftCancelAdd α], IsLeftCancelAdd αᵒᵈ | null | true |
Lean.VersoDocResult.mk.sizeOf_spec | Lean.DocString.Add | ∀ (toVersoDocString : Lean.VersoDocString) (deferredChecks : Array Lean.Doc.DeferredCheck),
sizeOf { toVersoDocString := toVersoDocString, deferredChecks := deferredChecks } =
1 + sizeOf toVersoDocString + sizeOf deferredChecks | null | true |
Int.add | Init.Data.Int.Basic | ℤ → ℤ → ℤ | Addition of integers, usually accessed via the `+` operator.
This function is overridden by the compiler with an efficient implementation. This definition is
the logical model.
Examples:
* `(7 : Int) + (6 : Int) = 13`
* `(6 : Int) + (-6 : Int) = 0`
| true |
CategoryTheory.GrothendieckTopology.Cover.instInhabited | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} → {J : CategoryTheory.GrothendieckTopology C} → Inhabited (J.Cover X) | null | true |
Std.Do.SPred.entails_3._simp_1 | Std.Do.SPred.DerivedLaws | ∀ {σ₁ σ₂ σ₃ : Type u_1} {P Q : Std.Do.SPred [σ₁, σ₂, σ₃]},
(P ⊢ₛ Q) = ∀ (s₁ : σ₁) (s₂ : σ₂) (s₃ : σ₃), (P s₁ s₂ s₃).down → (Q s₁ s₂ s₃).down | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.