name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
LocallyConstant.congrRightₗ._proof_2 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_2} {Y : Type u_1} [inst : TopologicalSpace X] {Z : Type u_3} (R : Type u_4) [inst_1 : Semiring R]
[inst_2 : AddCommMonoid Y] [inst_3 : Module R Y] [inst_4 : AddCommMonoid Z] [inst_5 : Module R Z] (e : Y ≃ₗ[R] Z),
Function.RightInverse (LocallyConstant.congrRight e.toEquiv).invFun (LocallyConstant.cong... | null | false |
_private.Mathlib.Order.ConditionallyCompleteLattice.Indexed.0.exists_lt_of_lt_ciSup.match_1_1 | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {ι : Sort u_2} [inst : ConditionallyCompleteLinearOrder α] {b : α} {f : ι → α}
(motive : (∃ a ∈ Set.range f, b < a) → Prop) (x : ∃ a ∈ Set.range f, b < a),
(∀ (i : ι) (h : b < f i), motive ⋯) → motive x | null | false |
MulLECancellable.le_mul_iff_one_le_right | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {a b : α} [inst : LE α] [inst_1 : MulOneClass α] [MulLeftMono α],
MulLECancellable a → (a ≤ a * b ↔ 1 ≤ b) | null | true |
_private.Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace.0.Besicovitch.exists_goodδ._simp_1_1 | Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace | ∀ {α : Type u_1} {ι : Sort u_4} {f : ι → α} {s : Set α}, (Set.range f ⊆ s) = ∀ (y : ι), f y ∈ s | null | false |
Nat.add_sub_cancel | Init.Data.Nat.Basic | ∀ (n m : ℕ), n + m - m = n | null | true |
«term_⁻ᵐ» | Mathlib.Algebra.Notation | Lean.TrailingParserDescr | The *negative part* of an element `a`. | true |
FirstOrder.Language.Embedding.map_rel | Mathlib.ModelTheory.Basic | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type w'} [inst : L.Structure M] [inst_1 : L.Structure N]
(φ : L.Embedding M N) {n : ℕ} (r : L.Relations n) (x : Fin n → M),
FirstOrder.Language.Structure.RelMap r (⇑φ ∘ x) ↔ FirstOrder.Language.Structure.RelMap r x | null | true |
AddSubgroup.map._proof_3 | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_2} [inst : AddGroup G] {N : Type u_1} [inst_1 : AddGroup N] (f : G →+ N) (H : AddSubgroup G),
0 ∈ (AddSubmonoid.map f H.toAddSubmonoid).carrier | null | false |
ProbabilityTheory.Kernel.IndepSets.union_iff._simp_1 | Mathlib.Probability.Independence.Kernel.Indep | ∀ {α : Type u_1} {Ω : Type u_2} {_mα : MeasurableSpace α} {s₁ s₂ s' : Set (Set Ω)} {_mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α},
ProbabilityTheory.Kernel.IndepSets (s₁ ∪ s₂) s' κ μ =
(ProbabilityTheory.Kernel.IndepSets s₁ s' κ μ ∧ ProbabilityTheory.Kernel.IndepSets ... | null | false |
CategoryTheory.Hopf.instCategory | Mathlib.CategoryTheory.Monoidal.Hopf_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → CategoryTheory.Category.{v₁, max u₁ v₁} (CategoryTheory.Hopf C) | Morphisms of Hopf monoids are just morphisms of the underlying bimonoids.
In fact they automatically intertwine the antipodes, proved below.
| true |
instSliceableSubarrayNat_8 | Init.Data.Slice.Array.Basic | {α : Type u} → Std.Rii.Sliceable (Subarray α) ℕ (Subarray α) | null | true |
ISize.toUSize_ofNat | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, ISize.toUSize (OfNat.ofNat n) = OfNat.ofNat n | null | true |
CategoryTheory.ShortComplex.FunctorEquivalence.unitIso._proof_10 | Mathlib.Algebra.Homology.ShortComplex.FunctorEquivalence | ∀ (J : Type u_1) (C : Type u_3) [inst : CategoryTheory.Category.{u_4, u_1} J]
[inst_1 : CategoryTheory.Category.{u_2, u_3} C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : CategoryTheory.ShortComplex (CategoryTheory.Functor J C)} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.... | null | false |
UpperSet.instMax._proof_1 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α] (s t : UpperSet α), IsUpperSet (↑s ∩ ↑t) | null | false |
AlgebraNorm.recOn | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | {R : Type u_1} →
[inst : SeminormedCommRing R] →
{S : Type u_2} →
[inst_1 : Ring S] →
[inst_2 : Algebra R S] →
{motive : AlgebraNorm R S → Sort u} →
(t : AlgebraNorm R S) →
((toRingNorm : RingNorm S) →
(smul' : ∀ (a : R) (x : S), toRingNorm.toFun... | null | false |
_private.Mathlib.Tactic.ClickSuggestions.Unfold.0.Mathlib.Tactic.ClickSuggestions.filteredUnfolds | Mathlib.Tactic.ClickSuggestions.Unfold | Lean.Expr → Lean.MetaM (Array Lean.Expr) | Return the consecutive unfoldings of `e` that are user friendly. | true |
_private.Mathlib.GroupTheory.FreeGroup.Basic.0.FreeGroup.Red.Step.length.match_1_1 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u_1} (motive : (x x_1 : List (α × Bool)) → FreeGroup.Red.Step x x_1 → Prop) (x x_1 : List (α × Bool))
(x_2 : FreeGroup.Red.Step x x_1),
(∀ (L1 L2 : List (α × Bool)) (x : α) (b : Bool), motive (L1 ++ (x, b) :: (x, !b) :: L2) (L1 ++ L2) ⋯) →
motive x x_1 x_2 | null | false |
Similar.index_map | Mathlib.Topology.MetricSpace.Similarity | ∀ {ι : Type u_1} {ι' : Type u_2} {P₁ : Type u_3} {P₂ : Type u_4} {v₁ : ι → P₁} {v₂ : ι → P₂}
[inst : PseudoEMetricSpace P₁] [inst_1 : PseudoEMetricSpace P₂],
Similar v₁ v₂ → ∀ (f : ι' → ι), Similar (v₁ ∘ f) (v₂ ∘ f) | Change the index set ι to an index ι' that maps to ι. | true |
AddMonoidAlgebra.domCongr._proof_3 | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ (A : Type u_1) {M : Type u_2} {N : Type u_3} [inst : Semiring A] [inst_1 : AddMonoid M] [inst_2 : AddMonoid N]
(e : M ≃+ N) (x y : AddMonoidAlgebra A M),
(AddMonoidAlgebra.mapDomainRingEquiv A e).toFun (x + y) =
(AddMonoidAlgebra.mapDomainRingEquiv A e).toFun x + (AddMonoidAlgebra.mapDomainRingEquiv A e).toFu... | null | false |
Finset.neg_smul_finset | Mathlib.Algebra.Ring.Action.Pointwise.Finset | ∀ {R : Type u_1} {G : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup G] [inst_2 : Module R G] [inst_3 : DecidableEq G]
{t : Finset G} {a : R}, -a • t = -(a • t) | null | true |
NonarchimedeanAddGroup | Mathlib.Topology.Algebra.Nonarchimedean.Basic | (G : Type u_1) → [AddGroup G] → [TopologicalSpace G] → Prop | A topological additive group is nonarchimedean if every neighborhood of 0
contains an open subgroup. | true |
Ideal.IsMaximal.ne_bot_of_isIntegral_int | Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic | ∀ {R : Type u_1} [inst : CommRing R] [CharZero R] [Algebra.IsIntegral ℤ R] (I : Ideal R) [I.IsMaximal], I ≠ ⊥ | null | true |
HomogeneousLocalization.AtPrime | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | {ι : Type u_1} →
{A : Type u_2} →
{σ : Type u_3} → [inst : CommRing A] → [SetLike σ A] → (ι → σ) → (𝔭 : Ideal A) → [𝔭.IsPrime] → Type (max u_1 u_2) | Localizing a ring homogeneously at a prime ideal. | true |
_private.Mathlib.RingTheory.Ideal.Maps.0.Ideal.map_eq_image_of_surjective._proof_1_1 | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u_2} {S : Type u_1} {F : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
(f : F) {I : Ideal R} [RingHomClass F R S], Function.Surjective ⇑f → ↑(Ideal.map f I) = ⇑f '' ↑I | null | false |
LinearPMap.sSup_le | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : Ring S] {σ : R →+* S} {E : Type u_4} [inst_2 : AddCommGroup E]
[inst_3 : Module R E] {F : Type u_5} [inst_4 : AddCommGroup F] [inst_5 : Module S F] {c : Set (E →ₛₗ.[σ] F)}
(hc : DirectedOn (fun x1 x2 => x1 ≤ x2) c) {g : E →ₛₗ.[σ] F}, (∀ f ∈ c, f ≤ g) → Linea... | null | true |
Mathlib.Linter.TextBased.ErrorFormat.rec | Mathlib.Tactic.Linter.TextBased | {motive : Mathlib.Linter.TextBased.ErrorFormat → Sort u} →
motive Mathlib.Linter.TextBased.ErrorFormat.humanReadable →
motive Mathlib.Linter.TextBased.ErrorFormat.exceptionsFile →
motive Mathlib.Linter.TextBased.ErrorFormat.github → (t : Mathlib.Linter.TextBased.ErrorFormat) → motive t | null | false |
Std.IterM.mapM.eq_1 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β γ : Type w} {m : Type w → Type w'} {n : Type w → Type w''} [inst : Std.Iterator α m β] [inst_1 : Monad n]
[inst_2 : MonadAttach n] [inst_3 : MonadLiftT m n] (f : β → n γ) (it : Std.IterM m β),
Std.IterM.mapM f it = Std.IterM.mapWithPostcondition (fun b => Std.Iterators.PostconditionT.attachLift (f b)) it | null | true |
unitInterval.symm_lt_comm | Mathlib.Topology.UnitInterval | ∀ {i j : ↑unitInterval}, unitInterval.symm i < j ↔ unitInterval.symm j < i | null | true |
RelSeries.mem_toList._simp_1 | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} {s : RelSeries r} {x : α}, (x ∈ s.toList) = (x ∈ s) | null | false |
Set.mem_image_equiv._simp_1 | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_3} {β : Type u_4} {S : Set α} {f : α ≃ β} {x : β}, (x ∈ ⇑f '' S) = (f.symm x ∈ S) | null | false |
AddCommGroup.toDivisionAddCommMonoid.eq_1 | Mathlib.Algebra.Group.Defs | ∀ {G : Type u_1} [inst : AddCommGroup G],
AddCommGroup.toDivisionAddCommMonoid =
{ toSubNegMonoid := inst.toSubNegMonoid, neg_neg := ⋯, neg_add_rev := ⋯, neg_eq_of_add := ⋯, add_comm := ⋯ } | null | true |
_private.Batteries.Data.BinaryHeap.Lemmas.0.Batteries.BinaryHeap.mkHeap.loop.match_1.eq_1 | Batteries.Data.BinaryHeap.Lemmas | ∀ {α : Type u_1} {sz : ℕ} (motive : (x : ℕ) → Vector α sz → x ≤ sz → Sort u_2) (a : Vector α sz) (x : 0 ≤ sz)
(h_1 : (a : Vector α sz) → (x : 0 ≤ sz) → motive 0 a x)
(h_2 : (i : ℕ) → (a : Vector α sz) → (h : i + 1 ≤ sz) → motive i.succ a h),
(match 0, a, x with
| 0, a, x => h_1 a x
| i.succ, a, h => h_2 i... | null | true |
MonoidAlgebra.lift | Mathlib.Algebra.MonoidAlgebra.Basic | (R : Type u_1) →
(A : Type u_4) →
(M : Type u_7) →
[inst : CommSemiring R] →
[inst_1 : Semiring A] → [inst_2 : Algebra R A] → [inst_3 : Monoid M] → (M →* A) ≃ (MonoidAlgebra R M →ₐ[R] A) | Any monoid homomorphism `M →* A` can be lifted to an algebra homomorphism `R[M] →ₐ[R] A`. | true |
CategoryTheory.Pseudofunctor.StrongTrans.naturality_comp_inv | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Pseudo | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.Pseudofunctor B C} (α : F ⟶ G) {a b c : B} (f : a ⟶ b) (g : b ⟶ c),
(α.naturality (CategoryTheory.CategoryStruct.comp f g)).inv =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bic... | null | true |
_private.Batteries.Data.Vector.Basic.0.Vector.scanrMFast.loop._unary | Batteries.Data.Vector.Basic | {m : Type u_1 → Type u_2} →
{α : Type u_3} →
{β : Type u_1} →
{n : ℕ} →
[Monad m] →
(α → β → m β) →
Vector α n →
(n_usize : USize) →
n_usize.toNat = n →
(_ : β) ×' (i : USize) ×' (_ : i.toNat ≤ n) ×' Vector β (n + 1) → m (Vector β... | null | false |
MeasureTheory.stoppedValue_stoppedProcess | Mathlib.Probability.Process.Stopping | ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : Nonempty ι] {u : ι → Ω → β} {τ σ : Ω → WithTop ι}
[inst_1 : LinearOrder ι],
MeasureTheory.stoppedValue (MeasureTheory.stoppedProcess u τ) σ = fun ω =>
if σ ω ≠ ⊤ then MeasureTheory.stoppedValue u (fun ω => min (σ ω) (τ ω)) ω
else MeasureTheory.stoppedVa... | null | true |
Set.nonempty_image_addRight_neg_inter_iff | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : SubtractionMonoid α] {s t : Set α} {a : α},
((fun x => x + -a) '' s ∩ t).Nonempty ↔ ((fun x => a + x) '' (-s) ∩ -t).Nonempty | null | true |
Std.Slice.foldlM_toArray | Init.Data.Slice.Lemmas | ∀ {γ : Type u} {α β : Type v} {m : Type u_1 → Type u_2} {δ : Type u_1} [inst : Monad m]
[inst_1 : Std.ToIterator (Std.Slice γ) Id α β] [inst_2 : Std.Iterator α Id β] [inst_3 : Std.IteratorLoop α Id m]
[Std.LawfulIteratorLoop α Id m] [Std.Iterators.Finite α Id] [LawfulMonad m] {s : Std.Slice γ} {init : δ}
{f : δ →... | null | true |
_private.Mathlib.Topology.Closure.0.exists_isClosed_iff.match_1_1 | Mathlib.Topology.Closure | ∀ {X : Type u_1} [inst : TopologicalSpace X] {p : Set X → Prop} (motive : (∃ t, IsClosed t ∧ p t) → Prop)
(x : ∃ t, IsClosed t ∧ p t), (∀ (w : Set X) (h : IsClosed w ∧ p w), motive ⋯) → motive x | null | false |
CategoryTheory.Pretriangulated.Triangle.functorIsoMk._proof_4 | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_2, u_4} C] [inst_1 : CategoryTheory.HasShift C ℤ] {J : Type u_1}
[inst_2 : CategoryTheory.Category.{u_3, u_1} J]
(A B : CategoryTheory.Functor J (CategoryTheory.Pretriangulated.Triangle C))
(iso₁ : A.comp CategoryTheory.Pretriangulated.Triangle.π₁ ≅ B.comp Categ... | null | false |
CategoryTheory.Subobject.isoOfEq._proof_4 | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {B : C} (X Y : CategoryTheory.Subobject B) (h : X = Y),
CategoryTheory.CategoryStruct.comp (Y.ofLE X ⋯) (X.ofLE Y ⋯) =
CategoryTheory.CategoryStruct.id (CategoryTheory.Subobject.underlying.obj Y) | null | false |
LinearMap.instDistribMulActionDomMulActOfSMulCommClass._proof_3 | Mathlib.Algebra.Module.LinearMap.Basic | ∀ {R : Type u_4} {R' : Type u_5} {M : Type u_3} {M' : Type u_2} [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'}
{S' : Type u_1} [inst_6 : Monoid S'] [inst_7 : DistribMulAction S' M] [inst_8 : SMulCommCla... | null | false |
Matrix.blockDiagonal'_zero | Mathlib.Data.Matrix.Block | ∀ {o : Type u_4} {m' : o → Type u_7} {n' : o → Type u_8} {α : Type u_11} [inst : DecidableEq o] [inst_1 : Zero α],
Matrix.blockDiagonal' 0 = 0 | null | true |
selfAdjoint.submodule | Mathlib.Algebra.Star.Module | (R : Type u_1) →
(A : Type u_2) →
[inst : Semiring R] →
[inst_1 : StarMul R] →
[TrivialStar R] →
[inst_3 : AddCommGroup A] →
[inst_4 : Module R A] → [inst_5 : StarAddMonoid A] → [StarModule R A] → Submodule R A | The self-adjoint elements of a star module, as a submodule. | true |
LieEquiv.coe_toLieHom | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u} {L₁ : Type v} {L₂ : Type w} [inst : CommRing R] [inst_1 : LieRing L₁] [inst_2 : LieRing L₂]
[inst_3 : LieAlgebra R L₁] [inst_4 : LieAlgebra R L₂] (e : L₁ ≃ₗ⁅R⁆ L₂), ⇑e.toLieHom = ⇑e | null | true |
CategoryTheory.MorphismProperty.LeftFraction₃.recOn | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Fractions | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{W : CategoryTheory.MorphismProperty C} →
{X Y : C} →
{motive : W.LeftFraction₃ X Y → Sort u} →
(t : W.LeftFraction₃ X Y) →
({Y' : C} →
(f f' f'' : X ⟶ Y') →
(s : Y ⟶ Y') → (hs : ... | null | false |
List.subset_replicate | Init.Data.List.Sublist | ∀ {α : Type u_1} {n : ℕ} {a : α} {l : List α}, n ≠ 0 → (l ⊆ List.replicate n a ↔ ∀ x ∈ l, x = a) | null | true |
_private.Lean.Elab.DocString.0.Lean.Doc.ModuleDocstringState._sizeOf_inst | Lean.Elab.DocString | SizeOf Lean.Doc.ModuleDocstringState✝ | null | false |
CategoryTheory.Pseudofunctor.whiskerRight_mapId_hom_app_assoc | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] (F : CategoryTheory.Pseudofunctor B CategoryTheory.Cat) {a b : B}
(f : a ⟶ b) (X : ↑(F.obj a)) {Z : ↑(F.obj b)}
(h : (F.map f).toFunctor.obj ((CategoryTheory.CategoryStruct.id (F.obj a)).toFunctor.obj X) ⟶ Z),
CategoryTheory.CategoryStruct.comp ((F.map f).toFu... | null | true |
Lean.Meta.Simp.Result.mk._flat_ctor | Lean.Meta.Tactic.Simp.Types | Lean.Expr → Option Lean.Expr → Bool → Lean.Meta.Simp.Result | null | false |
List.getElem_swap_of_ne | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {i j k : ℕ}, k ≠ i → k ≠ j → ∀ (hk : k < (xs.swap i j).length), (xs.swap i j)[k] = xs[k] | null | true |
AdjoinRoot.algHomOfDvd._proof_1 | Mathlib.RingTheory.AdjoinRoot | ∀ (R : Type u_2) {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (f g : Polynomial S),
g ∣ f → g ∣ Polynomial.map (↑(AlgHom.id R S)) f | null | false |
Substring.Raw.noConfusion | Init.Prelude | {P : Sort u} → {t t' : Substring.Raw} → t = t' → Substring.Raw.noConfusionType P t t' | null | false |
Finset.symmDiff_nonempty | Mathlib.Data.Finset.SymmDiff | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α}, (symmDiff s t).Nonempty ↔ s ≠ t | null | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj.0.CategoryTheory.Functor.PullbackObjObj.mapArrowRight._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u_5} {C₂ : Type u_2} {C₃ : Type u_6} [inst : CategoryTheory.Category.{u_3, u_5} C₁]
[inst_1 : CategoryTheory.Category.{u_1, u_2} C₂] [inst_2 : CategoryTheory.Category.{u_4, u_6} C₃]
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)} {f₁ : CategoryTheory.Arrow C₁}
{f₃ f₃' : CategoryTheor... | null | false |
MonotoneOn.image_lowerBounds_subset_lowerBounds_image | Mathlib.Order.Bounds.Image | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} {s t : Set α},
MonotoneOn f t → s ⊆ t → f '' (lowerBounds s ∩ t) ⊆ lowerBounds (f '' s) | null | true |
CategoryTheory.Limits.pullbackConeEquivBinaryFan._proof_15 | Mathlib.CategoryTheory.Limits.Constructions.Over.Products | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {f : Y ⟶ X} {g : Z ⟶ X}
(X_1 : CategoryTheory.Limits.BinaryFan (CategoryTheory.Over.mk f) (CategoryTheory.Over.mk g)),
(({
obj := fun c =>
CategoryTheory.Limits.PullbackCone.mk (CategoryTheory.Over.Hom.left ... | null | false |
Metric.infDist_le_hausdorffDist_of_mem | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoMetricSpace α] {s t : Set α} {x : α},
x ∈ s → Metric.hausdorffEDist s t ≠ ⊤ → Metric.infDist x t ≤ Metric.hausdorffDist s t | The distance to a set is controlled by the Hausdorff distance. | true |
Mathlib.Tactic.modifyLocalContext | Mathlib.Util.Tactic | {m : Type → Type} → [Lean.MonadMCtx m] → Lean.MVarId → (Lean.LocalContext → Lean.LocalContext) → m Unit | `modifyLocalContext mvarId f` updates the local context of the metavariable
`mvarId` with `f`. The new local context must contain the same fvars as the old
local context and the types (and values, if any) of the fvars in the new local
context must be defeq to their equivalents in the old local context.
If `mvarId` doe... | true |
inv_mul' | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), (a * b)⁻¹ = a⁻¹ / b | null | true |
Array.reverse_eq_append_iff._simp_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs ys zs : Array α}, (xs.reverse = ys ++ zs) = (xs = zs.reverse ++ ys.reverse) | null | false |
ContinuousOn.cfcₙ._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | Lean.Syntax | null | false |
Prod.instGeneralizedBooleanAlgebra._proof_4 | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : GeneralizedBooleanAlgebra α] [inst_1 : GeneralizedBooleanAlgebra β]
(x x_1 : α × β), x ⊓ x_1 ⊔ x \ x_1 = x | null | false |
MinTropical.instMonoidOfAddMonoid._proof_1 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u_1} [inst : AddMonoid R] (x : MinTropical R), MinTropical.untrop (x ^ 0) = MinTropical.untrop 1 | null | false |
CategoryTheory.IsPullback.rec | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Defs | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{P X Y Z : C} →
{fst : P ⟶ X} →
{snd : P ⟶ Y} →
{f : X ⟶ Z} →
{g : Y ⟶ Z} →
{motive : CategoryTheory.IsPullback fst snd f g → Sort u} →
((toCommSq : CategoryTheory.CommSq fst snd f g) →
... | null | false |
_private.Batteries.Util.ProofWanted.0.elabWanted.match_7 | Batteries.Util.ProofWanted | (motive : Lean.TSyntax `ident × WantedRefInfo✝ → Sort u_1) →
(x : Lean.TSyntax `ident × WantedRefInfo✝) →
((hyp : Lean.TSyntax `ident) → (refInfo : WantedRefInfo✝) → motive (hyp, refInfo)) → motive x | null | false |
StrongDual.toLpₗ.eq_1 | Mathlib.Probability.Moments.CovarianceBilinDual | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] {mE : MeasurableSpace E} {𝕜 : Type u_2}
[inst_1 : NontriviallyNormedField 𝕜] [inst_2 : NormedSpace 𝕜 E] (μ : MeasureTheory.Measure E) (p : ENNReal),
StrongDual.toLpₗ μ p =
if h_Lp : MeasureTheory.MemLp id p μ then
{ toFun := fun L => MeasureTheory.MemLp.to... | null | true |
CategoryTheory.GradedObject.mapTrifunctor._proof_8 | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_2} {C₂ : Type u_4} {C₃ : Type u_5} {C₄ : Type u_9} [inst : CategoryTheory.Category.{u_3, u_2} C₁]
[inst_1 : CategoryTheory.Category.{u_10, u_4} C₂] [inst_2 : CategoryTheory.Category.{u_11, u_5} C₃]
[inst_3 : CategoryTheory.Category.{u_8, u_9} C₄]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Funct... | null | false |
Multiset.foldl_add | Mathlib.Data.Multiset.MapFold | ∀ {α : Type u_1} {β : Type v} (f : β → α → β) [inst : RightCommutative f] (b : β) (s t : Multiset α),
Multiset.foldl f b (s + t) = Multiset.foldl f (Multiset.foldl f b s) t | null | true |
CategoryTheory.Limits.FormalCoproduct.evalCompInclIsoId._proof_2 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ (C : Type u_4) [inst : CategoryTheory.Category.{u_3, u_4} C] (A : Type u_2)
[inst_1 : CategoryTheory.Category.{u_1, u_2} A] [inst_2 : CategoryTheory.Limits.HasCoproducts A]
(F : CategoryTheory.Functor C A) (x : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.Sigma.desc fun x_1 =>
Cat... | null | false |
FreeMagma.of.elim | Mathlib.Algebra.Free | {α : Type u} →
{motive : FreeMagma α → Sort u_1} → (t : FreeMagma α) → t.ctorIdx = 0 → ((a : α) → motive (FreeMagma.of a)) → motive t | null | false |
Std.ExtTreeSet.get_union_of_not_mem_left | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α}
(not_mem : k ∉ t₁) {h' : k ∈ t₁ ∪ t₂}, (t₁ ∪ t₂).get k h' = t₂.get k ⋯ | null | true |
Int.toList_rco_eq_singleton_iff._simp_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {k m n : ℤ}, ((m...n).toList = [k]) = (n = m + 1 ∧ m = k) | null | false |
_private.Mathlib.Analysis.Complex.JensenFormula.0.AnalyticOnNhd.sum_divisor_le._simp_1_8 | Mathlib.Analysis.Complex.JensenFormula | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
Nat.descFactorial_self._f | Mathlib.Data.Nat.Factorial.Basic | ∀ (x : ℕ) (f : Nat.below x), x.descFactorial x = x.factorial | null | false |
CategoryTheory.WithTerminal.homFrom | Mathlib.CategoryTheory.WithTerminal.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(X : C) → CategoryTheory.WithTerminal.incl.obj X ⟶ CategoryTheory.WithTerminal.star | Constructs a morphism to `star` from `of X`. | true |
Prop.instDistribLattice | Mathlib.Order.PropInstances | DistribLattice Prop | Propositions form a distributive lattice. | true |
_private.Mathlib.Topology.Sets.CompactOpenCovered.0.IsCompactOpenCovered.of_isCompact_of_forall_exists_isCompactOpenCovered._proof_1_3 | Mathlib.Topology.Sets.CompactOpenCovered | ∀ {S : Type u_1} [inst : TopologicalSpace S] {U : Set S} (Us : (x : S) → x ∈ U → Set S),
(∀ (x : S) (a : x ∈ U), Us x a ⊆ U) →
∀ (x : S) (U_1 : Set S), IsOpen U_1 → ∀ (x_1 : S) (x_2 : x_1 ∈ U), Us x_1 ⋯ = U_1 → x ∈ U_1 → x ∈ U | null | false |
_private.Mathlib.Algebra.Category.MonCat.FilteredColimits.0.MonCat.FilteredColimits.colimit_mul_mk_eq._simp_1_1 | Mathlib.Algebra.Category.MonCat.FilteredColimits | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {FC : outParam (C → C → Type u_1)} {CC : outParam (C → Type w)}
{inst_1 : outParam ((X Y : C) → FunLike (FC X Y) (CC X) (CC Y))} [self : CategoryTheory.ConcreteCategory C FC]
{X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) (x : CC X),
(CategoryTheory.ConcreteCategory.h... | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.head?_keys._simp_1_4 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {t t' : Std.DTreeMap.Internal.Impl α β}, t.Equiv t' = t.toListModel.Perm t'.toListModel | null | false |
comap_prime | Mathlib.Algebra.Prime.Lemmas | ∀ {M : Type u_1} {N : Type u_2} [inst : CommMonoidWithZero M] [inst_1 : CommMonoidWithZero N] {F : Type u_3}
{G : Type u_4} [inst_2 : FunLike F M N] [MonoidWithZeroHomClass F M N] [inst_4 : FunLike G N M] [MulHomClass G N M]
(f : F) (g : G) {p : M}, (∀ (a : M), g (f a) = a) → Prime (f p) → Prime p | null | true |
isUnit_unop | Mathlib.Algebra.Group.Units.Opposite | ∀ {M : Type u_1} [inst : Monoid M] {m : Mᵐᵒᵖ}, IsUnit (MulOpposite.unop m) ↔ IsUnit m | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp.0.Real.differentiable_iteratedDeriv_sinh.match_1_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ (motive : ℕ → Prop) (n : ℕ),
(∀ (_ : Unit), motive 0) → (∀ (_ : Unit), motive 1) → (∀ (n : ℕ), motive n.succ.succ) → motive n | null | false |
HomotopicalAlgebra.PrepathObject.trans_ι | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C} (P P' : HomotopicalAlgebra.PrepathObject A)
[inst_1 : CategoryTheory.Limits.HasPullback P.p₁ P'.p₀],
(P.trans P').ι = CategoryTheory.Limits.pullback.lift P.ι P'.ι ⋯ | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected.0.SimpleGraph.Reachable.mem_subgraphVerts.aux | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {G : SimpleGraph V} {v : V} {H : G.Subgraph},
(∀ v ∈ H.verts, ∀ (w : V), G.Adj v w → H.Adj v w) → ∀ {v' : V}, v' ∈ H.verts → ∀ (p : G.Walk v' v), v ∈ H.verts | null | true |
CompleteLinearOrder.toDecidableLE | Mathlib.Order.CompleteLattice.Defs | {α : Type u_4} → [self : CompleteLinearOrder α] → DecidableLE α | In a linearly ordered type, we assume the order relations are all decidable. | true |
FiberBundleCore.mem_localTrivAt_source._simp_1 | Mathlib.Topology.FiberBundle.Basic | ∀ {ι : Type u_1} {B : Type u_2} {F : Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
(Z : FiberBundleCore ι B F) (p : Z.TotalSpace) (b : B),
(p ∈ (Z.localTrivAt b).source) = (p.proj ∈ (Z.localTrivAt b).baseSet) | null | false |
complEDS₂_two | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ {R : Type u_1} [inst : CommRing R] (b c d : R), complEDS₂ b c d 2 = d | null | true |
Std.ExtDHashMap.get_filter | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α]
{f : (a : α) → β a → Bool} {k : α} {h' : k ∈ Std.ExtDHashMap.filter f m},
(Std.ExtDHashMap.filter f m).get k h' = m.get k ⋯ | null | true |
MulEquiv.coprodCongr._proof_4 | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N], MonoidHomClass (N ≃* M) N M | null | false |
NNReal.rpow_sub_natCast | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {x : NNReal}, x ≠ 0 → ∀ (y : ℝ) (n : ℕ), x ^ (y - ↑n) = x ^ y / x ^ n | null | true |
Quaternion.coe_ofComplex | Mathlib.Analysis.Quaternion | ⇑Quaternion.ofComplex = Quaternion.coeComplex | null | true |
PreAbstractSimplicialComplex.addSingletons._proof_1 | Mathlib.AlgebraicTopology.SimplicialComplex.Basic | ∀ (ι : Type u_1) (K : PreAbstractSimplicialComplex ι), IsRelLowerSet (K.faces ∪ {s | ∃ v, s = {v}}) Finset.Nonempty | null | false |
CategoryTheory.Limits.IsColimit.OfNatIso.homOfCocone.eq_1 | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {X : C} (h : F.cocones.CorepresentableBy X) (s : CategoryTheory.Limits.Cocone F),
CategoryTheory.Limits.IsColimit.OfNatIso.homOfCocone h s = h.homEquiv.symm s.ι | null | true |
Std.DTreeMap.get_erase | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] {k a : α} {h' : a ∈ t.erase k}, (t.erase k).get a h' = t.get a ⋯ | null | true |
GradeMaxOrder.mk.noConfusion | Mathlib.Order.Grade | {𝕆 : Type u_5} →
{α : Type u_6} →
{inst : Preorder 𝕆} →
{inst_1 : Preorder α} →
{P : Sort u} →
{toGradeOrder : GradeOrder 𝕆 α} →
{isMax_grade : ∀ ⦃a : α⦄, IsMax a → IsMax (GradeOrder.grade a)} →
{toGradeOrder' : GradeOrder 𝕆 α} →
{isMax_grade' ... | null | false |
MulSemiringAction.ctorIdx | Mathlib.Algebra.Ring.Action.Basic | {M : Type u} → {R : Type v} → {inst : Monoid M} → {inst_1 : Semiring R} → MulSemiringAction M R → ℕ | null | false |
AffineSubspace.comap_mk' | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {k : Type u_1} {V₁ : Type u_2} {P₁ : Type u_3} {V₂ : Type u_4} {P₂ : Type u_5} [inst : Ring k]
[inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁] [inst_3 : AddTorsor V₁ P₁] [inst_4 : AddCommGroup V₂]
[inst_5 : Module k V₂] [inst_6 : AddTorsor V₂ P₂] (f : P₁ →ᵃ[k] P₂) (p : P₁) (s : Submodule k V₂),
AffineSubspace... | null | true |
CategoryTheory.ComposableArrows.Precomp.obj₂₃ | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (F : CategoryTheory.ComposableArrows C 2) (X : C),
CategoryTheory.ComposableArrows.Precomp.obj F X 3 = F.obj 2 | null | true |
Lean.LLVM.createModule | Lean.Compiler.IR.LLVMBindings | (ctx : Lean.LLVM.Context) → String → BaseIO (Lean.LLVM.Module ctx) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.