name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.isTrivialBottomUp | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | Lean.Expr → Lean.PrettyPrinter.Delaborator.TopDownAnalyze.AnalyzeM Bool |
RelUpperSet.isRelUpperSet' | Mathlib.Order.Defs.Unbundled | ∀ {α : Type u_1} [inst : LE α] {P : α → Prop} (self : RelUpperSet P), IsRelUpperSet self.carrier P |
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem._proof_1_71 | Mathlib.Data.List.Triplewise | ∀ {α : Type u_1} (head : α) (tail : List α) (i : ℕ),
tail.length + 1 ≤ (head :: tail).length → (head :: tail).length + 1 ≤ tail.length → tail.length < tail.length |
MeromorphicNFAt.meromorphicAt | Mathlib.Analysis.Meromorphic.NormalForm | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {x : 𝕜}, MeromorphicNFAt f x → MeromorphicAt f x |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getD_map_of_getKey?_eq_some._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) |
Nat.Linear.Expr.var.inj | Init.Data.Nat.Linear | ∀ {i i_1 : Nat.Linear.Var}, Nat.Linear.Expr.var i = Nat.Linear.Expr.var i_1 → i = i_1 |
AddMonoidHom.smul | Mathlib.Algebra.Module.Hom | {R : Type u_1} → {M : Type u_3} → [inst : Semiring R] → [inst_1 : AddCommMonoid M] → [Module R M] → R →+ M →+ M |
Finmap.sigma_keys_lookup | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (s : Finmap β),
(s.keys.sigma fun i => (Finmap.lookup i s).toFinset) = { val := s.entries, nodup := ⋯ } |
Filter.Tendsto.atBot_mul_eventuallyLE_one | Mathlib.Order.Filter.AtTopBot.Monoid | ∀ {α : Type u_1} {M : Type u_2} [inst : CommMonoid M] [inst_1 : Preorder M] [IsOrderedMonoid M] {l : Filter α}
{f g : α → M}, Filter.Tendsto f l Filter.atBot → g ≤ᶠ[l] 1 → Filter.Tendsto (fun x => f x * g x) l Filter.atBot |
_private.Mathlib.Order.Interval.Set.Pi.0.Set.Icc_diff_pi_univ_Ioc_subset._simp_1_1 | Mathlib.Order.Interval.Set.Pi | ∀ {a b : Prop}, (¬(a ∧ b)) = (¬a ∨ ¬b) |
Monoid.PushoutI.NormalWord.Transversal.mk.noConfusion | Mathlib.GroupTheory.PushoutI | {ι : Type u_1} →
{G : ι → Type u_2} →
{H : Type u_3} →
{inst : (i : ι) → Group (G i)} →
{inst_1 : Group H} →
{φ : (i : ι) → H →* G i} →
{P : Sort u} →
{injective : ∀ (i : ι), Function.Injective ⇑(φ i)} →
{set : (i : ι) → Set (G i)} →
{one_mem : ∀ (i : ι), 1 ∈ set i} →
{compl : ∀ (i : ι), Subgroup.IsComplement (↑(φ i).range) (set i)} →
{injective' : ∀ (i : ι), Function.Injective ⇑(φ i)} →
{set' : (i : ι) → Set (G i)} →
{one_mem' : ∀ (i : ι), 1 ∈ set' i} →
{compl' : ∀ (i : ι), Subgroup.IsComplement (↑(φ i).range) (set' i)} →
{ injective := injective, set := set, one_mem := one_mem, compl := compl } =
{ injective := injective', set := set', one_mem := one_mem', compl := compl' } →
(set ≍ set' → P) → P |
_private.Mathlib.Algebra.Ring.CentroidHom.0.CentroidHom._aux_Mathlib_Algebra_Ring_CentroidHom___macroRules__private_Mathlib_Algebra_Ring_CentroidHom_0_CentroidHom_termL_1 | Mathlib.Algebra.Ring.CentroidHom | Lean.Macro |
doublyStochastic.congr_simp | Mathlib.Analysis.Convex.DoublyStochasticMatrix | ∀ (R : Type u_3) (n : Type u_4) [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring R]
[inst_3 : PartialOrder R] [inst_4 : IsOrderedRing R], doublyStochastic R n = doublyStochastic R n |
Submodule.exists_sub_one_mem_and_smul_eq_zero_of_fg_of_le_smul | Mathlib.RingTheory.Finiteness.Nakayama | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] (I : Ideal R)
(N : Submodule R M), N.FG → N ≤ I • N → ∃ r, r - 1 ∈ I ∧ ∀ n ∈ N, r • n = 0 |
Projectivization.Subspace.instCompleteLattice | Mathlib.LinearAlgebra.Projectivization.Subspace | {K : Type u_1} →
{V : Type u_2} →
[inst : Field K] →
[inst_1 : AddCommGroup V] → [inst_2 : Module K V] → CompleteLattice (Projectivization.Subspace K V) |
_aux_Mathlib_Algebra_Module_LinearMap_Defs___unexpand_LinearMap_1 | Mathlib.Algebra.Module.LinearMap.Defs | Lean.PrettyPrinter.Unexpander |
Action.instIsIsoHomInv | Mathlib.CategoryTheory.Action.Basic | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {G : Type u_2} [inst_1 : Monoid G] {M N : Action V G}
(f : M ≅ N), CategoryTheory.IsIso f.inv.hom |
SpecialLinearGroup.centerEquivRootsOfUnity.eq_1 | Mathlib.LinearAlgebra.SpecialLinearGroup | ∀ {R : Type u_1} {V : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
[inst_3 : Module.Free R V] [inst_4 : Module.Finite R V],
SpecialLinearGroup.centerEquivRootsOfUnity =
{
toFun := fun g =>
⋯.by_cases (fun x => 1) fun hR =>
⋯.by_cases (fun x => 1) fun hV =>
have hV := ⋯;
have hr := ⋯;
let r := ⋯.choose;
have this := ⋯;
⟨this.unit, ⋯⟩,
invFun := SpecialLinearGroup.centerEquivRootsOfUnity_invFun, left_inv := ⋯, right_inv := ⋯, map_mul' := ⋯ } |
Equiv.traverse.eq_1 | Mathlib.Control.Traversable.Equiv | ∀ {t t' : Type u → Type u} (eqv : (α : Type u) → t α ≃ t' α) [inst : Traversable t] {m : Type u → Type u}
[inst_1 : Applicative m] {α β : Type u} (f : α → m β) (x : t' α),
Equiv.traverse eqv f x = ⇑(eqv β) <$> traverse f ((eqv α).symm x) |
MvPolynomial.pderiv_X_of_ne | Mathlib.Algebra.MvPolynomial.PDeriv | ∀ {R : Type u} {σ : Type v} [inst : CommSemiring R] {i j : σ}, j ≠ i → (MvPolynomial.pderiv i) (MvPolynomial.X j) = 0 |
RelSeries.head_append | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} (p q : RelSeries r) (connect : (p.last, q.head) ∈ r),
(p.append q connect).head = p.head |
RestrictedProduct.instMonoidCoeOfSubmonoidClass._proof_4 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} (R : ι → Type u_2) {𝓕 : Filter ι} {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)]
{B : (i : ι) → S i} [inst_1 : (i : ι) → Monoid (R i)] [inst_2 : ∀ (i : ι), SubmonoidClass (S i) (R i)], ⇑1 = ⇑1 |
Subsingleton.measurable | Mathlib.MeasureTheory.MeasurableSpace.Basic | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] [Subsingleton α],
Measurable f |
_private.Mathlib.RingTheory.AdicCompletion.Exactness.0.AdicCompletion.mapPreimage._proof_2 | Mathlib.RingTheory.AdicCompletion.Exactness | ∀ {R : Type u_3} [inst : CommRing R] {I : Ideal R} {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{N : Type u_1} [inst_3 : AddCommGroup N] [inst_4 : Module R N] {f : M →ₗ[R] N} (hf : Function.Surjective ⇑f)
(x : AdicCompletion.AdicCauchySequence I N), f ⋯.choose = ↑x 0 |
Ideal.isPrime_map_of_isLocalizationAtPrime | Mathlib.RingTheory.Localization.AtPrime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (q : Ideal R) [inst_1 : q.IsPrime] {S : Type u_4} [inst_2 : CommSemiring S]
[inst_3 : Algebra R S] [IsLocalization.AtPrime S q] {p : Ideal R} [p.IsPrime],
p ≤ q → (Ideal.map (algebraMap R S) p).IsPrime |
TensorProduct.ext' | Mathlib.LinearAlgebra.TensorProduct.Basic | ∀ {R : Type u_1} {R₂ : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring R₂] {σ₁₂ : R →+* R₂} {M : Type u_7}
{N : Type u_8} {P₂ : Type u_17} [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid N] [inst_4 : AddCommMonoid P₂]
[inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R₂ P₂] {g h : TensorProduct R M N →ₛₗ[σ₁₂] P₂},
(∀ (x : M) (y : N), g (x ⊗ₜ[R] y) = h (x ⊗ₜ[R] y)) → g = h |
CategoryTheory.Limits.hasFiniteProducts_of_hasFiniteLimits | Mathlib.CategoryTheory.Limits.Shapes.FiniteProducts | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteLimits C],
CategoryTheory.Limits.HasFiniteProducts C |
_private.Mathlib.Topology.MetricSpace.Bounded.0.IsComplete.nonempty_iInter_of_nonempty_biInter._simp_1_1 | Mathlib.Topology.MetricSpace.Bounded | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i |
ModularForm.const_apply | Mathlib.NumberTheory.ModularForms.Basic | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} [inst : Γ.HasDetOne] (x : ℂ) (τ : UpperHalfPlane), (ModularForm.const x) τ = x |
LieIdeal.map_sup_ker_eq_map' | Mathlib.Algebra.Lie.Ideal | ∀ {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] {f : L →ₗ⁅R⁆ L'} {I : LieIdeal R L},
LieIdeal.map f I ⊔ LieIdeal.map f f.ker = LieIdeal.map f I |
Set.vadd_empty | Mathlib.Algebra.Group.Pointwise.Set.Scalar | ∀ {α : Type u_2} {β : Type u_3} [inst : VAdd α β] {s : Set α}, s +ᵥ ∅ = ∅ |
ProofWidgets.CheckRequestResponse.ctorElimType | ProofWidgets.Cancellable | {motive : ProofWidgets.CheckRequestResponse → Sort u} → ℕ → Sort (max 1 u) |
CategoryTheory.MorphismProperty.HasQuotient.iff_of_eqvGen | Mathlib.CategoryTheory.MorphismProperty.Quotient | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (W : CategoryTheory.MorphismProperty C)
{homRel : HomRel C} [inst_1 : CategoryTheory.HomRel.IsStableUnderPrecomp homRel]
[inst_2 : CategoryTheory.HomRel.IsStableUnderPostcomp homRel] [W.HasQuotient homRel] {X Y : C} {f g : X ⟶ Y},
Relation.EqvGen homRel f g → (W f ↔ W g) |
Lean.Lsp.instFromJsonDiagnosticCode.match_1 | Lean.Data.Lsp.Diagnostics | (motive : Lean.Json → Sort u_1) →
(x : Lean.Json) →
((i : ℤ) → motive (Lean.Json.num { mantissa := i, exponent := 0 })) →
((s : String) → motive (Lean.Json.str s)) → ((j : Lean.Json) → motive j) → motive x |
Std.ExtTreeSet.contains_max? | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {km : α},
t.max? = some km → t.contains km = true |
CategoryTheory.Functor.mapTriangleInvRotateIso_inv_app_hom₃ | Mathlib.CategoryTheory.Triangulated.Functor | ∀ {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] [inst_2 : CategoryTheory.HasShift C ℤ]
[inst_3 : CategoryTheory.HasShift D ℤ] (F : CategoryTheory.Functor C D) [inst_4 : F.CommShift ℤ]
[inst_5 : CategoryTheory.Preadditive C] [inst_6 : CategoryTheory.Preadditive D] [inst_7 : F.Additive]
(X : CategoryTheory.Pretriangulated.Triangle C),
(F.mapTriangleInvRotateIso.inv.app X).hom₃ = CategoryTheory.CategoryStruct.id (F.obj X.obj₂) |
instDecidableEqDihedralGroup.decEq._proof_1 | Mathlib.GroupTheory.SpecificGroups.Dihedral | ∀ {n : ℕ} (a : ZMod n), DihedralGroup.r a = DihedralGroup.r a |
_private.Mathlib.Topology.MetricSpace.HausdorffDimension.0.hausdorffMeasure_of_lt_dimH._simp_1_1 | Mathlib.Topology.MetricSpace.HausdorffDimension | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLinearOrder α] {a : α} {f : ι → α}, (a < iSup f) = ∃ i, a < f i |
Int16.toInt_div_of_ne_left | Init.Data.SInt.Lemmas | ∀ (a b : Int16), a ≠ Int16.minValue → (a / b).toInt = a.toInt.tdiv b.toInt |
Filter.TendstoCofinite.mk | Mathlib.Order.Filter.TendstoCofinite | ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Filter.Tendsto f Filter.cofinite Filter.cofinite → Filter.TendstoCofinite f |
Std.Tactic.BVDecide.BVLogicalExpr.bitblast.go.match_3 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure | (motive : Std.Tactic.BVDecide.Gate → Sort u_1) →
(g : Std.Tactic.BVDecide.Gate) →
(Unit → motive Std.Tactic.BVDecide.Gate.and) →
(Unit → motive Std.Tactic.BVDecide.Gate.xor) →
(Unit → motive Std.Tactic.BVDecide.Gate.beq) → (Unit → motive Std.Tactic.BVDecide.Gate.or) → motive g |
CategoryTheory.MonoidalCategory.InducedLawfulDayConvolutionMonoidalCategoryStructCore.ofHasDayConvolutions._proof_1 | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {V : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} V] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory V] {D : Type u_6} [inst_4 : CategoryTheory.Category.{u_5, u_6} D]
(ι : CategoryTheory.Functor D (CategoryTheory.Functor C V))
[hasDayConvolution :
∀ (d d' : D),
(CategoryTheory.MonoidalCategory.tensor C).HasPointwiseLeftKanExtension
(CategoryTheory.MonoidalCategory.externalProduct (ι.obj d) (ι.obj d'))]
(essImageDayConvolution :
∀ (d d' : D),
ι.essImage
((CategoryTheory.MonoidalCategory.tensor C).pointwiseLeftKanExtension
(CategoryTheory.MonoidalCategory.externalProduct (ι.obj d) (ι.obj d'))))
(d d' : D) (x y : C),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.MonoidalCategory.DayConvolution.unit (ι.obj d) (ι.obj d')).app (x, y))
(((fun d d' => ⋯.getIso) d d').inv.app (CategoryTheory.MonoidalCategoryStruct.tensorObj x y)) =
CategoryTheory.CategoryStruct.comp
((CategoryTheory.MonoidalCategory.DayConvolution.unit (ι.obj d) (ι.obj d')).app (x, y))
(⋯.getIso.inv.app (CategoryTheory.MonoidalCategoryStruct.tensorObj x y)) |
CategoryTheory.Functor.LaxLeftLinear.μₗ | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | {D : Type u_1} →
{D' : Type u_2} →
{inst : CategoryTheory.Category.{v_1, u_1} D} →
{inst_1 : CategoryTheory.Category.{v_2, u_2} D'} →
(F : CategoryTheory.Functor D D') →
{C : Type u_3} →
{inst_2 : CategoryTheory.Category.{v_3, u_3} C} →
{inst_3 : CategoryTheory.MonoidalCategory C} →
{inst_4 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D} →
{inst_5 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D'} →
[self : F.LaxLeftLinear C] →
(c : C) →
(d : D) →
CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionObj c (F.obj d) ⟶
F.obj (CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionObj c d) |
Function.Injective.groupWithZero | Mathlib.Algebra.GroupWithZero.InjSurj | {G₀ : Type u_2} →
{G₀' : Type u_4} →
[inst : GroupWithZero G₀] →
[inst_1 : Zero G₀'] →
[inst_2 : Mul G₀'] →
[inst_3 : One G₀'] →
[inst_4 : Inv G₀'] →
[inst_5 : Div G₀'] →
[inst_6 : Pow G₀' ℕ] →
[inst_7 : Pow G₀' ℤ] →
(f : G₀' → G₀) →
Function.Injective f →
f 0 = 0 →
f 1 = 1 →
(∀ (x y : G₀'), f (x * y) = f x * f y) →
(∀ (x : G₀'), f x⁻¹ = (f x)⁻¹) →
(∀ (x y : G₀'), f (x / y) = f x / f y) →
(∀ (x : G₀') (n : ℕ), f (x ^ n) = f x ^ n) →
(∀ (x : G₀') (n : ℤ), f (x ^ n) = f x ^ n) → GroupWithZero G₀' |
ENat.floor_le_self | Mathlib.Algebra.Order.Floor.Extended | ∀ {r : ENNReal}, ↑⌊r⌋ₑ ≤ r |
_private.Mathlib.Combinatorics.SimpleGraph.Extremal.Turan.0.SimpleGraph.sum_ne_add_mod_eq_sub_one | Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | ∀ {n r c : ℕ}, (∑ w ∈ Finset.range r, if c % r ≠ (n + w) % r then 1 else 0) = r - 1 |
MLList.filterMap | Batteries.Data.MLList.Basic | {m : Type u_1 → Type u_1} → {α β : Type u_1} → [Monad m] → (α → Option β) → MLList m α → MLList m β |
CFC.log_one | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.ExpLog.Basic | ∀ {A : Type u_1} [inst : NormedRing A] [inst_1 : StarRing A] [inst_2 : NormedAlgebra ℝ A]
[inst_3 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint], CFC.log 1 = 0 |
_private.Init.Data.Range.Polymorphic.SInt.0.Int32.instUpwardEnumerable._proof_1 | Init.Data.Range.Polymorphic.SInt | ∀ (n : ℕ) (i : Int32), Int32.minValue.toInt ≤ i.toInt → ¬Int32.minValue.toInt ≤ i.toInt + ↑n → False |
FirstOrder.Language.HomClass.mk._flat_ctor | Mathlib.ModelTheory.Basic | ∀ {L : outParam FirstOrder.Language} {F : Type u_3} {M : outParam (Type u_4)} {N : outParam (Type u_5)}
[inst : FunLike F M N] [inst_1 : L.Structure M] [inst_2 : L.Structure N],
(∀ (φ : F) {n : ℕ} (f : L.Functions n) (x : Fin n → M),
φ (FirstOrder.Language.Structure.funMap f x) = FirstOrder.Language.Structure.funMap f (⇑φ ∘ x)) →
(∀ (φ : F) {n : ℕ} (r : L.Relations n) (x : Fin n → M),
FirstOrder.Language.Structure.RelMap r x → FirstOrder.Language.Structure.RelMap r (⇑φ ∘ x)) →
L.HomClass F M N |
TendstoLocallyUniformlyOn.tendsto_at | Mathlib.Topology.UniformSpace.LocallyUniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} [inst : TopologicalSpace α] [inst_1 : UniformSpace β] {F : ι → α → β}
{f : α → β} {s : Set α} {p : Filter ι},
TendstoLocallyUniformlyOn F f p s → ∀ {a : α}, a ∈ s → Filter.Tendsto (fun i => F i a) p (nhds (f a)) |
CategoryTheory.StrictlyUnitaryLaxFunctor.mk.injEq | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(toLaxFunctor : CategoryTheory.LaxFunctor B C)
(map_id :
autoParam
(∀ (X : B),
toLaxFunctor.map (CategoryTheory.CategoryStruct.id X) = CategoryTheory.CategoryStruct.id (toLaxFunctor.obj X))
CategoryTheory.StrictlyUnitaryLaxFunctor.map_id._autoParam)
(mapId_eq_eqToHom :
autoParam (∀ (X : B), toLaxFunctor.mapId X = CategoryTheory.eqToHom ⋯)
CategoryTheory.StrictlyUnitaryLaxFunctor.mapId_eq_eqToHom._autoParam)
(toLaxFunctor_1 : CategoryTheory.LaxFunctor B C)
(map_id_1 :
autoParam
(∀ (X : B),
toLaxFunctor_1.map (CategoryTheory.CategoryStruct.id X) =
CategoryTheory.CategoryStruct.id (toLaxFunctor_1.obj X))
CategoryTheory.StrictlyUnitaryLaxFunctor.map_id._autoParam)
(mapId_eq_eqToHom_1 :
autoParam (∀ (X : B), toLaxFunctor_1.mapId X = CategoryTheory.eqToHom ⋯)
CategoryTheory.StrictlyUnitaryLaxFunctor.mapId_eq_eqToHom._autoParam),
({ toLaxFunctor := toLaxFunctor, map_id := map_id, mapId_eq_eqToHom := mapId_eq_eqToHom } =
{ toLaxFunctor := toLaxFunctor_1, map_id := map_id_1, mapId_eq_eqToHom := mapId_eq_eqToHom_1 }) =
(toLaxFunctor = toLaxFunctor_1) |
padicValInt | Mathlib.NumberTheory.Padics.PadicVal.Basic | ℕ → ℤ → ℕ |
Int.Linear.instBEqPoly.beq_spec | Init.Data.Int.Linear | ∀ (x x_1 : Int.Linear.Poly),
(x == x_1) =
match x, x_1 with
| Int.Linear.Poly.num a, Int.Linear.Poly.num b => a == b
| Int.Linear.Poly.add a a_1 a_2, Int.Linear.Poly.add b b_1 b_2 => a == b && (a_1 == b_1 && a_2 == b_2)
| x, x_2 => false |
_private.Lean.Elab.Tactic.Do.ProofMode.Frame.0.Lean.Elab.Tactic.Do.ProofMode.transferHypNames.label.match_5 | Lean.Elab.Tactic.Do.ProofMode.Frame | (motive : List Lean.Elab.Tactic.Do.ProofMode.Hyp → Sort u_1) →
(Ps' : List Lean.Elab.Tactic.Do.ProofMode.Hyp) →
((P : Lean.Elab.Tactic.Do.ProofMode.Hyp) → (Ps'' : List Lean.Elab.Tactic.Do.ProofMode.Hyp) → motive (P :: Ps'')) →
((x : List Lean.Elab.Tactic.Do.ProofMode.Hyp) → motive x) → motive Ps' |
Std.ExtDHashMap.getD_ofList_of_contains_eq_false | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} [inst : LawfulBEq α] {l : List ((a : α) × β a)} {k : α}
{fallback : β k}, (List.map Sigma.fst l).contains k = false → (Std.ExtDHashMap.ofList l).getD k fallback = fallback |
Std.ExtDTreeMap.get_getKey? | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp] {a : α}
{h : (t.getKey? a).isSome = true}, (t.getKey? a).get h = t.getKey a ⋯ |
MeasureTheory.Measure.singularPart_eq_zero | Mathlib.MeasureTheory.Measure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} (μ ν : MeasureTheory.Measure α) [μ.HaveLebesgueDecomposition ν],
μ.singularPart ν = 0 ↔ μ.AbsolutelyContinuous ν |
CliffordAlgebra.ofBaseChangeAux._proof_5 | Mathlib.LinearAlgebra.CliffordAlgebra.BaseChange | ∀ {R : Type u_1} [inst : CommRing R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) |
_private.Mathlib.Analysis.Analytic.Order.0.AnalyticAt.analyticOrderAt_deriv_add_one._simp_1_2 | Mathlib.Analysis.Analytic.Order | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) |
LinearMap.coe_equivOfIsUnitDet | Mathlib.LinearAlgebra.Determinant | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : Module.Free R M] [inst_4 : Module.Finite R M] {f : M →ₗ[R] M} (h : IsUnit (LinearMap.det f)),
↑(LinearMap.equivOfIsUnitDet h) = f |
_private.Lean.Meta.Sym.Simp.Have.0.Lean.Meta.Sym.Simp.GetUnivsResult.casesOn | Lean.Meta.Sym.Simp.Have | {motive : Lean.Meta.Sym.Simp.GetUnivsResult✝ → Sort u} →
(t : Lean.Meta.Sym.Simp.GetUnivsResult✝¹) →
((argUnivs fnUnivs : Array Lean.Level) → motive { argUnivs := argUnivs, fnUnivs := fnUnivs }) → motive t |
_private.Mathlib.MeasureTheory.SetSemiring.0.MeasureTheory.IsSetSemiring.exists_disjoint_finset_diff_eq._simp_1_7 | Mathlib.MeasureTheory.SetSemiring | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop} {P : (x : α) → p x → Prop},
((∃ x, ∃ (h : p x), P x h) → b) = ∀ (x : α) (h : p x), P x h → b |
Function.Surjective.comp_left | Mathlib.Logic.Function.Basic | ∀ {α : Sort u} {β : Sort v} {γ : Sort w} {g : β → γ}, Function.Surjective g → Function.Surjective fun x => g ∘ x |
Lean.Widget.instInhabitedStrictOrLazy | Lean.Widget.InteractiveDiagnostic | {a : Type} → [Inhabited a] → {a_1 : Type} → Inhabited (Lean.Widget.StrictOrLazy a a_1) |
List.headD.eq_2 | Init.Data.List.Lemmas | ∀ {α : Type u} (x a : α) (as : List α), (a :: as).headD x = a |
Set.biUnion_union | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {β : Type u_2} (s t : Set α) (u : α → Set β), ⋃ x ∈ s ∪ t, u x = (⋃ x ∈ s, u x) ∪ ⋃ x ∈ t, u x |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.State.mk | Lean.Meta.LetToHave | ℕ → Std.HashMap Lean.ExprStructEq Lean.Meta.LetToHave.Result✝ → Lean.Meta.LetToHave.State✝ |
MaximalSpectrum.recOn | Mathlib.RingTheory.Spectrum.Maximal.Defs | {R : Type u_1} →
[inst : CommSemiring R] →
{motive : MaximalSpectrum R → Sort u} →
(t : MaximalSpectrum R) →
((asIdeal : Ideal R) →
(isMaximal : asIdeal.IsMaximal) → motive { asIdeal := asIdeal, isMaximal := isMaximal }) →
motive t |
CategoryTheory.PreGaloisCategory.PointedGaloisObject.incl.match_1 | Mathlib.CategoryTheory.Galois.Prorepresentability | {C : Type u_2} →
[inst : CategoryTheory.Category.{u_1, u_2} C] →
[inst_1 : CategoryTheory.GaloisCategory C] →
(F : CategoryTheory.Functor C FintypeCat) →
{X Y : CategoryTheory.PreGaloisCategory.PointedGaloisObject F} →
(motive : (X ⟶ Y) → Sort u_4) →
(x : X ⟶ Y) →
((f : X.obj ⟶ Y.obj) →
(comp : (CategoryTheory.ConcreteCategory.hom (F.map f)) X.pt = Y.pt) →
motive { val := f, comp := comp }) →
motive x |
Lean.DeclNameGenerator.mk.inj | Lean.CoreM | ∀ {namePrefix : Lean.Name} {idx : ℕ} {parentIdxs : List ℕ} {namePrefix_1 : Lean.Name} {idx_1 : ℕ}
{parentIdxs_1 : List ℕ},
{ namePrefix := namePrefix, idx := idx, parentIdxs := parentIdxs } =
{ namePrefix := namePrefix_1, idx := idx_1, parentIdxs := parentIdxs_1 } →
namePrefix = namePrefix_1 ∧ idx = idx_1 ∧ parentIdxs = parentIdxs_1 |
SSet.horn₂₀.ι₀₂._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | 1 ≠ 0 |
ProperCone.toPointedCone_bot | Mathlib.Analysis.Convex.Cone.Basic | ∀ {R : Type u_2} {E : Type u_3} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : AddCommMonoid E] [inst_4 : TopologicalSpace E] [inst_5 : Module R E] [inst_6 : T1Space E], ↑⊥ = ⊥ |
Equiv.decidableEq | Mathlib.Logic.Equiv.Defs | {α : Sort u} → {β : Sort v} → α ≃ β → [DecidableEq β] → DecidableEq α |
MulOpposite.instNonUnitalCommCStarAlgebra._proof_2 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [inst : NonUnitalCommCStarAlgebra A], CStarRing Aᵐᵒᵖ |
Lean.Parser.Command.namespace.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer |
RelIso.apply_eq_iff_eq | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (f : r ≃r s) {x y : α}, f x = f y ↔ x = y |
MonoidAlgebra.instCoalgebra | Mathlib.RingTheory.Coalgebra.MonoidAlgebra | (R : Type u_1) →
[inst : CommSemiring R] →
(A : Type u_2) →
[inst_1 : Semiring A] → (X : Type u_3) → [inst_2 : Module R A] → [Coalgebra R A] → Coalgebra R (MonoidAlgebra A X) |
RCLike.instPosMulReflectLE | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], PosMulReflectLE K |
IsOpen.exists_eq_add_of_deriv_eq | Mathlib.Analysis.Calculus.MeanValue | ∀ {𝕜 : Type u_3} {G : Type u_4} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup G] [inst_2 : NormedSpace 𝕜 G] {s : Set 𝕜}
{f g : 𝕜 → G},
IsOpen s →
IsPreconnected s →
DifferentiableOn 𝕜 f s →
DifferentiableOn 𝕜 g s → Set.EqOn (deriv f) (deriv g) s → ∃ a, Set.EqOn f (fun x => g x + a) s |
_private.Batteries.Data.List.Lemmas.0.List.take_succ_drop._proof_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} {n stop : ℕ}, n < l.length - stop → ¬stop + n < l.length → False |
AlgebraicGeometry.Scheme.Modules.pseudofunctor._proof_7 | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {b₀ b₁ b₂ b₃ : AlgebraicGeometry.Schemeᵒᵖ} (f : b₀ ⟶ b₁) (g : b₁ ⟶ b₂) (h : b₂ ⟶ b₃),
CategoryTheory.CategoryStruct.comp
((fun {b₀ b₁ b₂} x x_1 =>
CategoryTheory.Bicategory.Adj.iso₂Mk
(CategoryTheory.Cat.Hom.isoMk (AlgebraicGeometry.Scheme.Modules.pullbackComp x_1.unop x.unop).symm)
(CategoryTheory.Cat.Hom.isoMk (AlgebraicGeometry.Scheme.Modules.pushforwardComp x_1.unop x.unop)) ⋯)
(CategoryTheory.CategoryStruct.comp f g) h).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight
((fun {b₀ b₁ b₂} x x_1 =>
CategoryTheory.Bicategory.Adj.iso₂Mk
(CategoryTheory.Cat.Hom.isoMk (AlgebraicGeometry.Scheme.Modules.pullbackComp x_1.unop x.unop).symm)
(CategoryTheory.Cat.Hom.isoMk (AlgebraicGeometry.Scheme.Modules.pushforwardComp x_1.unop x.unop)) ⋯)
f g).hom
((fun {b b'} f =>
{ l := (AlgebraicGeometry.Scheme.Modules.pullback f.unop).toCatHom,
r := (AlgebraicGeometry.Scheme.Modules.pushforward f.unop).toCatHom,
adj := (AlgebraicGeometry.Scheme.Modules.pullbackPushforwardAdjunction f.unop).toCat })
h))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator
((fun {b b'} f =>
{ l := (AlgebraicGeometry.Scheme.Modules.pullback f.unop).toCatHom,
r := (AlgebraicGeometry.Scheme.Modules.pushforward f.unop).toCatHom,
adj := (AlgebraicGeometry.Scheme.Modules.pullbackPushforwardAdjunction f.unop).toCat })
f)
((fun {b b'} f =>
{ l := (AlgebraicGeometry.Scheme.Modules.pullback f.unop).toCatHom,
r := (AlgebraicGeometry.Scheme.Modules.pushforward f.unop).toCatHom,
adj := (AlgebraicGeometry.Scheme.Modules.pullbackPushforwardAdjunction f.unop).toCat })
g)
((fun {b b'} f =>
{ l := (AlgebraicGeometry.Scheme.Modules.pullback f.unop).toCatHom,
r := (AlgebraicGeometry.Scheme.Modules.pushforward f.unop).toCatHom,
adj := (AlgebraicGeometry.Scheme.Modules.pullbackPushforwardAdjunction f.unop).toCat })
h)).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft
((fun {b b'} f =>
{ l := (AlgebraicGeometry.Scheme.Modules.pullback f.unop).toCatHom,
r := (AlgebraicGeometry.Scheme.Modules.pushforward f.unop).toCatHom,
adj := (AlgebraicGeometry.Scheme.Modules.pullbackPushforwardAdjunction f.unop).toCat })
f)
((fun {b₀ b₁ b₂} x x_1 =>
CategoryTheory.Bicategory.Adj.iso₂Mk
(CategoryTheory.Cat.Hom.isoMk
(AlgebraicGeometry.Scheme.Modules.pullbackComp x_1.unop x.unop).symm)
(CategoryTheory.Cat.Hom.isoMk (AlgebraicGeometry.Scheme.Modules.pushforwardComp x_1.unop x.unop))
⋯)
g h).inv)
((fun {b₀ b₁ b₂} x x_1 =>
CategoryTheory.Bicategory.Adj.iso₂Mk
(CategoryTheory.Cat.Hom.isoMk (AlgebraicGeometry.Scheme.Modules.pullbackComp x_1.unop x.unop).symm)
(CategoryTheory.Cat.Hom.isoMk (AlgebraicGeometry.Scheme.Modules.pushforwardComp x_1.unop x.unop)) ⋯)
f (CategoryTheory.CategoryStruct.comp g h)).inv))) =
CategoryTheory.eqToHom ⋯ |
_private.Mathlib.Algebra.Category.Ring.Basic.0.RingCat.Hom.mk | Mathlib.Algebra.Category.Ring.Basic | {R S : RingCat} → (↑R →+* ↑S) → R.Hom S |
NonUnitalSubsemiring.map_equiv_eq_comap_symm | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S] (f : R ≃+* S)
(K : NonUnitalSubsemiring R), NonUnitalSubsemiring.map (↑f) K = NonUnitalSubsemiring.comap f.symm K |
Polynomial.trailingDegree_eq_iff_natTrailingDegree_eq_of_pos | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} {n : ℕ}, n ≠ 0 → (p.trailingDegree = ↑n ↔ p.natTrailingDegree = n) |
ContinuousLinearMap.IsPositive.inner_nonneg_right | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{T : E →L[𝕜] E}, T.IsPositive → ∀ (x : E), 0 ≤ inner 𝕜 x (T x) |
_private.Mathlib.GroupTheory.Perm.Cycle.Basic.0.Equiv.Perm.IsCycle.of_pow._simp_1_1 | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {f : Equiv.Perm α} {x : α}, (f x ≠ x) = (x ∈ f.support) |
_private.Mathlib.Data.Set.Finite.Basic.0.Set.finite_of_forall_not_lt_lt._simp_1_1 | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {s : Set α} {p : (x : α) → x ∈ s → Prop}, (∀ (x : α) (h : x ∈ s), p x h) = ∀ (x : ↑s), p ↑x ⋯ |
Batteries.Tactic.Lint.SimpTheoremInfo.rec | Batteries.Tactic.Lint.Simp | {motive : Batteries.Tactic.Lint.SimpTheoremInfo → Sort u} →
((hyps : Array Lean.Expr) → (lhs rhs : Lean.Expr) → motive { hyps := hyps, lhs := lhs, rhs := rhs }) →
(t : Batteries.Tactic.Lint.SimpTheoremInfo) → motive t |
Equiv.sigmaCongrRight_trans | Mathlib.Logic.Equiv.Defs | ∀ {α : Type u_4} {β₁ : α → Type u_1} {β₂ : α → Type u_2} {β₃ : α → Type u_3} (F : (a : α) → β₁ a ≃ β₂ a)
(G : (a : α) → β₂ a ≃ β₃ a),
(Equiv.sigmaCongrRight F).trans (Equiv.sigmaCongrRight G) = Equiv.sigmaCongrRight fun a => (F a).trans (G a) |
instReprVector | Init.Data.Vector.Basic | {α : Type u_1} → {n : ℕ} → [Repr α] → Repr (Vector α n) |
Std.TreeMap.getElem!_diff_of_mem_right | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α}
[inst : Inhabited β], k ∈ t₂ → (t₁ \ t₂)[k]! = default |
_private.Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan.0.MeasureTheory.SignedMeasure.of_diff_eq_zero_of_symmDiff_eq_zero_negative._simp_1_1 | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | ∀ {α : Type u_1} [inst : SubtractionMonoid α] {a : α}, (-a = 0) = (a = 0) |
Lean.Grind.CommSemiring.casesOn | Init.Grind.Ring.Basic | {α : Type u} →
{motive : Lean.Grind.CommSemiring α → Sort u_1} →
(t : Lean.Grind.CommSemiring α) →
([toSemiring : Lean.Grind.Semiring α] →
(mul_comm : ∀ (a b : α), a * b = b * a) → motive { toSemiring := toSemiring, mul_comm := mul_comm }) →
motive t |
pointedToBipointedSndBipointedToPointedSndAdjunction | Mathlib.CategoryTheory.Category.Bipointed | pointedToBipointedSnd ⊣ bipointedToPointedSnd |
RatFunc.instDiv | Mathlib.FieldTheory.RatFunc.Basic | {K : Type u} → [inst : CommRing K] → [IsDomain K] → Div (RatFunc K) |
_private.Mathlib.Data.List.Basic.0.List.dropLast_append_getLast.match_1_1 | Mathlib.Data.List.Basic | ∀ {α : Type u_1} (motive : (x : List α) → x ≠ [] → Prop) (x : List α) (x_1 : x ≠ []),
(∀ (h : [] ≠ []), motive [] h) →
(∀ (head : α) (x : [head] ≠ []), motive [head] x) →
(∀ (a b : α) (l : List α) (h : a :: b :: l ≠ []), motive (a :: b :: l) h) → motive x x_1 |
HomotopicalAlgebra.cofibration_iff | Mathlib.AlgebraicTopology.ModelCategory.CategoryWithCofibrations | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : HomotopicalAlgebra.CategoryWithCofibrations C],
HomotopicalAlgebra.Cofibration f ↔ HomotopicalAlgebra.cofibrations C f |
Function.mulSupport_fun_curry | Mathlib.Algebra.Notation.Support | ∀ {ι : Type u_1} {κ : Type u_2} {M : Type u_3} [inst : One M] (f : ι × κ → M),
(Function.mulSupport fun i j => f (i, j)) = Prod.fst '' Function.mulSupport f |
Lean.MonadRecDepth.getRecDepth | Lean.Exception | {m : Type → Type} → [self : Lean.MonadRecDepth m] → m ℕ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.