name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Classifier.hom_comp_hom | Mathlib.CategoryTheory.Subobject.Classifier.Defs | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (𝒞₁ 𝒞₂ 𝒞₃ : CategoryTheory.Subobject.Classifier C),
CategoryTheory.CategoryStruct.comp (𝒞₁.hom 𝒞₂) (𝒞₂.hom 𝒞₃) = 𝒞₁.hom 𝒞₃ | **Alias** of `CategoryTheory.Subobject.Classifier.hom_comp_hom`. | true |
AbsoluteValue.LiesOver.casesOn | Mathlib.Analysis.Normed.Ring.WithAbs | {K : Type u_3} →
{L : Type u_4} →
{S : Type u_5} →
[inst : CommRing K] →
[inst_1 : IsSimpleRing K] →
[inst_2 : CommRing L] →
[inst_3 : Algebra K L] →
[inst_4 : PartialOrder S] →
[inst_5 : Nontrivial L] →
[inst_6 : Semiring S] →
... | null | false |
ApplicativeTransformation.mk.sizeOf_spec | Mathlib.Control.Traversable.Basic | ∀ {F : Type u → Type v} [inst : Applicative F] {G : Type u → Type w} [inst_1 : Applicative G]
[inst_2 : (a : Type u) → SizeOf (F a)] [inst_3 : (a : Type u) → SizeOf (G a)] (app : (α : Type u) → F α → G α)
(preserves_pure' : ∀ {α : Type u} (x : α), app α (pure x) = pure x)
(preserves_seq' : ∀ {α β : Type u} (x : F... | null | true |
DirectLimit.instDivisionSemiring._proof_15 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (... | null | false |
toLexMulEquiv.eq_1 | Mathlib.Algebra.Order.Group.Equiv | ∀ (α : Type u_1) [inst : Mul α], toLexMulEquiv α = { toEquiv := toLex, map_mul' := ⋯ } | null | true |
ContDiffAt.snd' | Mathlib.Analysis.Calculus.ContDiff.Comp | ∀ {𝕜 : 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] {n : WithTop ℕ∞} {f : F → G} {x : E} ... | Precomposing `f` with `Prod.snd` is `C^n` at `(x, y)` | true |
differentiableAt_const._simp_1 | Mathlib.Analysis.Calculus.FDeriv.Const | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {x : E} (c : F), DifferentiableAt 𝕜 (fun x => c) x = True | null | false |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.updateCell._proof_19 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {β : α → Type u_2} (k' : α) (v' : β k'),
Std.DTreeMap.Internal.Impl.leaf.size - 1 ≤
(Std.DTreeMap.Internal.Impl.inner 1 k' v' Std.DTreeMap.Internal.Impl.leaf Std.DTreeMap.Internal.Impl.leaf).size | null | false |
IsSelfAdjoint.toReal_spectralRadius_eq_norm | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | ∀ {A : Type u_1} [inst : CStarAlgebra A] {a : A}, IsSelfAdjoint a → (spectralRadius ℝ a).toReal = ‖a‖ | null | true |
AlgebraicGeometry.Scheme.JointlySurjective.recOn | Mathlib.AlgebraicGeometry.Cover.MorphismProperty | {K : CategoryTheory.Precoverage AlgebraicGeometry.Scheme} →
{motive : AlgebraicGeometry.Scheme.JointlySurjective K → Sort u_1} →
(t : AlgebraicGeometry.Scheme.JointlySurjective K) →
((exists_eq : ∀ {X : AlgebraicGeometry.Scheme}, ∀ S ∈ K.coverings X, ∀ (x : ↥X), ∃ Y g, S g ∧ x ∈ Set.range ⇑g) →
mo... | null | false |
contMDiffWithinAt_iff_of_mem_source' | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : 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] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | true |
AddSemigrp.hom_comp | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {X Y T : AddSemigrp} (f : X ⟶ Y) (g : Y ⟶ T),
AddSemigrp.Hom.hom (CategoryTheory.CategoryStruct.comp f g) = (AddSemigrp.Hom.hom g).comp (AddSemigrp.Hom.hom f) | null | true |
UInt8.reduceBinPred._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.781669616._hygCtx._hyg.3 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | Lean.Name → ℕ → (UInt8 → UInt8 → Bool) → Lean.Expr → Lean.Meta.SimpM Lean.Meta.Simp.Step | null | false |
_private.Mathlib.Topology.Algebra.InfiniteSum.ConditionalInt.0.SummationFilter.symmetricIcc_eq_symmetricIoo_int._proof_1_13 | Mathlib.Topology.Algebra.InfiniteSum.ConditionalInt | ∀ (b : ℕ) (a_1 : ℤ), -↑b ≤ a_1 ∧ a_1 ≤ ↑b ↔ -1 < a_1 + ↑b ∧ a_1 < ↑b + 1 | null | false |
CategoryTheory.MorphismProperty.instIsStableUnderTransfiniteCompositionOfShapeFunctorFunctorCategoryOfHasIterationOfShape | Mathlib.CategoryTheory.MorphismProperty.FunctorCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C} (K : Type u')
[inst_1 : LinearOrder K] [inst_2 : SuccOrder K] [inst_3 : OrderBot K] [inst_4 : WellFoundedLT K]
[W.IsStableUnderTransfiniteCompositionOfShape K] (J : Type u'') [inst_6 : CategoryTheory.Category.{v'', u''}... | null | true |
_private.Mathlib.RingTheory.DedekindDomain.AdicValuation.0.IsDedekindDomain.HeightOneSpectrum.exists_intValuation_mul_sub_lt._simp_1_1 | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x : M}
{p p' : Submodule R M}, (x ∈ p ⊔ p') = ∃ y ∈ p, ∃ z ∈ p', y + z = x | null | false |
Matrix.IsDiag.submatrix | Mathlib.LinearAlgebra.Matrix.IsDiag | ∀ {α : Type u_1} {n : Type u_4} {m : Type u_5} [inst : Zero α] {A : Matrix n n α},
A.IsDiag → ∀ {f : m → n}, Function.Injective f → (A.submatrix f f).IsDiag | null | true |
_private.Mathlib.RingTheory.MvPowerSeries.LexOrder.0.MvPowerSeries.exists_finsupp_eq_lexOrder_of_ne_zero._simp_1_2 | Mathlib.RingTheory.MvPowerSeries.LexOrder | ∀ {α : Type u_1} {x : WithTop α}, (x ≠ ⊤) = ∃ a, ↑a = x | null | false |
RingHom.mk'._proof_4 | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_2} {β : Type u_1} [inst : NonAssocSemiring α] [inst_1 : NonAssocRing β] (f : α →* β)
(map_add : ∀ (a b : α), f (a + b) = f a + f b) (x y : α),
(↑(AddMonoidHom.mk' (⇑f) map_add)).toFun (x + y) =
(↑(AddMonoidHom.mk' (⇑f) map_add)).toFun x + (↑(AddMonoidHom.mk' (⇑f) map_add)).toFun y | null | false |
_private.Mathlib.Data.List.Basic.0.List.mem_getLast?_eq_getLast._proof_1_14 | Mathlib.Data.List.Basic | ∀ {α : Type u_1} (a b : α) (l : List α), ¬(a :: b :: l).length - 1 = 0 → (a :: b :: l).length - 2 < (b :: l).length | null | false |
PMF.toMeasure_inj._simp_1 | Mathlib.Probability.ProbabilityMassFunction.Basic | ∀ {α : Type u_1} [inst : MeasurableSpace α] [MeasurableSingletonClass α] {p q : PMF α},
(p.toMeasure = q.toMeasure) = (p = q) | null | false |
Ring.KrullDimLE.subsingleton_primeSpectrum | Mathlib.RingTheory.KrullDimension.Zero | ∀ (R : Type u_1) [inst : CommSemiring R] [Ring.KrullDimLE 0 R] [IsLocalRing R], Subsingleton (PrimeSpectrum R) | null | true |
id_tensor_π_preserves_coequalizer_inv_colimMap_desc | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Limits.HasCoequalizers C]
[inst_3 :
∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁}
(CategoryTheory.MonoidalCategory.tensorLeft X)]
{X... | null | true |
ProbabilityTheory.Kernel.rnDeriv_pos | Mathlib.Probability.Kernel.RadonNikodym | ∀ {α : Type u_1} {γ : Type u_2} {mα : MeasurableSpace α} {mγ : MeasurableSpace γ} {κ η : ProbabilityTheory.Kernel α γ}
[hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ] [ProbabilityTheory.IsFiniteKernel κ]
[ProbabilityTheory.IsFiniteKernel η] {a : α}, (κ a).AbsolutelyContinuous (η a) → ∀ᵐ (x : γ) ∂κ a, 0 < ... | null | true |
EReal.top_ne_coe._simp_1 | Mathlib.Data.EReal.Basic | ∀ (x : ℝ), (⊤ = ↑x) = False | null | false |
ProbabilityTheory.gaussianPDF | Mathlib.Probability.Distributions.Gaussian.Real | ℝ → NNReal → ℝ → ENNReal | The pdf of a Gaussian distribution on ℝ with mean `μ` and variance `v`. | true |
Pi.nonUnitalNormedRing._proof_1 | Mathlib.Analysis.Normed.Ring.Lemmas | ∀ {ι : Type u_1} {R : ι → Type u_2} [inst : Fintype ι] [inst_1 : (i : ι) → NonUnitalNormedRing (R i)]
{x y : (i : ι) → R i}, dist x y = 0 → x = y | null | false |
Subgroup.commutator_eq_self | Mathlib.GroupTheory.IsPerfect | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G} [hH : Group.IsPerfect ↥H], ⁅H, H⁆ = H | null | true |
Subsemiring.coe_prod._simp_1 | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (s : Subsemiring R)
(t : Subsemiring S), ↑s ×ˢ ↑t = ↑(s.prod t) | null | false |
FirstOrder.Language.BoundedFormula.equal.elim | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} →
{α : Type u'} →
{motive : (a : ℕ) → L.BoundedFormula α a → Sort u_1} →
{a : ℕ} →
(t : L.BoundedFormula α a) →
t.ctorIdx = 1 →
({n : ℕ} → (t₁ t₂ : L.Term (α ⊕ Fin n)) → motive n (FirstOrder.Language.BoundedFormula.equal t₁ t₂)) →
motive ... | null | false |
instAddInt64 | Init.Data.SInt.Basic | Add Int64 | null | true |
QuadraticMap.zeroHomClass | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N], ZeroHomClass (QuadraticMap R M N) M N | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Search.0.Lean.Meta.Grind.Arith.Linear.findInt?.go | Lean.Meta.Tactic.Grind.Arith.Linear.Search | Array (ℚ × Lean.Meta.Grind.Arith.Linear.DiseqCnstr) → ℤ → ℤ → Option ℚ | null | true |
EMetric.diam_one | Mathlib.Topology.EMetricSpace.Diam | ∀ {X : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : One X], Metric.ediam 1 = 0 | **Alias** of `Metric.ediam_one`. | true |
ProbabilityTheory.integrable_rpow_abs_of_mem_interior_integrableExpSet | Mathlib.Probability.Moments.IntegrableExpMul | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω},
0 ∈ interior (ProbabilityTheory.integrableExpSet X μ) →
∀ {p : ℝ}, 0 ≤ p → MeasureTheory.Integrable (fun ω => |X ω| ^ p) μ | If 0 belongs to the interior of the interval `integrableExpSet X μ`,
then `|X| ^ n` is integrable for all nonnegative `p : ℝ`. | true |
_private.Std.Data.String.ToNat.0.not_noRepetition_append_singleton_of_suffix | Std.Data.String.ToNat | ∀ {α : Type u} {a : α} {l : List α}, [a] <:+ l → ¬NoRepetition✝ a (l ++ [a]) | null | true |
Std.DTreeMap.Internal.Impl.balanceL!_pair_congr | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} {k : α} {v : β k} {k' : α} {v' : β k'},
⟨k, v⟩ = ⟨k', v'⟩ →
∀ {l l' r r' : Std.DTreeMap.Internal.Impl α β},
l = l' → r = r' → Std.DTreeMap.Internal.Impl.balanceL! k v l r = Std.DTreeMap.Internal.Impl.balanceL! k' v' l' r' | null | true |
_private.Lean.Meta.Match.Match.0.Lean.Meta.Match.solveSomeLocalFVarIdCnstr?.go._unsafe_rec | Lean.Meta.Match.Match | Lean.Meta.Match.Alt →
List (Lean.Expr × Lean.Expr) → Lean.MetaM (Option (Lean.FVarId × Lean.Expr) × List (Lean.Expr × Lean.Expr)) | null | false |
CategoryTheory.mop_whiskerLeft | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C)
{Y Z : C} (f : Y ⟶ Z),
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f).mop =
CategoryTheory.MonoidalCategoryStruct.whiskerRight f.mop { unmop := X } | null | true |
Std.Internal.UV.Signal.cancel | Std.Internal.UV.Signal | Std.Internal.UV.Signal → IO Unit | This function has different behavior depending on the state of the `Signal`:
- If it is initial or finished this is a no-op.
- If it's running then it drops the accept promise and if it's not repeatable it sets
the signal handler to the initial state.
| true |
UInt16.toUInt32_ofNatClamp_of_lt | Init.Data.UInt.Lemmas | ∀ {n : ℕ} (hn : n < UInt16.size), (UInt16.ofNatClamp n).toUInt32 = UInt32.ofNatLT n ⋯ | null | true |
MvPolynomial.pderiv._proof_1 | Mathlib.Algebra.MvPolynomial.PDeriv | ∀ {R : Type u_1} {σ : Type u_2} [inst : CommSemiring R], IsScalarTower R (MvPolynomial σ R) (MvPolynomial σ R) | null | false |
Module.mapEvalEquiv | Mathlib.LinearAlgebra.Dual.Defs | (R : Type u_3) →
(M : Type u_4) →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
[Module.IsReflexive R M] → Submodule R M ≃o Submodule R (Module.Dual R (Module.Dual R M)) | The isomorphism `Module.evalEquiv` induces an order isomorphism on subspaces. | true |
_private.Lean.Elab.Tactic.Basic.0.Lean.Elab.Tactic.evalTactic.match_9 | Lean.Elab.Tactic.Basic | (motive : Lean.Exception → Sort u_1) →
(ex : Lean.Exception) →
((ref : Lean.Syntax) → (msg : Lean.MessageData) → motive (Lean.Exception.error ref msg)) →
((id : Lean.InternalExceptionId) → (extra : Lean.KVMap) → motive (Lean.Exception.internal id extra)) → motive ex | null | false |
SimplexCategory.δ_comp_σ_of_le | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {n : ℕ} {i : Fin (n + 2)} {j : Fin (n + 1)},
i ≤ j.castSucc →
CategoryTheory.CategoryStruct.comp (SimplexCategory.δ i.castSucc) (SimplexCategory.σ j.succ) =
CategoryTheory.CategoryStruct.comp (SimplexCategory.σ j) (SimplexCategory.δ i) | The second simplicial identity | true |
_private.Mathlib.Algebra.Polynomial.UnitTrinomial.0.Polynomial.isUnitTrinomial_iff'._simp_1_1 | Mathlib.Algebra.Polynomial.UnitTrinomial | ∀ {α : Type u} [inst : Monoid α] (a : αˣ) (n : ℕ), ↑a ^ n = ↑(a ^ n) | null | false |
List.zipWith_eq_nil_iff | Init.Data.List.Zip | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β → γ} {l : List α} {l' : List β},
List.zipWith f l l' = [] ↔ l = [] ∨ l' = [] | null | true |
Polynomial.SplittingField.instCharZero | Mathlib.FieldTheory.SplittingField.Construction | ∀ {K : Type v} [inst : Field K] (f : Polynomial K) [CharZero K], CharZero f.SplittingField | null | true |
_private.Mathlib.Analysis.SpecialFunctions.ArithmeticGeometricMean.0.NNReal.bddAbove_range_agmSequences_fst._simp_1_3 | Mathlib.Analysis.SpecialFunctions.ArithmeticGeometricMean | ∀ {α : Sort u_2} {β : Sort u_1} {f : α → β} {p : β → Prop}, (∀ (b : β) (a : α), f a = b → p b) = ∀ (a : α), p (f a) | null | false |
FreeGroup.isReduced_iff_reduce_eq | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} {L : List (α × Bool)} [inst : DecidableEq α], FreeGroup.IsReduced L ↔ FreeGroup.reduce L = L | null | true |
instLTBitVec | Init.Prelude | {w : ℕ} → LT (BitVec w) | null | true |
CategoryTheory.Limits.widePushoutShapeOp | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | (J : Type w) →
CategoryTheory.Functor (CategoryTheory.Limits.WidePushoutShape J) (CategoryTheory.Limits.WidePullbackShape J)ᵒᵖ | The obvious functor `WidePushoutShape J ⥤ (WidePullbackShape J)ᵒᵖ` | true |
PMF.uniformOfFintype_apply | Mathlib.Probability.Distributions.Uniform | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : Nonempty α] (a : α), (PMF.uniformOfFintype α) a = (↑(Fintype.card α))⁻¹ | null | true |
ciSup_eq_ite | Mathlib.Order.ConditionallyCompletePartialOrder.Indexed | ∀ {α : Type u_1} [inst : ConditionallyCompletePartialOrderSup α] {p : Prop} [inst_1 : Decidable p] {f : p → α},
⨆ (h : p), f h = if h : p then f h else sSup ∅ | null | true |
_private.Mathlib.GroupTheory.Perm.Finite.0.Equiv.Perm.disjoint_support_closure_of_disjoint_support._simp_1_2 | Mathlib.GroupTheory.Perm.Finite | ∀ {α : Type u_1} {t : Set α} {ι : Sort u_12} {s : ι → Set α}, Disjoint t (⋃ i, s i) = ∀ (i : ι), Disjoint t (s i) | null | false |
Pi.mulSingle_le_mulSingle._gcongr_3 | Mathlib.Algebra.Order.Pi | ∀ {ι : Type u_6} {α : ι → Type u_7} [inst : DecidableEq ι] [inst_1 : (i : ι) → One (α i)]
[inst_2 : (i : ι) → Preorder (α i)] {i : ι} {a b : α i}, a ≤ b → Pi.mulSingle i a ≤ Pi.mulSingle i b | null | false |
CategoryTheory.MorphismProperty.IsStableUnderComonoid.recOn | Mathlib.CategoryTheory.CopyDiscardCategory.Widesubcategory | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{P : CategoryTheory.MorphismProperty C} →
{c : C} →
[inst_2 : CategoryTheory.ComonObj c] →
{motive : P.IsStableUnderComonoid c → Sort u} →
(t : P.IsStab... | null | false |
String.Slice.toList_split_prop | Init.Data.String.Lemmas.Pattern.Split.Pred | ∀ {s : String.Slice} {p : Char → Prop} [inst : DecidablePred p],
List.map String.Slice.copy (s.split p).toList =
List.map String.ofList (List.splitOnP (fun b => decide (p b)) s.copy.toList) | null | true |
PresheafOfModules.presheaf._proof_5 | Mathlib.Algebra.Category.ModuleCat.Presheaf | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
(M : PresheafOfModules R) (X : Cᵒᵖ),
AddCommGrpCat.ofHom
(AddMonoidHom.mk' ⇑(CategoryTheory.ConcreteCategory.hom (M.map (CategoryTheory.CategoryStruct.id X))) ⋯) =
CategoryTheory.CategoryStruct.id ((Cat... | null | false |
ISize.toInt_maxValue | Init.Data.SInt.Lemmas | ISize.maxValue.toInt = 2 ^ (System.Platform.numBits - 1) - 1 | null | true |
_private.Mathlib.Tactic.Find.0.Mathlib.Tactic.Find.matchHyps | Mathlib.Tactic.Find | List Lean.Expr → List Lean.Expr → List Lean.Expr → Lean.MetaM Bool | null | true |
CompletelyDistribLattice.MinimalAxioms.mk | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u} →
(toCompleteLattice : CompleteLattice α) →
(∀ {ι : Type u} {κ : ι → Type u} (f : (a : ι) → κ a → α), ⨅ a, ⨆ b, f a b = ⨆ g, ⨅ a, f a (g a)) →
CompletelyDistribLattice.MinimalAxioms α | null | true |
LaurentSeries.val_le_one_iff_eq_coe | Mathlib.RingTheory.LaurentSeries | ∀ (K : Type u_2) [inst : Field K] (f : LaurentSeries K), Valued.v f ≤ 1 ↔ ∃ F, (HahnSeries.ofPowerSeries ℤ K) F = f | Every Laurent series of valuation less than `(1 : ℤᵐ⁰)` comes from a power series. | true |
Lean.instForInMVarIdSetMVarIdOfMonad | Lean.Expr | {m : Type u_1 → Type u_2} → [Monad m] → ForIn m Lean.MVarIdSet Lean.MVarId | null | true |
_private.Mathlib.Order.Sublocale.0.Sublocale.giAux._proof_3 | Mathlib.Order.Sublocale | ∀ {X : Type u_1} [inst : Order.Frame X] (S : Sublocale X) (x : ↥S), x ≤ Sublocale.restrictAux✝ S ↑x | null | false |
Lean.Lsp.DiagnosticCode | Lean.Data.Lsp.Diagnostics | Type | Some languages have specific codes for each error type. | true |
Ordnode.eraseMin._unsafe_rec | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → Ordnode α → Ordnode α | null | false |
UpperSet.coe_nonempty | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α] {s : UpperSet α}, (↑s).Nonempty ↔ s ≠ ⊤ | null | true |
_private.Mathlib.RingTheory.Lasker.0.Submodule.IsMinimalPrimaryDecomposition.comap_localized₀_eq_ite._simp_1_9 | Mathlib.RingTheory.Lasker | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ | null | false |
_private.Lean.Meta.Tactic.Cbv.Util.0.Lean.Meta.Tactic.Cbv.isBitVecValue | Lean.Meta.Tactic.Cbv.Util | Lean.Expr → Bool | null | true |
CategoryTheory.Functor.map_braiding_assoc | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u₂} [inst_3 : CategoryTheory.Category.{v₂, u₂} D]
[inst_4 : CategoryTheory.MonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D]
(F : CategoryThe... | null | true |
ContinuousMap.instRegularSpace | Mathlib.Topology.CompactOpen | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [RegularSpace Y],
RegularSpace C(X, Y) | null | true |
Mathlib.Tactic.ClickSuggestions.SectionKind.hyp.elim | Mathlib.Tactic.ClickSuggestions.SectionState | {motive : Mathlib.Tactic.ClickSuggestions.SectionKind → Sort u} →
(t : Mathlib.Tactic.ClickSuggestions.SectionKind) →
t.ctorIdx = 0 → motive Mathlib.Tactic.ClickSuggestions.SectionKind.hyp → motive t | null | false |
Std.IterM.Partial.it | Init.Data.Iterators.Consumers.Monadic.Partial | {α : Type w} → {m : Type w → Type w'} → {β : Type w} → Std.IterM.Partial m β → Std.IterM m β | The wrapped iterator, which was wrapped by `IterM.allowNontermination`.
| true |
AlgebraicTopology.DoldKan.Γ₀.Obj.map._proof_1 | Mathlib.AlgebraicTopology.DoldKan.FunctorGamma | ∀ {Δ' Δ : SimplexCategoryᵒᵖ} (θ : Δ ⟶ Δ') (A : CategoryTheory.SimplicialObject.Splitting.IndexSet Δ),
CategoryTheory.Limits.HasImage (CategoryTheory.CategoryStruct.comp θ.unop A.e) | null | false |
Lean.Parser.anyOfFn._unsafe_rec | Lean.Parser.Basic | List Lean.Parser.Parser → Lean.Parser.ParserFn | null | false |
Subring.range_snd | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocRing R] [inst_1 : NonAssocRing S], (RingHom.snd R S).rangeS = ⊤ | null | true |
Algebra.TensorProduct.tensorQuotientEquiv_symm_apply_tmul | Mathlib.RingTheory.TensorProduct.Quotient | ∀ {R : Type u_1} (S : Type u_2) (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] (I : Ideal T) (a : A) (t : T),
(Algebra.Ten... | null | true |
Lean.Level.PP.Context.recOn | Lean.Level | {motive : Lean.Level.PP.Context → Sort u} →
(t : Lean.Level.PP.Context) →
((mvars : Bool) → (lIndex? : Lean.LMVarId → Option ℕ) → motive { mvars := mvars, lIndex? := lIndex? }) → motive t | null | false |
Std.ExtTreeMap.union_insert_right_eq_insert_union | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
{p : (_ : α) × β}, t₁ ∪ t₂.insert p.fst p.snd = (t₁ ∪ t₂).insert p.fst p.snd | null | true |
String.Slice.Pattern.Model.IsValidSearchFrom.mismatched_of_eq | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice}
{startPos startPos' endPos : s.Pos} {l : List (String.Slice.Pattern.SearchStep s)},
String.Slice.Pattern.Model.IsValidSearchFrom pat endPos l →
startPos' < endPos →
(∀ (pos : s.Pos), startPos' ≤ pos → pos < endP... | null | true |
Std.ExtDHashMap.mem_modify | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α] {k k' : α}
{f : β k → β k}, k' ∈ m.modify k f ↔ k' ∈ m | null | true |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.getStackEntries.loop | Mathlib.Lean.Meta.RefinedDiscrTree.Encode | Array Lean.Expr →
List Lean.FVarId →
Lean.Expr →
ℕ → ℕ → List Lean.Meta.RefinedDiscrTree.StackEntry → Lean.MetaM (List Lean.Meta.RefinedDiscrTree.StackEntry) | The main loop of `getStackEntries` | true |
Std.DHashMap.Internal.Raw₀.Const.isEmpty_filter_eq_false_iff | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[EquivBEq α] [LawfulHashable α] {f : α → β → Bool},
(↑m).WF →
((↑(Std.DHashMap.Internal.Raw₀.filter f m)).isEmpty = false ↔
∃ k, ∃ (h : m.contains k = true), f (m.getKey k h) (Std.DHashMap.Intern... | null | true |
Dyadic.toRat_le_toRat_iff._simp_1 | Init.Data.Dyadic.Basic | ∀ {x y : Dyadic}, (x.toRat ≤ y.toRat) = (x ≤ y) | null | false |
CategoryTheory.MonoidalCategory.whiskerLeftIso_trans | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (W : C)
{X Y Z : C} (f : X ≅ Y) (g : Y ≅ Z),
CategoryTheory.MonoidalCategory.whiskerLeftIso W (f ≪≫ g) =
CategoryTheory.MonoidalCategory.whiskerLeftIso W f ≪≫ CategoryTheory.MonoidalCategory.whiskerLeftIso W g | null | true |
List.isEmpty_reverse | Init.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α}, xs.reverse.isEmpty = xs.isEmpty | null | true |
Std.TreeSet.Raw.insertMany_list_equiv_foldl | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ : Std.TreeSet.Raw α cmp} {l : List α},
(t₁.insertMany l).Equiv (List.foldl (fun acc a => acc.insert a) t₁ l) | null | true |
MeasureTheory.Measure.pi_noAtoms | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasurableSpace (α i)]
{μ : (i : ι) → MeasureTheory.Measure (α i)} [∀ (i : ι), MeasureTheory.SigmaFinite (μ i)] (i : ι)
[MeasureTheory.NoAtoms (μ i)], MeasureTheory.NoAtoms (MeasureTheory.Measure.pi μ) | If one of the measures `μ i` has no atoms, them `Measure.pi µ`
has no atoms. The instance below assumes that all `μ i` have no atoms. | true |
InnerProductSpace.bounded_harmonic_on_complex_plane_is_constant | Mathlib.Analysis.Complex.Harmonic.Liouville | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] (f : ℂ → E),
InnerProductSpace.HarmonicOnNhd f Set.univ → Bornology.IsBounded (Set.range f) → ∀ (z w : ℂ), f z = f w | **Liouville's theorem for harmonic functions on the complex plane** A bounded harmonic function on
the complex plane is constant.
| true |
CategoryTheory.ComposableArrows.homMkSucc | Mathlib.CategoryTheory.ComposableArrows.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{n : ℕ} →
{F G : CategoryTheory.ComposableArrows C (n + 1)} →
(α : F.obj' 0 ⋯ ⟶ G.obj' 0 ⋯) →
(β : F.δ₀ ⟶ G.δ₀) →
CategoryTheory.CategoryStruct.comp (F.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 ⋯)
... | Inductive construction of morphisms in `ComposableArrows C (n + 1)`: in order to construct
a morphism `F ⟶ G`, it suffices to provide `α : F.obj' 0 ⟶ G.obj' 0` and `β : F.δ₀ ⟶ G.δ₀`
such that `F.map' 0 1 ≫ app' β 0 = α ≫ G.map' 0 1`. | true |
_private.Mathlib.LinearAlgebra.Projection.0.LinearMap.IsIdempotentElem.commute_iff_of_isUnit._simp_1_4 | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {f : M ≃ₗ[R] M}
{p : Submodule R M}, (p ≤ Submodule.map (↑f) p) = (p ∈ Module.End.invtSubmodule ↑f.symm) | null | false |
CategoryTheory.Oplax.OplaxTrans.OplaxFunctor.bicategory | Mathlib.CategoryTheory.Bicategory.FunctorBicategory.Oplax | (B : Type u₁) →
[inst : CategoryTheory.Bicategory B] →
(C : Type u₂) → [inst_1 : CategoryTheory.Bicategory C] → CategoryTheory.Bicategory (CategoryTheory.OplaxFunctor B C) | A bicategory structure on the oplax functors between bicategories. | true |
OrderDual.instModule' | Mathlib.Algebra.Order.Module.Synonym | {α : Type u_1} → {β : Type u_2} → [inst : Semiring α] → [inst_1 : AddCommMonoid β] → [Module α β] → Module α βᵒᵈ | null | true |
CStarMatrix.instAddCommGroupWithOne._proof_1 | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {n : Type u_1} {A : Type u_2} [inst : DecidableEq n] [inst_1 : AddCommGroupWithOne A],
autoParam (↑0 = 0) AddMonoidWithOne.natCast_zero._autoParam | null | false |
Ideal.quotientEquivDirectSum | Mathlib.LinearAlgebra.FreeModule.IdealQuotient | {ι : Type u_1} →
{R : Type u_2} →
{S : Type u_3} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
[inst_3 : IsDomain R] →
[inst_4 : IsPrincipalIdealRing R] →
[inst_5 : IsDomain S] →
[inst_6 : Finite ι] →
... | Decompose `S⧸I` as a direct sum of cyclic `R`-modules
(quotients by the ideals generated by Smith coefficients of `I`). | true |
CategoryTheory.ShortComplex.Splitting.unop_r | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S : CategoryTheory.ShortComplex Cᵒᵖ} (h : S.Splitting), h.unop.r = h.s.unop | null | true |
Std.ExtTreeMap.maxKey?_mem | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {km : α},
t.maxKey? = some km → km ∈ t | null | true |
instance_wanted | Batteries.Util.ProofWanted | Lean.Parser.Parser | This typeclass instance would be a welcome contribution to the library!
The syntax mirrors `instance` (the name is optional, auto-generated from the class head if
absent) and the payload must be a typeclass. The placeholder is recorded as
`DefWanted (TheClass …)` like `def_wanted`, but additionally the declared
name i... | true |
CategoryTheory.Functor.DenseAt.ofIso | Mathlib.CategoryTheory.Functor.KanExtension.DenseAt | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} → {Y : D} → F.DenseAt Y → {Y' : D} → (Y ≅ Y') → F.DenseAt Y' | If `F : C ⥤ D` is dense at `Y : D`, then it is also at `Y'`
if `Y` and `Y'` are isomorphic. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.