name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Elab.Command.0.Lean.Elab.Command.mkTermContext | Lean.Elab.Command | Lean.Elab.Command.Context → Lean.Elab.Command.State → Lean.Elab.Command.CommandElabM Lean.Elab.Term.Context | null | true |
_private.Mathlib.Data.Finset.PImage.0.Finset.pimage_inter._simp_1_2 | Mathlib.Data.Finset.PImage | ∀ {α : Type u_1} {β : Type u_2} (f : α →. β) (s t : Set α), (f.image (s ∩ t) ⊆ f.image s ∩ f.image t) = True | null | false |
WithBot.bot_ne_natCast | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : AddMonoidWithOne α] (n : ℕ), ⊥ ≠ ↑n | null | true |
StarSubalgebra.inclusion._proof_5 | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : StarRing A] [inst_4 : Algebra R A] [inst_5 : StarModule R A] {S₁ S₂ : StarSubalgebra R A} (h : S₁ ≤ S₂)
(x : R), Subtype.map id h ((algebraMap R ↥S₁) x) = Subtype.map id h ((algebraMap R ↥S₁) x) | null | false |
CategoryTheory.Limits.pullbackLeftPullbackSndIso_inv_fst_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) (g' : W ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasPullback f g]
[inst_2 : CategoryTheory.Limits.HasPullback (CategoryTheory.Limits.pullback.snd f g) g'] {Z_1 : C} (h : X ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (Categor... | null | true |
_private.Mathlib.Data.Finset.Insert.0.Finset.coe_subset_singleton._proof_1_1 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {s : Finset α} {a : α}, ↑s ⊆ {a} ↔ s ⊆ {a} | null | false |
Tactic.ComputeAsymptotics.Seq.instMetricSpaceStream'._proof_14 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | ∀ {α : Type u_1},
(Tactic.ComputeAsymptotics.Seq.instMetricSpaceStream'._aux_11.lift' fun s => SetRel.comp s s) ≤
Tactic.ComputeAsymptotics.Seq.instMetricSpaceStream'._aux_11 | null | false |
List.mapTR.loop.eq_2 | Init.Data.List.Basic | ∀ {α : Type u} {β : Type v} (f : α → β) (a : List β) (a_1 : α) (as : List α),
List.mapTR.loop f (a_1 :: as) a = List.mapTR.loop f as (f a_1 :: a) | null | true |
LinearEquiv.toFGModuleCatIso._proof_1 | Mathlib.Algebra.Category.FGModuleCat.Basic | ∀ {R : Type u_2} [inst : Ring R] {V W : Type u_1} [inst_1 : AddCommGroup V] [inst_2 : Module R V]
[inst_3 : Module.Finite R V] [inst_4 : AddCommGroup W] [inst_5 : Module R W] [inst_6 : Module.Finite R W]
(e : V ≃ₗ[R] W),
CategoryTheory.CategoryStruct.comp (CategoryTheory.ConcreteCategory.ofHom ↑e)
(Category... | null | false |
Std.DTreeMap.Internal.Impl.forInStep_eq_foldlM | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} {δ : Type w} {t : Std.DTreeMap.Internal.Impl α β} {m : Type w → Type w'}
[inst : Monad m] [LawfulMonad m] {f : (a : α) → β a → δ → m (ForInStep δ)} {init : δ},
Std.DTreeMap.Internal.Impl.forInStep f init t =
Std.DTreeMap.Internal.Impl.foldlM
(fun x =>
match (motive ... | null | true |
CategoryTheory.AddMon.instCartesianMonoidalCategory._proof_6 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (M N : CategoryTheory.AddMon C) {T : CategoryTheory.AddMon C} (f : T ⟶ M)
(g : T ⟶ N),
CategoryTheory.CategoryStruct.comp
{ hom := CategoryTheory.C... | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0.BitVec.reduceSMTUDiv._regBuiltin.BitVec.reduceSMTUDiv.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.310104482._hygCtx._hyg.29 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit | null | false |
CommGroup.primaryComponent._proof_1 | Mathlib.GroupTheory.Torsion | ∀ (G : Type u_1) [inst : CommGroup G] (p : ℕ) {g : G},
g ∈ (CommMonoid.primaryComponent G p).carrier → g⁻¹ ∈ (CommMonoid.primaryComponent G p).carrier | null | false |
Finsupp.embDomain_apply | Mathlib.Data.Finsupp.Defs | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_4} [inst : Zero M] (f : α ↪ β) (v : α →₀ M) (b : β),
(Finsupp.embDomain f v) b = if h : ∃ a, f a = b then v h.choose else 0 | null | true |
Mathlib.Meta.NormNum.isFibAux_two_mul_add_one_done | Mathlib.Tactic.NormNum.NatFib | ∀ {n a b n' a' : ℕ}, Mathlib.Meta.NormNum.IsFibAux n a b → 2 * n + 1 = n' → a * a + b * b = a' → Nat.fib n' = a' | null | true |
_private.Mathlib.Probability.UniformOn.0.ProbabilityTheory.uniformOn_pi._simp_1_1 | Mathlib.Probability.UniformOn | ∀ {α : Type u} (s : Set α) [Finite ↑s], s.Finite = True | null | false |
Denumerable.sum._proof_3 | Mathlib.Basic.Denumerable | ∀ {α : Type u_1} {β : Type u_2} [inst : Denumerable α] [inst_1 : Denumerable β] (n : ℕ),
∃ a ∈ Encodable.decode n, Encodable.encode a = n | null | false |
_private.Init.Data.Array.Sort.Basic.0.Array.MergeSort.Internal.merge.go._unsafe_rec | Init.Data.Array.Sort.Basic | {α : Type u_1} →
(α → α → Bool) → (xs ys : Subarray α) → 0 < Std.Slice.size xs → 0 < Std.Slice.size ys → Array α → Array α | null | false |
Aesop.Script.LazyStep.runFirstSuccessfulTacticBuilder | Aesop.Script.Step | Aesop.Script.LazyStep → Lean.MetaM Aesop.Script.Tactic | null | true |
AddCon.congr_symm | Mathlib.GroupTheory.Congruence.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : Add M] [inst_1 : Add N] {c : AddCon M} {d : AddCon N} (e : M ≃+ N)
(h : c = AddCon.comap ⇑e ⋯ d), (AddCon.congr e h).symm = AddCon.congr e.symm ⋯ | null | true |
Finset.sum_powerset | Mathlib.Algebra.BigOperators.Group.Finset.Powerset | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid β] (s : Finset α) (f : Finset α → β),
∑ t ∈ s.powerset, f t = ∑ j ∈ Finset.range (s.card + 1), ∑ t ∈ Finset.powersetCard j s, f t | A sum over `powerset s` is equal to the double sum over sets of subsets of `s`
with `#s = k`, for `k = 0, ..., #s` | true |
tendstoUniformlyOn_tsum_nat | Mathlib.Analysis.Normed.Group.FunctionSeries | ∀ {β : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup F] [CompleteSpace F] {f : ℕ → β → F} {u : ℕ → ℝ},
Summable u →
∀ {s : Set β},
(∀ (n : ℕ), ∀ x ∈ s, ‖f n x‖ ≤ u n) →
TendstoUniformlyOn (fun N x => ∑ n ∈ Finset.range N, f n x) (fun x => ∑' (n : ℕ), f n x) Filter.atTop s | An infinite sum of functions with summable sup norm is the uniform limit of its partial sums.
Version relative to a set, with index set `ℕ`. | true |
Filter.Germ.compTendsto'._proof_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {l : Filter α} {lc : Filter γ} (g : lc.Germ α),
g.Tendsto l → ∀ (_f₁ _f₂ : α → β), _f₁ =ᶠ[l] _f₂ → Filter.Germ.map _f₁ g = Filter.Germ.map _f₂ g | null | false |
_private.Mathlib.NumberTheory.Modular.0.ModularGroup.cases_c_one_d_zero._proof_1_4 | Mathlib.NumberTheory.Modular | 1 + ↑UpperHalfPlane.ρ = -↑UpperHalfPlane.ρ ^ 2 | null | false |
Classical.not_imp._simp_1 | Init.Classical | ∀ {a b : Prop}, (¬(a → b)) = (a ∧ ¬b) | null | false |
CategoryTheory.ShortComplex.LeftHomologyData.leftHomologyIso_hom_naturality_assoc | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology] (φ : S₁ ⟶ S₂)
(h₁ : S₁.LeftHomologyData) (h₂ : S₂.LeftHomologyData) {Z : C} (h : h₂.H ⟶ Z),
CategoryTheory.Catego... | null | true |
_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.State.items._default | Lean.Server.Completion.CompletionCollectors | Array Lean.Lsp.ResolvableCompletionItem | null | false |
MeasureTheory.Measure.ofMeasurable_zero | Mathlib.MeasureTheory.Measure.Module | ∀ {α : Type u_1} {mα : MeasurableSpace α}, MeasureTheory.Measure.ofMeasurable (fun x x_1 => 0) ⋯ ⋯ = 0 | null | true |
Finset.union_smul | Mathlib.Algebra.Group.Pointwise.Finset.Scalar | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] [inst_1 : SMul α β] {s₁ s₂ : Finset α} {t : Finset β}
[inst_2 : DecidableEq α], (s₁ ∪ s₂) • t = s₁ • t ∪ s₂ • t | null | true |
DomMulAct.instDivisionMonoidOfMulOpposite | Mathlib.GroupTheory.GroupAction.DomAct.Basic | {M : Type u_1} → [DivisionMonoid Mᵐᵒᵖ] → DivisionMonoid Mᵈᵐᵃ | null | true |
LinearMap.BilinForm.flip._proof_2 | Mathlib.LinearAlgebra.BilinearForm.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
SMulCommClass R R (M →ₗ[R] R) | null | false |
Matrix.piEquiv._proof_2 | Mathlib.Data.Matrix.Basic | ∀ {m : Type u_1} {n : Type u_2} {ι : Type u_4} {β : ι → Type u_3} (x : (i : ι) → Matrix m n (β i)),
(fun i => (Matrix.of fun j k i => x i j k).map fun x => x i) = fun i =>
(Matrix.of fun j k i => x i j k).map fun x => x i | null | false |
Std.DTreeMap.Raw.ofList_eq_insertMany_empty | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {l : List ((a : α) × β a)},
Std.DTreeMap.Raw.ofList l cmp = ∅.insertMany l | null | true |
HasFPowerSeriesAt.const_smul | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} {F : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{pf : FormalMultilinearSeries 𝕜 E F} {x : E} {R : Type u_9} [inst_5 : NormedRing R] [inst_6 : Modul... | null | true |
CategoryTheory.LiftLeftAdjoint.otherMap.eq_1 | Mathlib.CategoryTheory.Adjunction.Lifting.Left | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
{U : CategoryTheory.Functor B C} {F : CategoryTheory.Functor C B} (R : CategoryTheory.Functor A B)
(F' : CategoryTheory.Functor C A) (... | null | true |
SheafOfModules.pushforwardId | Mathlib.Algebra.Category.ModuleCat.Sheaf.PushforwardContinuous | {D : Type u₂} →
[inst : CategoryTheory.Category.{v₂, u₂} D] →
{K : CategoryTheory.GrothendieckTopology D} →
(R : CategoryTheory.Sheaf K RingCat) →
SheafOfModules.pushforward (CategoryTheory.CategoryStruct.id R) ≅ CategoryTheory.Functor.id (SheafOfModules R) | The pushforward functor by the identity morphism identifies to
the identify functor of the category of sheaves of modules. | true |
RingCon.quotientKerEquivOfRightInverse._proof_2 | Mathlib.RingTheory.Congruence.Hom | ∀ {M : Type u_1} {P : Type u_2} [inst : NonAssocSemiring M] [inst_1 : NonAssocSemiring P] (f : M →+* P) (g : P → M)
(hf : Function.RightInverse g ⇑f),
Function.RightInverse (Setoid.quotientKerEquivOfRightInverse (⇑f) g hf).invFun
(Setoid.quotientKerEquivOfRightInverse (⇑f) g hf).toFun | null | false |
List.find?_not_eq_head_dropWhile._proof_1 | Mathlib.Data.List.TakeWhile | ∀ {α : Type u_1} {p : α → Bool} {l : List α}, (∃ x ∈ l, ¬p x = true) → List.dropWhile p l ≠ [] | null | false |
_private.Init.Grind.Ring.CommSemiringAdapter.0.Lean.Grind.CommRing.Expr.toPolyS.match_4.splitter | Init.Grind.Ring.CommSemiringAdapter | (motive : Lean.Grind.CommRing.Expr → Sort u_1) →
(x : Lean.Grind.CommRing.Expr) →
((n : ℤ) → motive (Lean.Grind.CommRing.Expr.num n)) →
((x : Lean.Grind.CommRing.Var) → motive (Lean.Grind.CommRing.Expr.var x)) →
((a b : Lean.Grind.CommRing.Expr) → motive (a.add b)) →
((a b : Lean.Grind.Com... | null | true |
CategoryTheory.Adjunction.Quadruple.mk.noConfusion | Mathlib.CategoryTheory.Adjunction.Quadruple | {C : Type u₁} →
{D : Type u₂} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} D} →
{L : CategoryTheory.Functor C D} →
{F : CategoryTheory.Functor D C} →
{G : CategoryTheory.Functor C D} →
{R : CategoryTheory.Functor D C} ... | null | false |
SSet.ιNormalizedChainComplex_d_assoc | Mathlib.AlgebraicTopology.SimplicialSet.Homology.Nondegenerate | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasCoproducts C]
[inst_2 : CategoryTheory.Preadditive C] (X : SSet) {R : C} {n : ℕ} (x : X.obj (Opposite.op { len := n + 1 })) {Z : C}
(h : (X.normalizedChainComplex R).X n ⟶ Z),
CategoryTheory.CategoryStruct.comp (X.ιNormali... | null | true |
LinearEquiv.coe_toAddEquiv_symm | Mathlib.Algebra.Module.Equiv.Defs | ∀ {R₁ : Type u_2} {R₂ : Type u_3} {M₁ : Type u_8} {M₂ : Type u_9} [inst : Semiring R₁] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M₁] [inst_3 : AddCommMonoid M₂] {module_M₁ : Module R₁ M₁} {module_M₂ : Module R₂ M₂}
{σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁} {re₁₂ : RingHomInvPair σ₁₂ σ₂₁} {re₂₁ : RingHomInvPair σ₂₁ σ... | null | true |
MeasureTheory.integral_prod | Mathlib.MeasureTheory.Integral.Prod | ∀ {α : Type u_1} {β : Type u_2} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
{μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} [inst_2 : NormedAddCommGroup E] [MeasureTheory.SFinite ν]
[inst_4 : NormedSpace ℝ E] [MeasureTheory.SFinite μ] (f : α × β → E),
MeasureTheory.Integrabl... | **Fubini's Theorem**: For integrable functions on `α × β`,
the Bochner integral of `f` is equal to the iterated Bochner integral.
`integrable_prod_iff` can be useful to show that the function in question in integrable.
`MeasureTheory.Integrable.integral_prod_right` is useful to show that the inner integral
of the right... | true |
AlgEquiv.ofRingEquiv._proof_3 | Mathlib.Algebra.Algebra.Equiv | ∀ {A₁ : Type u_2} {A₂ : Type u_1} [inst : Semiring A₁] [inst_1 : Semiring A₂] {f : A₁ ≃+* A₂} (x y : A₁),
f.toFun (x * y) = f.toFun x * f.toFun y | null | false |
CategoryTheory.IsoCat.mk.injEq | Mathlib.CategoryTheory.IsoCat | ∀ {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] (functor : CategoryTheory.Functor C D)
(inverse : CategoryTheory.Functor D C) (unit_eq : CategoryTheory.Functor.id C = functor.comp inverse)
(counit_eq : inverse.comp functor = CategoryThe... | null | true |
«term_≃ₗ[_]_» | Mathlib.Algebra.Module.Equiv.Defs | Lean.TrailingParserDescr | `M ≃ₗ[R] M₂` denotes the type of linear equivalences between `M` and `M₂` over
a plain linear map `M →ₗ M₂`. | true |
SSet.Truncated.sk._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.Basic | ∀ (n : ℕ) (F : CategoryTheory.Functor (SimplexCategory.Truncated n)ᵒᵖ (Type u_1)),
(SimplexCategory.Truncated.inclusion n).op.HasLeftKanExtension F | null | false |
QuadraticMap.Isometry | Mathlib.LinearAlgebra.QuadraticForm.Isometry | {R : Type u_1} →
{M₁ : Type u_3} →
{M₂ : Type u_4} →
{N : Type u_7} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M₁] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : AddCommMonoid N] →
[inst_4 : Module R M₁] →
[inst_5 : Module R M... | An isometry between two quadratic spaces `M₁, Q₁` and `M₂, Q₂` over a ring `R`,
is a linear map between `M₁` and `M₂` that commutes with the quadratic forms. | true |
Int.toArray_roc_eq_singleton_append_iff._simp_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {xs : Array ℤ} {m n a : ℤ}, ((m<...=n).toArray = #[a] ++ xs) = (m + 1 = a ∧ m < n ∧ (m + 1<...=n).toArray = xs) | null | false |
CategoryTheory.WithTerminal.of.noConfusion | Mathlib.CategoryTheory.WithTerminal.Basic | {C : Type u} →
{P : Sort u_1} → {a a' : C} → CategoryTheory.WithTerminal.of a = CategoryTheory.WithTerminal.of a' → (a ≍ a' → P) → P | null | false |
Std.Iter.toList_zip_of_finite | Std.Data.Iterators.Lemmas.Combinators.Zip | ∀ {α₁ α₂ β₁ β₂ : Type u_1} [inst : Std.Iterator α₁ Id β₁] [inst_1 : Std.Iterator α₂ Id β₂] {it₁ : Std.Iter β₁}
{it₂ : Std.Iter β₂} [Std.Iterators.Finite α₁ Id] [Std.Iterators.Finite α₂ Id],
(it₁.zip it₂).toList = it₁.toList.zip it₂.toList | null | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Assignment.0.Std.Tactic.BVDecide.LRAT.Internal.Assignment.ofClause_spec.match_1.eq_2 | Std.Tactic.BVDecide.LRAT.Internal.Assignment | ∀ (motive : Option Std.Tactic.BVDecide.LRAT.Internal.Assignment → Sort u_1)
(assignment : Std.Tactic.BVDecide.LRAT.Internal.Assignment) (h_1 : Unit → motive none)
(h_2 : (assignment : Std.Tactic.BVDecide.LRAT.Internal.Assignment) → motive (some assignment)),
(match some assignment with
| none => h_1 ()
| ... | null | true |
HasStrictFDerivAt.mem_toOpenPartialHomeomorph_source | Mathlib.Analysis.Calculus.InverseFunctionTheorem.FDeriv | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{f' : E ≃L[𝕜] F} {a : E} [inst_5 : CompleteSpace E] (hf : HasStrictFDerivAt f (↑f') a),
a ∈ (HasS... | null | true |
FormalMultilinearSeries.rightInv._proof_20 | Mathlib.Analysis.Analytic.Inverse | ∀ {E : Type u_1} [inst : NormedAddCommGroup E], ContinuousAdd E | null | false |
ModularFormClass.modularForm._proof_1 | Mathlib.NumberTheory.ModularForms.Basic | ∀ {F : Type u_1} {Γ : Subgroup (GL (Fin 2) ℝ)} {k : ℤ} [inst : FunLike F UpperHalfPlane ℂ] [ModularFormClass F Γ k]
(f : F), ∀ γ ∈ Γ, SlashAction.map k γ ⇑f = ⇑f | null | false |
CategoryTheory.Localization.SmallHom.mkInv.congr_simp | Mathlib.CategoryTheory.Localization.SmallHom | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {W : CategoryTheory.MorphismProperty C} {X Y : C}
(f f_1 : Y ⟶ X) (e_f : f = f_1) (hf : W f) [inst_1 : CategoryTheory.Localization.HasSmallLocalizedHom W X Y],
CategoryTheory.Localization.SmallHom.mkInv f hf = CategoryTheory.Localization.SmallHom.mkInv f_1... | null | true |
Finsupp.instCoalgebra._proof_2 | Mathlib.RingTheory.Coalgebra.Basic | ∀ (R : Type u_1) (ι : Type u_2) (A : Type u_3) [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : Coalgebra R A],
LinearMap.rTensor (ι →₀ A) CoalgebraStruct.counit ∘ₗ CoalgebraStruct.comul = (TensorProduct.mk R R (ι →₀ A)) 1 | null | false |
PrimeSpectrum.exists_comap_evalRingHom_eq | Mathlib.RingTheory.Spectrum.Prime.RingHom | ∀ {ι : Type u_3} {R : ι → Type u_4} [inst : (i : ι) → CommRing (R i)] [Finite ι] (p : PrimeSpectrum ((i : ι) → R i)),
∃ i q, PrimeSpectrum.comap (Pi.evalRingHom R i) q = p | null | true |
SimpleGraph.triangle_removal | Mathlib.Combinatorics.SimpleGraph.Triangle.Removal | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {G : SimpleGraph α} [inst_2 : DecidableRel G.Adj] {ε : ℝ},
↑(G.cliqueFinset 3).card < SimpleGraph.triangleRemovalBound ε * ↑(Fintype.card α) ^ 3 →
∃ G' ≤ G, ∃ x, ↑G.edgeFinset.card - ↑G'.edgeFinset.card < ε * ↑(Fintype.card α ^ 2) ∧ G'.CliqueFree 3 | **Triangle Removal Lemma**. If there are not too many triangles (on the order of `(card α)^3`)
then they can all be removed by removing a few edges (on the order of `(card α)^2`). | true |
Metric.isBounded_range_of_cauchy_map_cofinite | Mathlib.Topology.MetricSpace.Bounded | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] {f : β → α},
Cauchy (Filter.map f Filter.cofinite) → Bornology.IsBounded (Set.range f) | null | true |
_private.Init.Data.List.ToArray.0.List.replace_toArray._proof_1_10 | Init.Data.List.ToArray | ∀ {α : Type u_1} [BEq α] (l : List α) (a b : α) (i : Fin l.toArray.size) (j : ℕ), ¬j = ↑i → ↑i = j → False | null | false |
_private.Mathlib.CategoryTheory.Abelian.DiagramLemmas.Four.0.CategoryTheory.Abelian.isIso_of_isIso_of_mono._proof_1_1 | Mathlib.CategoryTheory.Abelian.DiagramLemmas.Four | ¬0 + 2 ≤ 2 → False | null | false |
Std.ExtDHashMap.ofList | Std.Data.ExtDHashMap.Basic | {α : Type u} → {β : α → Type v} → [inst : BEq α] → [inst_1 : Hashable α] → List ((a : α) × β a) → Std.ExtDHashMap α β | Creates a hash map from a list of mappings. If the same key appears multiple times, the last
occurrence takes precedence. | true |
_private.Lean.Environment.0.Lean.AsyncConsts.findRecAndParent? | Lean.Environment | Lean.AsyncConsts✝ → Lean.Name → Option (Lean.AsyncConst✝ × Option Lean.AsyncConst✝) | Like `findRec?` but also returns the constant that has `declName` in its `consts`, if any. | true |
Nat.cast_lt_ofNat | Mathlib.Data.Nat.Cast.Order.Basic | ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α] [AddLeftMono α] [ZeroLEOneClass α] [CharZero α]
{m n : ℕ} [inst_5 : n.AtLeastTwo], ↑m < OfNat.ofNat n ↔ m < OfNat.ofNat n | null | true |
Finset.infs_eq_empty._simp_1 | Mathlib.Data.Finset.Sups | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : SemilatticeInf α] {s t : Finset α}, (s ⊼ t = ∅) = (s = ∅ ∨ t = ∅) | null | false |
Filter.comk._proof_2 | Mathlib.Order.Filter.Defs | ∀ {α : Type u_1} (p : Set α → Prop),
(∀ (s : Set α), p s → ∀ (t : Set α), p t → p (s ∪ t)) →
∀ {x y : Set α}, x ∈ {t | p tᶜ} → y ∈ {t | p tᶜ} → x ∩ y ∈ {t | p tᶜ} | null | false |
List.toFinsupp._proof_4 | Mathlib.Data.List.ToFinsupp | ∀ {M : Type u_1} [inst : Zero M] (l : List M) [inst_1 : DecidablePred fun x => l.getD x 0 ≠ 0] (n : ℕ),
n ∈ {i ∈ Finset.range l.length | l.getD i 0 ≠ 0} ↔ l.getD n 0 ≠ 0 | null | false |
_private.Mathlib.Algebra.BigOperators.Fin.0.List.prod_take_ofFn._proof_1_2 | Mathlib.Algebra.BigOperators.Fin | ∀ {M : Type u_1} {n : ℕ} (f : Fin n → M), ∀ i < (List.ofFn f).length, i < n | null | false |
maximal_and_iff_right_of_imp | Mathlib.Order.Minimal | ∀ {α : Type u_2} {P Q : α → Prop} {x : α} [inst : LE α],
(∀ ⦃x : α⦄, P x → Q x) → (Maximal (fun x => P x ∧ Q x) x ↔ Maximal P x ∧ Q x) | null | true |
MeasureTheory.instIsMeasurablyGeneratedAeMeasure | Mathlib.MeasureTheory.Measure.Filter | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α}, (MeasureTheory.ae μ).IsMeasurablyGenerated | null | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.getEntry?.match_1 | Std.Data.Internal.List.Associative | {α : Type u_2} →
{β : α → Type u_1} →
(motive : List ((a : α) × β a) → Sort u_3) →
(x : List ((a : α) × β a)) →
(Unit → motive []) → ((k : α) → (v : β k) → (l : List ((a : α) × β a)) → motive (⟨k, v⟩ :: l)) → motive x | null | false |
_private.Std.Sat.CNF.RelabelFin.0.Std.Sat.CNF.Clause.of_maxLiteral_eq_none._simp_1_2 | Std.Sat.CNF.RelabelFin | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l : List α}, (List.map f l = []) = (l = []) | null | false |
Lean.Grind.OrderConfig.ringSteps._inherited_default | Init.Grind.Config | ℕ | null | false |
Std.Do.WPMonad | Std.Do.WP.Monad | (m : Type u → Type v) → outParam Std.Do.PostShape → [Monad m] → Type (max (u + 1) v) | A monad with weakest preconditions (`WP`) that is also a monad morphism, preserving `pure` and
`bind`.
In practice, `mvcgen` is not useful for reasoning about programs in a monad that is without a
`WPMonad` instance. The specification lemmas for `Pure.pure` and `Bind.bind`, as well as those for
operators like `Functor... | true |
AffineIsometryEquiv.instGroup._proof_2 | Mathlib.Analysis.Normed.Affine.Isometry | ∀ {𝕜 : Type u_1} {V : Type u_2} {P : Type u_3} [inst : NormedField 𝕜] [inst_1 : SeminormedAddCommGroup V]
[inst_2 : NormedSpace 𝕜 V] [inst_3 : PseudoMetricSpace P] [inst_4 : NormedAddTorsor V P] (n : ℕ) (x : P ≃ᵃⁱ[𝕜] P),
x ^ (n + 1) = x ^ n * x | null | false |
DirectSum.bracket_apply | Mathlib.Algebra.Lie.DirectSum | ∀ {ι : Type v} (L : ι → Type w) [inst : (i : ι) → LieRing (L i)] (x y : DirectSum ι fun i => L i) (i : ι),
⁅x, y⁆ i = ⁅x i, y i⁆ | null | true |
_private.Mathlib.Topology.MetricSpace.GromovHausdorffRealized.0.GromovHausdorff.Cb | Mathlib.Topology.MetricSpace.GromovHausdorffRealized | (X : Type u) → (Y : Type v) → [MetricSpace X] → [MetricSpace Y] → Type (max v u) | null | true |
OrderIso.lt_iff_lt | Mathlib.Order.Hom.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] (e : α ≃o β) {x y : α}, e x < e y ↔ x < y | null | true |
_private.Std.Data.ExtDHashMap.Lemmas.0.Std.ExtDHashMap.Const.insertMany_list_eq_empty_iff._simp_1_2 | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u_1} {l : List α}, (l = []) = (l.isEmpty = true) | null | false |
Sym.equivNatSum | Mathlib.Data.Finsupp.Multiset | (α : Type u_1) → [DecidableEq α] → (n : ℕ) → Sym α n ≃ { P // (P.sum fun x => id) = n } | The `n`th symmetric power of a type `α` is naturally equivalent to the subtype of
finitely-supported maps `α →₀ ℕ` with total mass `n`.
See also `Sym.equivNatSumOfFintype` when `α` is finite. | true |
_private.Mathlib.Data.Set.Insert.0.Set.insert_subset_insert_iff._proof_1_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s t : Set α} {a : α}, a ∉ s → (insert a s ⊆ insert a t ↔ s ⊆ t) | null | false |
CategoryTheory.ComposableArrows.homMk₁._proof_4 | Mathlib.CategoryTheory.ComposableArrows.Basic | 0 ≤ 1 | null | false |
HahnSeries.instAddMonoid._proof_1 | Mathlib.RingTheory.HahnSeries.Addition | ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : AddMonoid R] (a b c : HahnSeries Γ R),
a + b + c = a + (b + c) | null | false |
Mathlib.Meta.Simproc.FactorsHelper.nil | Mathlib.Tactic.Simproc.Factors | ∀ {a : ℕ}, Mathlib.Meta.Simproc.FactorsHelper 1 a [] | null | true |
IsClosed.sdiff | Mathlib.Topology.Basic | ∀ {X : Type u} {s t : Set X} [inst : TopologicalSpace X], IsClosed s → IsOpen t → IsClosed (s \ t) | null | true |
_private.Mathlib.NumberTheory.ArithmeticFunction.LFunction.0.ArithmeticFunction.ofPowerSeries.match_3 | Mathlib.NumberTheory.ArithmeticFunction.LFunction | ∀ (motive : ℕ × ℕ → Prop) (h : ℕ × ℕ), (∀ (a b : ℕ), motive (a, b)) → motive h | null | false |
NumberField.InfinitePlace.Completion.instAlgebra._proof_7 | Mathlib.NumberTheory.NumberField.Completion.InfinitePlace | ∀ {K : Type u_1} [inst : Field K] (v : NumberField.InfinitePlace K) (R : Type u_2) [inst_1 : CommSemiring R]
[inst_2 : Algebra R (WithAbs ↑v)] [inst_3 : UniformContinuousConstSMul R (WithAbs ↑v)] (x y : R),
(↑↑((RingEquiv.symm (NumberField.InfinitePlace.Completion.equivCompletion v).ringEquiv).toRingHom.comp
... | null | false |
IsCadlag.tendsto_nhdsLT_leftLim | Mathlib.Topology.Order.Cadlag | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] {f : X → Y} [inst_1 : LinearOrder X]
[inst_2 : TopologicalSpace Y] [OrderTopology X],
IsCadlag f → ∀ (x : X), Filter.Tendsto f (nhdsWithin x (Set.Iio x)) (nhds (Function.leftLim f x)) | null | true |
Std.Tactic.BVDecide.Frontend.Normalize.BitVec.not_bif_eq_bif' | Std.Tactic.BVDecide.Normalize.Equal | ∀ {w : ℕ} (d : Bool) (a b c : BitVec w),
((~~~bif d then a else c) == bif d then b else c) = bif d then ~~~a == b else ~~~c == c | null | true |
HomologicalComplex.homologyFunctorIso_inv_app | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} (c : ComplexShape ι) (i : ι) [inst_2 : CategoryTheory.CategoryWithHomology C]
(X : HomologicalComplex C c),
(HomologicalComplex.homologyFunctorIso C c i).inv.app X = CategoryTheory.Cat... | null | true |
MulAut.characteristic.eq_1 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) [inst_1 : H.Characteristic],
MulAut.characteristic H =
{
toFun := fun φ =>
{ toFun := fun h => ⟨φ ↑h, ⋯⟩, invFun := fun h => ⟨(MulEquiv.symm φ) ↑h, ⋯⟩, left_inv := ⋯, right_inv := ⋯,
map_mul' := ⋯ },
map_one' := ⋯, map_mul' := ⋯ } | null | true |
Lean.Lsp.InlayHintClientCapabilities.noConfusionType | Lean.Data.Lsp.LanguageFeatures | Sort u → Lean.Lsp.InlayHintClientCapabilities → Lean.Lsp.InlayHintClientCapabilities → Sort u | null | false |
instDecidableAnd._proof_1 | Init.Prelude | ∀ {p q : Prop} [dp : Decidable p] [dq : Decidable q], (decide p && decide q).Reflects (p ∧ q) | null | false |
ContinuousAlternatingMap.analyticWithinAt_compContinuousLinearMapCLM | Mathlib.Analysis.Analytic.CPolynomial | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {ι : Type u_5} [inst_7 : Fintype ι] [... | null | true |
Lean.Lsp.FileSource.noConfusion | Lean.Server.FileSource | {P : Sort u} →
{α : Type} →
{t : Lean.Lsp.FileSource α} →
{α' : Type} → {t' : Lean.Lsp.FileSource α'} → α = α' → t ≍ t' → Lean.Lsp.FileSource.noConfusionType P t t' | null | false |
Lean.Meta.Grind.Arith.CommRing.State.semirings | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Lean.Meta.Grind.Arith.CommRing.State → Array Lean.Meta.Grind.Arith.CommRing.CommSemiring | Commutative semirings. We support them using the envelope `OfCommRing.Q` | true |
ContinuousAffineMap.coe_continuousMap_mk._simp_1 | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ {R : Type u_1} {V : Type u_2} {W : Type u_3} {P : Type u_4} {Q : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace Q] [inst_8 : AddTorsor W Q] (f : P →ᵃ[R] Q) (... | null | false |
MeasureTheory.setToFun_smul_left | Mathlib.MeasureTheory.Integral.SetToL1.Function | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{T : Set α → E →L[ℝ] F} {C : ℝ} (hT : MeasureTheory.DominatedFinMeasAdditive μ T C) (c : ℝ) (f : α ... | null | true |
upperClosure_add | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : Preorder α] [IsOrderedAddMonoid α] (s t : Set α),
↑(upperClosure s) + t = ↑(upperClosure (s + t)) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.