name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
PartialEquiv.coe_trans | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : PartialEquiv α β) (e' : PartialEquiv β γ), ↑(e.trans e') = ↑e' ∘ ↑e | null | true |
_private.Mathlib.Logic.Equiv.Basic.0.Equiv.swap_eq_update._proof_1_2 | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} [inst : DecidableEq α] (i j : α), ⇑(Equiv.swap i j) = Function.update (Function.update id j i) i j | null | false |
AffineSubspace.direction_eq_bot_iff | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {s : AffineSubspace k P}, s.direction = ⊥ ↔ (↑s).Subsingleton | null | true |
Set.image_affine_Ioc | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {K : Type u_2} [inst : DivisionSemiring K] [inst_1 : PartialOrder K] [PosMulReflectLT K] [IsOrderedCancelAddMonoid K]
[ExistsAddOfLE K] {a : K},
0 < a → ∀ (b c d : K), (fun x => a * x + b) '' Set.Ioc c d = Set.Ioc (a * c + b) (a * d + b) | null | true |
MeasureTheory.lintegral_subtype_comap | Mathlib.MeasureTheory.Integral.Lebesgue.Map | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α},
MeasurableSet s →
∀ (f : α → ENNReal), ∫⁻ (x : ↑s), f ↑x ∂MeasureTheory.Measure.comap Subtype.val μ = ∫⁻ (x : α) in s, f x ∂μ | null | true |
Std.HashMap.toArray | Std.Data.HashMap.Basic | {α : Type u} → {β : Type v} → {x : BEq α} → {x_1 : Hashable α} → Std.HashMap α β → Array (α × β) | Transforms the hash map into an array of mappings in some order. | true |
AlgebraicGeometry.Scheme.instHasIsosFpqcPrecoverage | Mathlib.AlgebraicGeometry.Sites.Fpqc | AlgebraicGeometry.Scheme.fpqcPrecoverage.HasIsos | null | true |
ENNReal.continuous_ofReal | Mathlib.Topology.Instances.ENNReal.Lemmas | Continuous ENNReal.ofReal | null | true |
CategoryTheory.SplitEpi._sizeOf_inst | Mathlib.CategoryTheory.EpiMono | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{X Y : C} → (f : X ⟶ Y) → [SizeOf C] → SizeOf (CategoryTheory.SplitEpi f) | null | false |
Mathlib.Tactic.Monoidal.evalWhiskerRight_cons_of_of | Mathlib.Tactic.CategoryTheory.Monoidal.Normalize | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {f g h i j : C}
{α : f ≅ g} {η : g ⟶ h} {ηs : h ⟶ i}
{ηs₁ : CategoryTheory.MonoidalCategoryStruct.tensorObj h j ⟶ CategoryTheory.MonoidalCategoryStruct.tensorObj i j}
{η₁ : CategoryTheory.MonoidalCategoryStruct.t... | null | true |
_private.Mathlib.Data.Nat.Log.0.Nat.log.go_spec._simp_1_6 | Mathlib.Data.Nat.Log | ∀ (a m n : ℕ), (a ^ m) ^ n = a ^ (m * n) | null | false |
CategoryTheory.Functor.instPreservesColimitsOfShapeOfIsLeftAdjoint | Mathlib.CategoryTheory.Adjunction.Limits | ∀ {J : Type u_1} {C : Type u_2} {D : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] [inst_2 : CategoryTheory.Category.{v_3, u_3} D]
(F : CategoryTheory.Functor C D) [F.IsLeftAdjoint], CategoryTheory.Limits.PreservesColimitsOfShape J F | null | true |
_private.Init.Data.Int.DivMod.Basic.0.Int.fdiv.match_1.eq_3 | Init.Data.Int.DivMod.Basic | ∀ (motive : ℤ → ℤ → Sort u_1) (m n : ℕ) (h_1 : (x : ℤ) → motive 0 x)
(h_2 : (m n : ℕ) → motive (Int.ofNat m) (Int.ofNat n)) (h_3 : (m n : ℕ) → motive (Int.ofNat m.succ) (Int.negSucc n))
(h_4 : (a : ℕ) → motive (Int.negSucc a) 0) (h_5 : (m n : ℕ) → motive (Int.negSucc m) (Int.ofNat n.succ))
(h_6 : (m n : ℕ) → moti... | null | true |
Std.Iter.atIdxSlow?._proof_1 | Init.Data.Iterators.Consumers.Access | ∀ {α β : Type u_1} (a : Std.Iter β) (b : ℕ), Nonempty (Option β) | null | false |
CategoryTheory.sum.inverseAssociator_obj_inr_inr | Mathlib.CategoryTheory.Sums.Associator | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(E : Type u₃) [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (X : E),
(CategoryTheory.sum.inverseAssociator C D E).obj (Sum.inr (Sum.inr X)) = Sum.inr X | null | true |
_private.Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence.0.CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore.i₀_le._proof_1_2 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (r r' : ℤ), r + 1 = r' → r ≤ r' | null | false |
Mathlib.Meta.NormNum.Result'.isNNRat.injEq | Mathlib.Tactic.NormNum.Result | ∀ (inst : Lean.Expr) (q : ℚ) (n d proof inst_1 : Lean.Expr) (q_1 : ℚ) (n_1 d_1 proof_1 : Lean.Expr),
(Mathlib.Meta.NormNum.Result'.isNNRat inst q n d proof =
Mathlib.Meta.NormNum.Result'.isNNRat inst_1 q_1 n_1 d_1 proof_1) =
(inst = inst_1 ∧ q = q_1 ∧ n = n_1 ∧ d = d_1 ∧ proof = proof_1) | null | true |
Qq.Impl.UnquoteState.exprSubst._default | Qq.Macro | Std.HashMap Lean.Expr Lean.Expr | null | false |
alternatingGroup.isMultiplyPretransitive | Mathlib.GroupTheory.GroupAction.MultipleTransitivity | ∀ (α : Type u_1) [inst : Fintype α] [inst_1 : DecidableEq α],
MulAction.IsMultiplyPretransitive (↥(alternatingGroup α)) α (Nat.card α - 2) | The `alternatingGroup` on `α` is `(Nat.card α - 2)`-pretransitive. | true |
Lean.Server.WithRpcRef.rec | Lean.Server.Rpc.Basic | {α : Type u} →
{motive : Lean.Server.WithRpcRef α → Sort u_1} →
((val : α) → (id : USize) → motive { val := val, id := id }) → (t : Lean.Server.WithRpcRef α) → motive t | null | false |
Matrix.linftyOpSeminormedAddCommGroup._proof_7 | Mathlib.Analysis.Matrix.Normed | ∀ {m : Type u_1} {n : Type u_2} {α : Type u_3} [inst : Fintype m] [inst_1 : Fintype n]
[inst_2 : SeminormedAddCommGroup α],
autoParam (∀ (x y : Matrix m n α), dist x y = ‖-x + y‖) SeminormedAddCommGroup.dist_eq._autoParam | null | false |
Real.sinh_eq_zero | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ {x : ℝ}, Real.sinh x = 0 ↔ x = 0 | null | true |
eq_iff_iff._simp_1 | Init.Core | ∀ {a b : Prop}, (a = b) = (a ↔ b) | null | false |
_private.Mathlib.LinearAlgebra.ExteriorAlgebra.BaseChange.0.ExteriorAlgebra.baseChangeEquivForward.eq_1 | Mathlib.LinearAlgebra.ExteriorAlgebra.BaseChange | ∀ (R : Type u_1) [inst : CommRing R] (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M] (S : Type u_3)
[inst_3 : CommRing S] [inst_4 : Algebra R S],
ExteriorAlgebra.baseChangeEquivForward✝ R M S =
Algebra.TensorProduct.lift (Algebra.ofId S (ExteriorAlgebra S (TensorProduct R S M)))
(ExteriorAl... | null | true |
Monoid.Coprod.mrange_lift | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} {P : Type u_3} [inst : MulOneClass M] [inst_1 : MulOneClass N] [inst_2 : Monoid P]
(f : M →* P) (g : N →* P), MonoidHom.mrange (Monoid.Coprod.lift f g) = MonoidHom.mrange f ⊔ MonoidHom.mrange g | null | true |
_private.Lean.Data.Options.0.Lean.optionDeclsRef._proof_1 | Lean.Data.Options | Nonempty (ST.Ref IO.RealWorld Lean.OptionDecls) | null | false |
_private.Mathlib.Tactic.Determinant.Bird.Meta.0.Mathlib.Tactic.Determinant.reifyBirdDet.match_117 | Mathlib.Tactic.Determinant.Bird.Meta | (motive : Option Q(ℕ) → Sort u_1) →
(__x : Option Q(ℕ)) →
((dimensionLit : Q(ℕ)) → motive (some dimensionLit)) → ((x : Option Q(ℕ)) → motive x) → motive __x | null | false |
NonemptyInterval.instPreorderLex._proof_3 | Mathlib.Order.Interval.Lex | ∀ {α : Type u_1} [inst : Preorder α],
autoParam (∀ (a b : Lex (NonemptyInterval α)), a < b ↔ a ≤ b ∧ ¬b ≤ a) Preorder.lt_iff_le_not_ge._autoParam | null | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms.0.SimplexCategoryGenRel.standardσ_simplicialInsert._proof_1_24 | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms | ∀ (m₁ a : ℕ) (L : List ℕ) {m : ℕ} (j : ℕ),
m + (a :: L).length + 1 = m₁ → ¬j < a → m + 1 + (SimplexCategoryGenRel.simplicialInsert (j + 1) L).length = m₁ | null | false |
AddCon.recOn | Mathlib.GroupTheory.Congruence.Defs | {M : Type u_1} →
[inst : Add M] →
{motive : AddCon M → Sort u} →
(t : AddCon M) →
((toSetoid : Setoid M) →
(add' : ∀ {w x y z : M}, toSetoid w x → toSetoid y z → toSetoid (w + y) (x + z)) →
motive { toSetoid := toSetoid, add' := add' }) →
motive t | null | false |
instIsUniformAddGroupReal | Mathlib.Topology.Algebra.Ring.Real | IsUniformAddGroup ℝ | null | true |
CategoryTheory.Functor.partialLeftAdjointHomEquiv | Mathlib.CategoryTheory.Adjunction.PartialAdjoint | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(F : CategoryTheory.Functor D C) →
{X : F.PartialLeftAdjointSource} → {Y : D} → (F.partialLeftAdjointObj X ⟶ Y) ≃ (X.obj ⟶ F.obj Y) | Given `F : D ⥤ C`, this is the canonical bijection
`(F.partialLeftAdjointObj X ⟶ Y) ≃ (X.obj ⟶ F.obj Y)`
for all `X : F.PartialLeftAdjointSource` and `Y : D`. | true |
Array.pairwise_singleton | Batteries.Data.Array.Pairwise | ∀ {α : Type u_1} (R : α → α → Prop) (a : α), Array.Pairwise R #[a] | null | true |
_private.Mathlib.LinearAlgebra.TensorProduct.Defs.0.TensorProduct.map₂_mk_top_top_eq_top.match_1_1 | Mathlib.LinearAlgebra.TensorProduct.Defs | ∀ (R : Type u_3) [inst : CommSemiring R] (M : Type u_1) (N : Type u_2) [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (x : TensorProduct R M N)
(motive : x ∈ {t | ∃ m n, m ⊗ₜ[R] n = t} → Prop) (x_1 : x ∈ {t | ∃ m n, m ⊗ₜ[R] n = t}),
(∀ (m : M) (n : N) (h : m ⊗ₜ[R... | null | false |
Prod.instSubtractionMonoid._proof_3 | Mathlib.Algebra.Group.Prod | ∀ {G : Type u_1} {H : Type u_2} [inst : SubtractionMonoid G] [inst_1 : SubtractionMonoid H] (x x_1 : G × H),
x + x_1 = 0 → -x = x_1 | null | false |
SetSemiring.instCompleteBooleanAlgebra._proof_9 | Mathlib.Data.Set.Semiring | ∀ {α : Type u_1} (a b : SetSemiring α), SetSemiring.instCompleteBooleanAlgebra._aux_6 a b ≤ b | null | false |
Rep.FiniteCyclicGroup.groupCohomologyIsoEven._proof_5 | Mathlib.RepresentationTheory.Homological.GroupCohomology.FiniteCyclic | ∀ (i : ℕ), (ComplexShape.up ℕ).Rel i ((ComplexShape.up ℕ).next i) | null | false |
_private.Mathlib.Topology.Algebra.Module.Basic.0.Submodule.closure_coe_iSup_map_single._simp_1_1 | Mathlib.Topology.Algebra.Module.Basic | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {s : Set X},
(x ∈ closure s) = ∀ (o : Set X), IsOpen o → x ∈ o → (o ∩ s).Nonempty | null | false |
Lean.Elab.Command.InductiveElabStep1.mk.noConfusion | Lean.Elab.MutualInductive | {P : Sort u} →
{view : Lean.Elab.Command.InductiveView} →
{elabCtors :
Array Lean.Elab.Command.ElabHeaderResult →
Lean.Elab.Command.ElabHeaderResult →
Array Lean.Expr → Lean.Elab.TermElabM Lean.Elab.Command.InductiveElabStep2} →
{view' : Lean.Elab.Command.InductiveView} →
... | null | false |
Inclusion.HypothesisM.Context.noConfusionType | Mathlib.Tactic.Inclusion.Core.Types | Sort u → Inclusion.HypothesisM.Context → Inclusion.HypothesisM.Context → Sort u | null | false |
Booleanisation.lift_sdiff_lift | Mathlib.Order.Booleanisation | ∀ {α : Type u_1} [inst : GeneralizedBooleanAlgebra α] (a b : α),
Booleanisation.lift a \ Booleanisation.lift b = Booleanisation.lift (a \ b) | null | true |
Ideal.quotEquivPowQuotPowSucc._simp_2 | Mathlib.RingTheory.Ideal.IsPrincipalPowQuotient | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{f : M →ₛₗ[τ₁₂] M₂} {y : M}, (y ∈ f.ker) = (f y = 0) | null | false |
CliffordAlgebraDualNumber.equiv._proof_6 | Mathlib.LinearAlgebra.CliffordAlgebra.Equivs | ∀ {R : Type u_1} [inst : CommRing R], IsScalarTower R Rᵐᵒᵖ R | null | false |
ContDiffMapSupportedIn.tsupport_subset | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {n : ℕ∞} {K : TopologicalSpace.Compacts E} (f : ContDiffMapSupportedIn E F n K),
tsupport ⇑f ⊆ ↑K | null | true |
Setoid.quotientEquivClasses._simp_1 | Mathlib.Order.Setoid.Partition | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | null | false |
AddMonoidAlgebra.coeffLinearEquiv.eq_1 | Mathlib.Algebra.MonoidAlgebra.Module | ∀ (R : Type u_1) {S : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : Module R S],
AddMonoidAlgebra.coeffLinearEquiv R = AddEquiv.linearEquiv R AddMonoidAlgebra.coeffAddEquiv | null | true |
Ordnode.findIndexAux._sunfold | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → [inst : LE α] → [DecidableLE α] → α → Ordnode α → ℕ → Option ℕ | null | false |
Filter.Tendsto.const_smul_zero | Mathlib.Topology.Algebra.ConstMulAction | ∀ {M : Type u_1} {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : Zero α]
[inst_2 : SMulZeroClass M α] [ContinuousConstSMul M α] {g : β → α} {l : Filter β} (c : M),
Filter.Tendsto g l (nhds 0) → Filter.Tendsto (fun x => c • g x) l (nhds 0) | null | true |
Multiset.consEquiv._proof_7 | Mathlib.Data.Multiset.Fintype | ∀ {α : Type u_1} [inst : DecidableEq α] {m : Multiset α} {v : α},
Function.RightInverse (fun x => x.elim ⟨v, ⟨Multiset.count v m, ⋯⟩⟩ fun x => ⟨x.fst, Fin.castLE ⋯ x.snd⟩) fun x =>
if h : x.fst = v ∧ ↑x.snd = Multiset.count v m then none else some ⟨x.fst, ⟨↑x.snd, ⋯⟩⟩ | null | false |
Matrix.PosDef.transpose_iff._simp_1 | Mathlib.LinearAlgebra.Matrix.PosDef | ∀ {n : Type u_2} {R' : Type u_4} [inst : CommRing R'] [inst_1 : PartialOrder R'] [inst_2 : StarRing R']
{M : Matrix n n R'}, M.transpose.PosDef = M.PosDef | null | false |
Std.DTreeMap.Const.get!_insertMany_list_of_mem | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp]
[inst : Inhabited β] {l : List (α × β)} {k k' : α},
cmp k k' = Ordering.eq →
∀ {v : β},
List.Pairwise (fun a b => ¬cmp a.1 b.1 = Ordering.eq) l →
(k, v) ∈ l → Std.DTreeMap.Const.get! (Std.... | null | true |
CategoryTheory.IsSifted.rec | Mathlib.CategoryTheory.Limits.Sifted | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.IsSifted C → Sort u_1} →
([toFinal : (CategoryTheory.Functor.diag C).Final] → [nonempty : Nonempty C] → motive ⋯) →
(t : CategoryTheory.IsSifted C) → motive t | null | false |
CategoryTheory.Triangulated.TStructure.natTransTruncLTOfLE_refl | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} 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 : CategoryTheory.... | null | true |
Complex.arg_conj_coe_angle | Mathlib.Analysis.SpecialFunctions.Complex.Arg | ∀ (x : ℂ), ↑((starRingEnd ℂ) x).arg = -↑x.arg | null | true |
SchwartzMap.pairing._proof_3 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {𝕜 : Type u_4} {D : Type u_1} {E : Type u_5} {F : Type u_2} {G : Type u_3} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F]
[inst_4 : NontriviallyNormedField 𝕜] [inst_5 : NormedAlgebra ℝ 𝕜] [inst_6 : NormedAddCommGroup D]
[inst_7 : NormedSpac... | null | false |
List.eraseIdx_eq_eraseIdxTR | Init.Data.List.Impl | @List.eraseIdx = @List.eraseIdxTR | null | true |
ProbabilityTheory.centralMoment.eq_1 | Mathlib.Probability.Moments.Basic | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} (X : Ω → ℝ) (p : ℕ) (μ : MeasureTheory.Measure Ω),
ProbabilityTheory.centralMoment X p μ = ∫ (x : Ω), ((X - fun x => ∫ (x : Ω), X x ∂μ) ^ p) x ∂μ | null | true |
Fin.encodeSubtype | Batteries.Data.Fin.Coding | {n : ℕ} → (P : Fin n → Prop) → [inst : DecidablePred P] → { i // P i } → Fin (Fin.countP fun x => decide (P x)) | Encode `{ i : Fin n // P i }` into `Fin (Fin.countP P)` where `P` is a decidable predicate. | true |
chart_mem_atlas._simp_1 | Mathlib.Geometry.Manifold.ChartedSpace | ∀ (H : Type u_4) {M : Type u_5} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M]
(x : M), (chartAt H x ∈ atlas H M) = True | null | false |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.insertIfNew._proof_5 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (t : Std.DTreeMap.Internal.Impl α β), t.size ≤ t.size + 1 | null | false |
Std.Internal.ForIn.toList_iter | Std.Internal.ForIn.Lemmas | ∀ {α γ : Type w} [inst : Std.Iterator α Id γ] [Std.Iterators.Finite α Id] [inst_2 : Std.IteratorLoop α Id Id]
[Std.LawfulIteratorLoop α Id Id] (it : Std.Iter γ), ForIn.toList it = it.toList | `ForIn.toList` on an iterator is the iterator's own `toList`, so every container whose `ForIn`
loop iterates its `Std.ToIterator` reaches the iterator lemmas through this one step. | true |
Con.conGen_idem | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Mul M] (r : M → M → Prop), conGen ⇑(conGen r) = conGen r | The map sending a binary relation to the smallest congruence relation in which it is
contained is idempotent. | true |
IsDedekindDomain.one_le_primesOver_ncard | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ {A : Type u_4} [inst : CommRing A] (p : Ideal A) [hpm : p.IsMaximal] (B : Type u_5) [inst_1 : CommRing B]
[IsDedekindDomain B] [inst_3 : Algebra A B] [IsDomain A] [Module.IsTorsionFree A B] [Algebra.IsIntegral A B],
1 ≤ (p.primesOver B).ncard | null | true |
divMonoidWithZeroHom._proof_1 | Mathlib.Algebra.GroupWithZero.Prod | ∀ {M₀ : Type u_1} [inst : CommGroupWithZero M₀], 0 / 0.2 = 0 | null | false |
gt_or_lt_of_ne | Mathlib.Order.Defs.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, a ≠ b → b < a ∨ a < b | null | true |
BoxIntegral.TaggedPrepartition.mem_toPrepartition._simp_1 | Mathlib.Analysis.BoxIntegral.Partition.Tagged | ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι} {π : BoxIntegral.TaggedPrepartition I}, (J ∈ π.toPrepartition) = (J ∈ π) | null | false |
LinearMap.intrinsicInvolutiveStar | Mathlib.Algebra.Star.LinearMap | {R : Type u_1} →
{E : Type u_2} →
{F : Type u_3} →
[inst : Semiring R] →
[inst_1 : InvolutiveStar R] →
[inst_2 : AddCommMonoid E] →
[inst_3 : Module R E] →
[inst_4 : StarAddMonoid E] →
[StarModule R E] →
[inst_6 : AddCommMonoid F]... | The involutive intrinsic star structure on linear maps. | true |
Order.Iic_pred_of_not_isMin | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] {a : α}, ¬IsMin a → Set.Iic (Order.pred a) = Set.Iio a | null | true |
Std.Sat.AIG.LawfulVecOperator.le_size_of_le_aig_size | Std.Sat.AIG.LawfulVecOperator | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {β : Std.Sat.AIG α → ℕ → Type}
{f : {len : ℕ} → (aig : Std.Sat.AIG α) → β aig len → Std.Sat.AIG.RefVecEntry α len}
[Std.Sat.AIG.LawfulVecOperator α β fun {len} => f] {len x : ℕ} (aig : Std.Sat.AIG α) (input : β aig len),
x ≤ aig.decls.size → x ≤ (f aig inp... | null | true |
OrderIso.coe_dualDual | Mathlib.Order.Hom.Basic | ∀ (α : Type u_2) [inst : LE α], ⇑(OrderIso.dualDual α) = ⇑OrderDual.toDual ∘ ⇑OrderDual.toDual | null | true |
Nat.le_of_add_left_le | Init.Data.Nat.Basic | ∀ {n m k : ℕ}, k + n ≤ m → n ≤ m | null | true |
Real.smul_iSup_of_nonneg | Mathlib.Basic.Real.Pointwise | ∀ {ι : Sort u_1} {α : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α]
[inst_3 : MulActionWithZero α ℝ] [IsOrderedModule α ℝ] {a : α}, 0 ≤ a → ∀ (f : ι → ℝ), a • ⨆ i, f i = ⨆ i, a • f i | null | true |
_private.Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup.0.MulAction.fixingSubgroup_le_stabilizer._simp_1_1 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup | ∀ (M : Type u_1) {α : Type u_2} [inst : Group M] [inst_1 : MulAction M α] {s : Set α} {m : M},
(m ∈ fixingSubgroup M s) = ∀ y ∈ s, m • y = y | null | false |
_private.Std.Data.DHashMap.RawLemmas.0.Std.DHashMap.Raw.Const.mem_modify._simp_1_1 | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} {a : α},
(a ∈ m) = (m.contains a = true) | null | false |
Order.lt_succ_iff_of_not_isMax' | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : SuccOrder α] {a b : α}, ¬IsMax b → (b < Order.succ a ↔ b ≤ a) | null | true |
Std.DTreeMap.getKey_eq_getKeyD | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {a fallback : α}
{h : a ∈ t}, t.getKey a h = t.getKeyD a fallback | null | true |
Ideal.mem_iSup_of_mem | Mathlib.RingTheory.Ideal.Lattice | ∀ {R : Type u} [inst : Semiring R] {ι : Sort u_1} {S : ι → Ideal R} (i : ι) {x : R}, x ∈ S i → x ∈ iSup S | null | true |
Real.mem_closure_iff | Mathlib.Topology.Instances.Real.Lemmas | ∀ {s : Set ℝ} {x : ℝ}, x ∈ closure s ↔ ∀ ε > 0, ∃ y ∈ s, |y - x| < ε | null | true |
CategoryTheory.WideSubcategory.instMonoidalCategoryStruct._proof_8 | Mathlib.CategoryTheory.Monoidal.Widesubcategory | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (P : CategoryTheory.MorphismProperty C)
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : P.IsMonoidalStable] (x : CategoryTheory.WideSubcategory P),
P (CategoryTheory.MonoidalCategoryStruct.leftUnitor x.obj).inv | null | false |
_private.Mathlib.SetTheory.Cardinal.Arithmetic.0.Cardinal.mk_compl_eq_mk_compl_finite_lift._simp_1_1 | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] {m n : ℕ}, (↑m = ↑n) = (m = n) | null | false |
Std.ExtDTreeMap.union.congr_simp | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] (m₁ m₁_1 : Std.ExtDTreeMap α β cmp),
m₁ = m₁_1 → ∀ (m₂ m₂_1 : Std.ExtDTreeMap α β cmp), m₂ = m₂_1 → m₁.union m₂ = m₁_1.union m₂_1 | null | true |
_private.Mathlib.GroupTheory.Coxeter.Basic.0.CoxeterSystem.getElem_alternatingWord._proof_1_1 | Mathlib.GroupTheory.Coxeter.Basic | ∀ {B : Type u_1} (i j : B) (k : ℕ) (h : k < 0), (CoxeterSystem.alternatingWord i j 0)[k] = if Even (0 + k) then i else j | null | false |
_private.Mathlib.Order.SuccPred.Limit.0.WithTop.isSuccPrelimit_iff_of_isSuccArchimedean._simp_1_2 | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} [inst : LE α] [Nonempty α] {x : WithTop α}, IsMin x = ∃ y, x = ↑y ∧ IsMin y | null | false |
StrictAntiOn.strictAnti | Mathlib.Data.Set.Monotone | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β} [inst : Preorder α] [inst_1 : Preorder β],
StrictAntiOn f s → StrictAnti (f ∘ Subtype.val) | null | true |
_private.Batteries.Recycling.RBTree.Lemmas.0.RBTree.RBNode.Any_def._simp_1_2 | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Sort u_1} {p q : α → Prop}, (∃ x, p x ∨ q x) = ((∃ x, p x) ∨ ∃ x, q x) | null | false |
_private.Std.Data.DHashMap.Lemmas.0.Std.DHashMap.isEmpty_iff_forall_not_mem._simp_1_1 | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} {a : α},
(a ∈ m) = (m.contains a = true) | null | false |
AddSubgroup.closure_prod | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_4} [inst_1 : AddGroup N] {s : Set G} {t : Set N},
0 ∈ s → 0 ∈ t → AddSubgroup.closure (s ×ˢ t) = (AddSubgroup.closure s).prod (AddSubgroup.closure t) | null | true |
Std.DHashMap.Raw.getKeyD_union_of_not_mem_left | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : α → Type v} {m₁ m₂ : Std.DHashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → ∀ {k fallback : α}, k ∉ m₁ → (m₁ ∪ m₂).getKeyD k fallback = m₂.getKeyD k fallback | null | true |
commGrpTypeEquivalenceCommGrpForgetGrp | Mathlib.CategoryTheory.Monoidal.Internal.Types.CommGrp_ | CommGrpTypeEquivalenceCommGrp.functor.comp (CategoryTheory.forget₂ CommGrpCat GrpCat) ≅
(CategoryTheory.CommGrp.forget₂Grp (Type u)).comp GrpTypeEquivalenceGrp.functor | The equivalences `Grp (Type u) ≌ GrpCat.{u}` and `CommGrp (Type u) ≌ CommGrpCat.{u}`
are naturally compatible with the forgetful functors to `GrpCat` and `Grp (Type u)`.
| true |
_private.Lean.AuxRecursor.0.Lean.initFn._@.Lean.AuxRecursor.235549338._hygCtx._hyg.2 | Lean.AuxRecursor | IO Lean.TagDeclarationExtension | null | false |
Matrix.star_vec_dotProduct_vec | Mathlib.LinearAlgebra.Matrix.Vec | ∀ {m : Type u_2} {n : Type u_3} {R : Type u_1} [inst : AddCommMonoid R] [inst_1 : Mul R] [inst_2 : Star R]
[inst_3 : Fintype m] [inst_4 : Fintype n] (A B : Matrix m n R), star A.vec ⬝ᵥ B.vec = (A.conjTranspose * B).trace | null | true |
IsLindelof.compl_mem_sets | Mathlib.Topology.Compactness.Lindelof | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X},
IsLindelof s → ∀ {f : Filter X} [CountableInterFilter f], (∀ x ∈ s, sᶜ ∈ nhds x ⊓ f) → sᶜ ∈ f | The complement to a Lindelöf set belongs to a filter `f` with the countable intersection
property if it belongs to each filter `𝓝 x ⊓ f`, `x ∈ s`. | true |
Lean.Meta.Grind.Arith.CommRing.Ring.mulFn?._default | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Option Lean.Expr | null | false |
asymptoticCone | Mathlib.Topology.Algebra.AsymptoticCone | (k : Type u_1) →
{V : Type u_2} →
{P : Type u_3} →
[inst : Field k] →
[LinearOrder k] →
[inst_2 : AddCommGroup V] → [Module k V] → [AddTorsor V P] → [TopologicalSpace V] → Set P → Set V | The set of directions `v` for which the set has points arbitrarily far in directions near `v`.
| true |
Filter.HasAntitoneBasis.subbasis_with_rel | Mathlib.Order.Filter.AtTopBot.Finite | ∀ {α : Type u_2} {f : Filter α} {s : ℕ → Set α},
f.HasAntitoneBasis s →
∀ {r : ℕ → ℕ → Prop},
(∀ (m : ℕ), ∀ᶠ (n : ℕ) in Filter.atTop, r m n) →
∃ φ, StrictMono φ ∧ (∀ ⦃m n : ℕ⦄, m < n → r (φ m) (φ n)) ∧ f.HasAntitoneBasis (s ∘ φ) | Given an antitone basis `s : ℕ → Set α` of a filter, extract an antitone subbasis `s ∘ φ`,
`φ : ℕ → ℕ`, such that `m < n` implies `r (φ m) (φ n)`. This lemma can be used to extract an
antitone basis with basis sets decreasing "sufficiently fast". | true |
_private.Batteries.Lean.Expr.0.Lean.Expr.withApp'.go.match_1 | Batteries.Lean.Expr | (motive : Lean.Expr → Array Lean.Expr → ℕ → Sort u_1) →
(x : Lean.Expr) →
(x_1 : Array Lean.Expr) →
(x_2 : ℕ) →
((data : Lean.MData) →
(b : Lean.Expr) → (as : Array Lean.Expr) → (i : ℕ) → motive (Lean.Expr.mdata data b) as i) →
((f a : Lean.Expr) → (as : Array Lean.Expr) → (i :... | null | false |
IsLocalizedModule.mk'_smul | 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] {R₀ : Type u_6} [inst_6 : SMul R₀ R] [inst_7 : SMul R₀ M] [inst_8 : SMul R₀ ... | null | true |
CategoryTheory.Pretriangulated.Opposite.commShiftFunctorOpInt._proof_2 | Mathlib.CategoryTheory.Triangulated.Opposite.Functor | ∀ (a b : ℤ), -(a + b) = -a + -b | null | false |
Mathlib.Tactic.Rify.ratCast_eq | Mathlib.Tactic.Rify | ∀ (a b : ℚ), a = b ↔ ↑a = ↑b | null | true |
FiniteField.algEquivOfCardEq._proof_2 | Mathlib.FieldTheory.Finite.GaloisField | ∀ {K : Type u_1} [inst : Fintype K] (p : ℕ) (n : ℕ+), Nat.Prime p ∧ Fintype.card K = p ^ ↑n → Fintype.card K = p ^ ↑n | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.