name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.uliftYoneda_obj_obj_eq_hom' | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} → [CategoryTheory.Category.{v₁, u₁} C] → C → C → Cᵒᵖ → Cᵒᵖ → Prop | Unification hint for `(uliftYoneda.obj X).obj Y = ULift (unop Y ⟶ X)`. | true |
MeasureTheory.Measure.InnerRegularWRT.rfl | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {p : Set α → Prop}, μ.InnerRegularWRT p p | null | true |
_private.Mathlib.GroupTheory.ResiduallyFinite.0.Group.exists_finiteIndexNormalSubgroup_of_residuallyFinite._simp_1_1 | Mathlib.GroupTheory.ResiduallyFinite | ∀ {α : Type u_1} [inst : Group α] {s : Subgroup α} {a b : α}, (↑a = ↑b) = (a⁻¹ * b ∈ s) | null | false |
Algebra.Extension.Cotangent.of_add | Mathlib.RingTheory.Extension.Basic | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {P : Algebra.Extension R S}
(w z : P.ker.Cotangent),
Algebra.Extension.Cotangent.of (w + z) = Algebra.Extension.Cotangent.of w + Algebra.Extension.Cotangent.of z | null | true |
Int.lcm_dvd | Init.Data.Int.Gcd | ∀ {a b : ℤ} {c : ℕ}, a ∣ ↑c → b ∣ ↑c → a.lcm b ∣ c | null | true |
CategoryTheory.Iso.mk.inj | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {X Y : C} {hom : X ⟶ Y} {inv : Y ⟶ X}
{hom_inv_id :
autoParam (CategoryTheory.CategoryStruct.comp hom inv = CategoryTheory.CategoryStruct.id X)
CategoryTheory.Iso.hom_inv_id._autoParam}
{inv_hom_id :
autoParam (CategoryTheory.CategoryStruct.comp... | null | true |
_private.Mathlib.Analysis.Normed.Lp.PiLp.0.PiLp.lipschitzWith_ofLp_aux | Mathlib.Analysis.Normed.Lp.PiLp | ∀ (p : ENNReal) {ι : Type u_2} (β : ι → Type u_4) [inst : Fact (1 ≤ p)] [inst_1 : (i : ι) → PseudoEMetricSpace (β i)]
[inst_2 : Fintype ι], LipschitzWith 1 WithLp.ofLp | null | true |
Std.DTreeMap.ofList_equiv_foldl | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {l : List ((a : α) × β a)},
(Std.DTreeMap.ofList l cmp).Equiv (List.foldl (fun acc p => acc.insert p.fst p.snd) ∅ l) | null | true |
RingCon.instNonAssocSemiringQuotient._proof_3 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R] (c : RingCon R),
autoParam (↑0 = 0) AddMonoidWithOne.natCast_zero._autoParam | null | false |
Finset.sup_image₂_right | Mathlib.Data.Finset.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} [inst : DecidableEq γ] {f : α → β → γ} (s : Finset α)
(t : Finset β) [inst_1 : SemilatticeSup δ] [inst_2 : OrderBot δ] (g : γ → δ),
(Finset.image₂ f s t).sup g = t.sup fun y => s.sup fun x => g (f x y) | null | true |
Function.locallyFinsuppWithin.le_def | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [inst_1 : LE Y] [inst_2 : Zero Y]
{D₁ D₂ : Function.locallyFinsuppWithin U Y}, D₁ ≤ D₂ ↔ ⇑D₁ ≤ ⇑D₂ | null | true |
CategoryTheory.exactPairingUnit._proof_1 | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)
(CategoryTheory.MonoidalCategoryStruct.rightUnitor (Cate... | null | false |
ZNum.zneg_neg | Mathlib.Data.Num.ZNum | ∀ (n : PosNum), -ZNum.neg n = ZNum.pos n | null | true |
_private.Init.Data.List.Pairwise.0.List.pairwise_iff_getElem._simp_1_2 | Init.Data.List.Pairwise | ∀ {α : Type u_1} {a : α} {l : List α}, (a ∈ l) = ∃ i, ∃ (h : i < l.length), l[i] = a | null | false |
UInt8.add_mul | Init.Data.UInt.Lemmas | ∀ {a b c : UInt8}, (a + b) * c = a * c + b * c | null | true |
NonUnitalAlgHom.mk.injEq | Mathlib.Algebra.Algebra.NonUnitalHom | ∀ {R : Type u} {S : Type u₁} [inst : Monoid R] [inst_1 : Monoid S] {φ : R →* S} {A : Type v} {B : Type w}
[inst_2 : NonUnitalNonAssocSemiring A] [inst_3 : DistribMulAction R A] [inst_4 : NonUnitalNonAssocSemiring B]
[inst_5 : DistribMulAction S B] (toDistribMulActionHom : A →ₑ+[φ] B)
(map_mul' :
∀ (x y : A), ... | null | true |
Std.Do.WhileInvariant | Std.Do.Triple.SpecLemmas | Type u → Type u → Std.Do.PostShape → Type u | An invariant for a `repeatM` loop, given as a `PostCond` over the `α ⊕ β` cursor:
`.inl a` is the `continue` case at `a`; `.inr b` is the `break` case with result `b`.
| true |
LeanSearchClient.SearchServer.query | LeanSearchClient.Syntax | LeanSearchClient.SearchServer → String → ℕ → Lean.MetaM (Array LeanSearchClient.SearchResult) | null | true |
Action.leftRegularTensorIso_inv_hom | Mathlib.CategoryTheory.Action.Monoidal | ∀ (G : Type u) [inst : Group G] (X : Action (Type u) G),
(Action.leftRegularTensorIso G X).inv.hom =
{ toFun := fun g => (g.1, (CategoryTheory.ConcreteCategory.hom (X.ρ g.1⁻¹).asHom) g.2),
invFun := fun g => (g.1, (CategoryTheory.ConcreteCategory.hom (X.ρ g.1).asHom) g.2), left_inv := ⋯,
right... | null | true |
ModuleCat.monoidalClosedHomEquiv._proof_2 | Mathlib.Algebra.Category.ModuleCat.Monoidal.Closed | ∀ {R : Type u_1} [inst : CommRing R] (M N P : ModuleCat R),
Function.RightInverse
(fun f =>
CategoryTheory.CategoryStruct.comp (β_ M N).hom (ModuleCat.ofHom (TensorProduct.lift (ModuleCat.Hom.hom₂ f))))
fun f =>
ModuleCat.ofHom₂
((TensorProduct.mk R ↑N ↑M).compr₂ (ModuleCat.Hom.hom (CategoryTh... | null | false |
_private.Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots.0.IsPrimitiveRoot.eq_pow_of_pow_eq_one._simp_1_2 | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {α : Type u} [inst : Monoid α] {u v : αˣ}, (↑u = ↑v) = (u = v) | null | false |
Lean.Meta.RefinedDiscrTree.ModuleDiscrTreeRef.casesOn | Mathlib.Lean.Meta.RefinedDiscrTree.Initialize | {α : Type} →
{motive : Lean.Meta.RefinedDiscrTree.ModuleDiscrTreeRef α → Sort u} →
(t : Lean.Meta.RefinedDiscrTree.ModuleDiscrTreeRef α) →
((ref : IO.Ref (Lean.Meta.RefinedDiscrTree α)) → motive { ref := ref }) → motive t | null | false |
String.Slice.Pattern.ToBackwardSearcher.DefaultBackwardSearcher.instIteratorIdSearchStepOfBackwardPattern.match_1 | Init.Data.String.Pattern.Basic | {ρ : Type} →
(pat : ρ) →
(s : String.Slice) →
(motive :
Std.IterStep (Std.IterM Id (String.Slice.Pattern.SearchStep s)) (String.Slice.Pattern.SearchStep s) →
Sort u_1) →
(x : Std.IterStep (Std.IterM Id (String.Slice.Pattern.SearchStep s)) (String.Slice.Pattern.SearchStep s)) →
... | null | false |
MvQPF.wrepr.eq_1 | Mathlib.Data.QPF.Multivariate.Constructions.Fix | ∀ {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n},
MvQPF.wrepr = MvQPF.recF ((MvQPF.P F).wMk' ∘ MvQPF.repr) | null | true |
Lean.Meta.Grind.CongrTheoremCacheKey.mk | Lean.Meta.Tactic.Grind.Types | Lean.Expr → ℕ → Lean.Meta.Grind.CongrTheoremCacheKey | null | true |
Sym2.toFinset_ne_empty._simp_1 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} [inst : DecidableEq α] (z : Sym2 α), (z.toFinset = ∅) = False | null | false |
analyticOn_cexp | Mathlib.Analysis.SpecialFunctions.ExpDeriv | AnalyticOn ℂ Complex.exp Set.univ | The function `Complex.exp` is complex analytic. | true |
IntermediateField.LinearDisjoint.congr_simp | Mathlib.FieldTheory.LinearDisjoint | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (A A_1 : IntermediateField F E),
A = A_1 →
∀ (L : Type w) [inst_3 : Field L] [inst_4 : Algebra F L] [inst_5 : Algebra L E] [inst_6 : IsScalarTower F L E],
A.LinearDisjoint L = A_1.LinearDisjoint L | null | true |
Finsupp.mapDomain_fun_comp | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {M : Type u_5} [inst : AddCommMonoid M] {v : α →₀ M} (f : α → β)
(g : β → γ), Finsupp.mapDomain (fun a => g (f a)) v = Finsupp.mapDomain g (Finsupp.mapDomain f v) | null | true |
Lean.Meta.Closure.Context._sizeOf_inst | Lean.Meta.Closure | SizeOf Lean.Meta.Closure.Context | null | false |
_private.Mathlib.Algebra.Module.Torsion.PrimaryComponent.0.Ideal.primaryComponent_torsionBySet_of_isCoprime._simp_1_4 | Mathlib.Algebra.Module.Torsion.PrimaryComponent | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ | null | false |
MeasureTheory.Measure.pi_caratheodory | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasurableSpace (α i)]
(μ : (i : ι) → MeasureTheory.Measure (α i)),
MeasurableSpace.pi ≤ (MeasureTheory.OuterMeasure.pi fun i => (μ i).toOuterMeasure).caratheodory | null | true |
BooleanSubalgebra.coe_comap._simp_1 | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_2} {β : Type u_3} [inst : BooleanAlgebra α] [inst_1 : BooleanAlgebra β] (L : BooleanSubalgebra β)
(f : BoundedLatticeHom α β), ⇑f ⁻¹' ↑L = ↑(BooleanSubalgebra.comap f L) | null | false |
_private.Std.Time.Date.Unit.Weekday.0.Std.Time.instReprWeekday.repr.match_1.splitter | Std.Time.Date.Unit.Weekday | (motive : Std.Time.Weekday → Sort u_1) →
(x : Std.Time.Weekday) →
(Unit → motive Std.Time.Weekday.monday) →
(Unit → motive Std.Time.Weekday.tuesday) →
(Unit → motive Std.Time.Weekday.wednesday) →
(Unit → motive Std.Time.Weekday.thursday) →
(Unit → motive Std.Time.Weekday.friday... | null | true |
Aesop.GoalWithMVars.mk.sizeOf_spec | Aesop.Script.GoalWithMVars | ∀ (goal : Lean.MVarId) (mvars : Std.HashSet Lean.MVarId),
sizeOf { goal := goal, mvars := mvars } = 1 + sizeOf goal + sizeOf mvars | null | true |
continuous_mabs | Mathlib.Topology.Algebra.Order.Group | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : CommGroup G] [inst_2 : LinearOrder G] [IsOrderedMonoid G]
[OrderTopology G], Continuous mabs | null | true |
_private.Mathlib.Geometry.Manifold.ChartedSpace.0.ChartedSpaceCore.openPartialHomeomorph._simp_2 | Mathlib.Geometry.Manifold.ChartedSpace | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
Lean.Meta.Simp.mkCast | Batteries.Lean.Meta.Simp | Lean.Meta.Simp.Result → Lean.Expr → Lean.MetaM Lean.Expr | Construct the `Expr` `cast h e`, from a `Simp.Result` with proof `h`. | true |
FintypeCat.Skeleton.incl._proof_2 | Mathlib.CategoryTheory.FintypeCat | ∀ {X Y Z : FintypeCat.Skeleton} (f : X ⟶ Y) (g : Y ⟶ Z),
FintypeCat.homMk (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (FintypeCat.homMk f) (FintypeCat.homMk g) | null | false |
CategoryTheory.Precoverage.ZeroHypercover.singleton.congr_simp | Mathlib.AlgebraicGeometry.Morphisms.UnderlyingMap | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Precoverage C} {S T : C} (f f_1 : S ⟶ T)
(e_f : f = f_1) (hf : CategoryTheory.Presieve.singleton f ∈ J.coverings T),
CategoryTheory.Precoverage.ZeroHypercover.singleton f hf = CategoryTheory.Precoverage.ZeroHypercover.singleton f_1 ⋯ | null | true |
riemannianMetricVectorSpace._proof_1 | Mathlib.Geometry.Manifold.Riemannian.Basic | ∀ (F : Type u_1) [inst : NormedAddCommGroup F] [inst_1 : InnerProductSpace ℝ F],
IsManifold (modelWithCornersSelf ℝ F) 1 F | null | false |
ArchimedeanClass.instLinearOrderedAddCommMonoidWithTop._proof_1 | Mathlib.Algebra.Order.Ring.Archimedean | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : CommRing R] [inst_2 : IsStrictOrderedRing R] (x : ArchimedeanClass R),
⊤ + x = ⊤ | null | false |
ContinuousMap.HomotopyEquiv.piCongrRight._proof_2 | Mathlib.Topology.Homotopy.Equiv | ∀ {ι : Type u_2} {X : ι → Type u_3} {Y : ι → Type u_1} [inst : (i : ι) → TopologicalSpace (X i)]
[inst_1 : (i : ι) → TopologicalSpace (Y i)] (h : (i : ι) → ContinuousMap.HomotopyEquiv (X i) (Y i)),
(ContinuousMap.piMap fun i => (h i).toFun.comp (h i).invFun).Homotopic
(ContinuousMap.piMap fun i => ContinuousMap... | null | false |
Int.add_le_add_left | Init.Data.Int.Order | ∀ {a b : ℤ}, a ≤ b → ∀ (c : ℤ), c + a ≤ c + b | null | true |
Lean.Meta.Grind.SavedState.grind | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.SavedState → Lean.Meta.Grind.State | null | true |
ENNReal.holderConjugate_coe_iff | Mathlib.Basic.Real.ConjExponents | ∀ {p q : NNReal}, (↑p).HolderConjugate ↑q ↔ p.HolderConjugate q | null | true |
AlgHom.restrictNormalAux._proof_10 | Mathlib.FieldTheory.Normal.Defs | ∀ {F : Type u_2} [inst : Field F] {K₁ : Type u_4} {K₂ : Type u_1} [inst_1 : Field K₁] [inst_2 : Field K₂]
[inst_3 : Algebra F K₁] [inst_4 : Algebra F K₂] (ϕ : K₁ →ₐ[F] K₂) (E : Type u_3) [inst_5 : Field E]
[inst_6 : Algebra F E] [inst_7 : Algebra E K₁] [inst_8 : Algebra E K₂] [inst_9 : IsScalarTower F E K₁]
[inst... | null | false |
Set.image_const_mul_uIcc | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] (a b c : α),
(fun x => a * x) '' Set.uIcc b c = Set.uIcc (a * b) (a * c) | null | true |
Plausible.Injective.testable | Mathlib.Testing.Plausible.Functions | {α : Type u} →
{β : Type v} →
(f : α → β) →
[I :
Plausible.Testable
(Plausible.NamedBinder "x"
(∀ (x : α), Plausible.NamedBinder "y" (∀ (y : α), Plausible.NamedBinder "H" (f x = f y → x = y))))] →
Plausible.Testable (Function.Injective f) | null | true |
CategoryTheory.Arrow.homMk.congr_simp | Mathlib.CategoryTheory.Comma.Arrow | ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] {f g : CategoryTheory.Arrow T} (u u_1 : f.left ⟶ g.left)
(e_u : u = u_1) (v v_1 : f.right ⟶ g.right) (e_v : v = v_1)
(w : CategoryTheory.CategoryStruct.comp u g.hom = CategoryTheory.CategoryStruct.comp f.hom v),
CategoryTheory.Arrow.homMk u v w = CategoryTh... | null | true |
Simplicial.«_aux_Mathlib_AlgebraicTopology_SimplicialObject_Basic___delab_app_Simplicial_term__⦋_⦌_1» | Mathlib.AlgebraicTopology.SimplicialObject.Basic | Lean.PrettyPrinter.Delaborator.Delab | Pretty printer defined by `notation3` command. | false |
Matrix.isHermitian_add_transpose_self | Mathlib.LinearAlgebra.Matrix.Hermitian | ∀ {α : Type u_1} {n : Type u_4} [inst : AddCommMonoid α] [inst_1 : StarAddMonoid α] (A : Matrix n n α),
(A + A.conjTranspose).IsHermitian | null | true |
Mathlib.Tactic.introv | Mathlib.Tactic.Basic | Lean.ParserDescr | `introv` introduces the parameters to a dependent function according to their parameter name. If the
first parameter is not depended on by the rest of the function type, `introv` with no (remaining)
arguments does nothing.
* `introv h₁ h₂ ...` introduces non-depended-on parameters in between sequences of depended-on
... | true |
_private.Init.Data.SInt.Package.0.instLinearOrderPackageISize._proof_1 | Init.Data.SInt.Package | ∀ (a b : ISize), a < b ↔ a ≤ b ∧ ¬b ≤ a | null | false |
AdjoinRoot.quotAdjoinRootEquivQuotPolynomialQuot_symm_mk_mk | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (f p : Polynomial R),
(AdjoinRoot.quotAdjoinRootEquivQuotPolynomialQuot I f).symm
((Ideal.Quotient.mk (Ideal.span {Polynomial.map (Ideal.Quotient.mk I) f}))
(Polynomial.map (Ideal.Quotient.mk I) p)) =
(Ideal.Quotient.mk (Ideal.map (AdjoinRoot.of f) ... | null | true |
hasSum_iff_tendsto_nat_of_nonneg | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {f : ℕ → ℝ},
(∀ (i : ℕ), 0 ≤ f i) →
∀ (r : ℝ), HasSum f r ↔ Filter.Tendsto (fun n => ∑ i ∈ Finset.range n, f i) Filter.atTop (nhds r) | A series of non-negative real numbers converges to `r` in the sense of `HasSum` if and only if
the sequence of partial sum converges to `r`. | true |
BoxIntegral.IntegrationParams.exists_memBaseSet_le_iUnion_eq | Mathlib.Analysis.BoxIntegral.Partition.Filter | ∀ {ι : Type u_1} [inst : Fintype ι] {I : BoxIntegral.Box ι} {c : NNReal} (l : BoxIntegral.IntegrationParams)
(π₀ : BoxIntegral.Prepartition I),
π₀.distortion ≤ c →
π₀.compl.distortion ≤ c →
∀ (r : (ι → ℝ) → ↑(Set.Ioi 0)), ∃ π, l.MemBaseSet I c r π ∧ π.toPrepartition ≤ π₀ ∧ π.iUnion = π₀.iUnion | null | true |
Lean.Level.hasMVarEx | Lean.Level | Lean.Level → Bool | null | true |
List.maxOn_cons_cons | Init.Data.List.MinMaxOn | ∀ {β : Type u_1} {α : Type u_2} [inst : LE β] [inst_1 : DecidableLE β] {a b : α} {l : List α} {f : α → β},
List.maxOn f (a :: b :: l) ⋯ = List.maxOn f (maxOn f a b :: l) ⋯ | null | true |
instMonoidHomClassContRepresentationContinuousLinearMapId | Mathlib.RepresentationTheory.Continuous.Basic | ∀ (R : Type u_1) (G : Type u_2) (V : Type u_3) [inst : Monoid G] [inst_1 : Ring R] [inst_2 : AddCommGroup V]
[inst_3 : TopologicalSpace V] [inst_4 : IsTopologicalAddGroup V] [inst_5 : Module R V],
MonoidHomClass (ContRepresentation R G V) G (V →L[R] V) | null | true |
Mathlib.Explode.instInhabitedEntries.default | Mathlib.Tactic.Explode.Datatypes | Mathlib.Explode.Entries | null | true |
_private.Mathlib.Probability.Kernel.IonescuTulcea.Traj.0.ProbabilityTheory.Kernel.trajContent_tendsto_zero._proof_1_3 | Mathlib.Probability.Kernel.IonescuTulcea.Traj | ∀ {X : ℕ → Type u_1} {p : ℕ} (x₀ : (i : ↥(Finset.Iic p)) → X ↑i)
(ind : (k : ℕ) → ((i : ↥(Finset.Iic k)) → X ↑i) → X (k + 1)) (i : ℕ),
iterateInduction x₀ ind i = iterateInduction x₀ ind i | null | false |
ImportGraph.Shake.Bitset.max? | ImportGraph.Shake.Basic | ImportGraph.Shake.Bitset → Option ℕ | The highest set bit of a `Bitset`, if there is one. | true |
TwoP.casesOn | Mathlib.CategoryTheory.Category.TwoP | {motive : TwoP → Sort u_1} →
(t : TwoP) →
((X : Type u) → (toTwoPointing : TwoPointing X) → motive { X := X, toTwoPointing := toTwoPointing }) → motive t | null | false |
Mathlib.Tactic.CheckCompositions.checkCompositionsTac | Mathlib.Tactic.CategoryTheory.CheckCompositions | Lean.Elab.Tactic.TacticM Unit | Check the typing of categorical compositions in the goal. | true |
Nucleus.instMin._proof_3 | Mathlib.Order.Nucleus | ∀ {X : Type u_1} [inst : SemilatticeInf X] (m n : Nucleus X) (x : X), x ≤ m x ⊓ n x | null | false |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.CofFibFactorizationQuasiIsoLE.sequence | Mathlib.Algebra.Homology.Factorizations.CM5a | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Abelian C] →
{K L : CochainComplex C ℤ} →
(f : K ⟶ L) →
[CategoryTheory.EnoughInjectives C] →
[CategoryTheory.Mono f] →
(n₀ : ℤ) →
[K.IsStrictlyGE (n₀ + 1)] →... | Assuming `f : K ⟶ L` is a monomorphism between complexes that are strictly `≥ n₀ + 1`,
this is a dependent sequence of terms in `CofFibFactorizationQuasiIsoLE f (n₀ + q)`
for all `q : ℕ`. | true |
CategoryTheory.StructuredArrow.mapIso_inverse_obj_right | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{S S' : D} {T : CategoryTheory.Functor C D} (i : S ≅ S')
(X : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit S') T),
((CategoryTheory.StructuredArrow.mapIso i).inverse.obj X).right = X.r... | null | true |
_private.Mathlib.ModelTheory.Algebra.Field.IsAlgClosed.0.FirstOrder.Field.finite_ACF_prime_not_realize_of_ACF_zero_realize._simp_1_3 | Mathlib.ModelTheory.Algebra.Field.IsAlgClosed | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {l : ℕ} {φ : L.BoundedFormula α l}
{v : α → M} {xs : Fin l → M}, φ.not.Realize v xs = ¬φ.Realize v xs | null | false |
Algebra.Presentation.HasCoeffs.mk | Mathlib.RingTheory.Extension.Presentation.Core | ∀ {R : Type u_1} {S : Type u_2} {ι : Type u_3} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] {P : Algebra.Presentation R S ι σ} {R₀ : Type u_5} [inst_3 : CommRing R₀]
[inst_4 : Algebra R₀ R] [inst_5 : Algebra R₀ S] [inst_6 : IsScalarTower R₀ R S],
P.coeffs ⊆ Set.range ⇑(algebraMa... | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0.BitVec.reduceOr._regBuiltin.BitVec.reduceOr.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.4244039097._hygCtx._hyg.31 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit | null | false |
Lean.Grind.AC.Seq.sort | Init.Grind.AC | Lean.Grind.AC.Seq → Lean.Grind.AC.Seq | null | true |
_private.Mathlib.RingTheory.Noetherian.OfPrime.0.IsNoetherianRing.of_prime._simp_1_2 | Mathlib.RingTheory.Noetherian.OfPrime | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | null | false |
SimpleGraph.Walk.append_copy_copy | Mathlib.Combinatorics.SimpleGraph.Walk.Operations | ∀ {V : Type u} {G : SimpleGraph V} {u v w u' v' w' : V} (p : G.Walk u v) (q : G.Walk v w) (hu : u = u') (hv : v = v')
(hw : w = w'), (p.copy hu hv).append (q.copy hv hw) = (p.append q).copy hu hw | null | true |
Lean.Compiler.LCNF.JoinPointContextExtender.ExtendState.fvarMap | Lean.Compiler.LCNF.JoinPoints | Lean.Compiler.LCNF.JoinPointContextExtender.ExtendState →
Std.HashMap Lean.FVarId (Std.HashMap Lean.FVarId (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure)) | A map from join point `FVarId`s to a respective map from free variables
to `Param`s. The free variables in this map are the once that the context
of said join point will be extended by passing in the respective parameter.
| true |
CompactExhaustion.shiftr._proof_1 | Mathlib.Topology.Compactness.SigmaCompact | ∀ {X : Type u_1} [inst : TopologicalSpace X] (K : CompactExhaustion X) (n : ℕ), IsCompact (Nat.casesOn n ∅ ⇑K) | null | false |
Fin.finsetImage_castAdd_Iic | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} (m : ℕ) (i : Fin n), Finset.image (Fin.castAdd m) (Finset.Iic i) = Finset.Iic (Fin.castAdd m i) | null | true |
RatFunc.liftOn | Mathlib.FieldTheory.RatFunc.Defs | {K : Type u_1} →
[inst : CommRing K] →
{P : Sort u_2} →
RatFunc K →
(f : Polynomial K → Polynomial K → P) →
(∀ {p q p' q' : Polynomial K},
q ∈ nonZeroDivisors (Polynomial K) →
q' ∈ nonZeroDivisors (Polynomial K) → q' * p = q * p' → f p q = f p' q') →
... | Non-dependent recursion principle for `K⟮X⟯`:
To construct a term of `P : Sort*` out of `x : K⟮X⟯`,
it suffices to provide a constructor `f : Π (p q : K[X]), P`
and a proof that `f p q = f p' q'` for all `p q p' q'` such that `q' * p = q * p'` where
both `q` and `q'` are not zero divisors, stated as `q ∉ K[X]⁰`, `q' ∉ ... | true |
FiniteGrp.instConcreteCategoryMonoidHomCarrierToGrp._aux_3 | Mathlib.Algebra.Category.Grp.FiniteGrp | {X Y : FiniteGrp.{u_1}} → (↑X.toGrp →* ↑Y.toGrp) → (X ⟶ Y) | null | false |
TensorProduct.instSmall | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_14} {M : Type u_15} {N : Type u_16} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] [Small.{u, u_15} M] [Small.{u, u_16} N],
Small.{u, max u_16 u_15} (TensorProduct R M N) | null | true |
Subgroup.quotientEquivProdOfLE'._proof_6 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] {t : Subgroup α} (f : α ⧸ t → α),
Function.RightInverse f QuotientGroup.mk → ∀ (g : α), (f (Quotient.mk'' g))⁻¹ * g ∈ t | null | false |
Asymptotics.IsBigOWith.sub | Mathlib.Analysis.Asymptotics.Arith | ∀ {α : Type u_1} {F : Type u_3} {E' : Type u_4} [inst : Norm F] [inst_1 : SeminormedAddCommGroup E'] {c₁ c₂ : ℝ}
{g : α → F} {l : Filter α} {f₁ f₂ : α → E'},
Asymptotics.IsBigOWith c₁ l f₁ g →
Asymptotics.IsBigOWith c₂ l f₂ g → Asymptotics.IsBigOWith (c₁ + c₂) l (fun x => f₁ x - f₂ x) g | null | true |
Std.DTreeMap.Internal.Impl.rotateR.eq_2 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u} {β : α → Type v} (k : α) (v : β k) (lk : α) (lv : β lk) (ll r : Std.DTreeMap.Internal.Impl α β) (ls : ℕ)
(lk_1 : α) (lv_1 : β lk_1) (ll_1 lr_1 : Std.DTreeMap.Internal.Impl α β),
Std.DTreeMap.Internal.Impl.rotateR k v lk lv ll (Std.DTreeMap.Internal.Impl.inner ls lk_1 lv_1 ll_1 lr_1) r =
if (Std.D... | null | true |
ProbabilityTheory.beta_eq_betaIntegralReal | Mathlib.Probability.Distributions.Beta | ∀ (α β : ℝ), 0 < α → 0 < β → ProbabilityTheory.beta α β = ((↑α).betaIntegral ↑β).re | Relation between the beta function and the gamma function over the reals. | true |
PowerSeries.rescale._proof_1 | Mathlib.RingTheory.PowerSeries.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (a : R), (PowerSeries.mk fun n => a ^ n * (PowerSeries.coeff n) 1) = 1 | null | false |
_private.Lean.Elab.DocString.0.Lean.Doc.fixupInline.match_1 | Lean.Elab.DocString | (motive : Option (Lean.Doc.Ref✝ String) → Sort u_1) →
(x : Option (Lean.Doc.Ref✝ String)) →
((r : Lean.Doc.Ref✝ String) →
(url : String) →
(location : Lean.Syntax) →
(seen : Bool) →
(h : r = { content := url, location := location, seen := seen }) →
motiv... | null | false |
CategoryTheory.Arrow.hom.congr_left | Mathlib.CategoryTheory.Comma.Arrow | ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] {f g : CategoryTheory.Arrow T} {φ₁ φ₂ : f ⟶ g},
φ₁ = φ₂ → CategoryTheory.Arrow.Hom.left φ₁ = CategoryTheory.Arrow.Hom.left φ₂ | null | true |
finsuppTensorFinsuppRid | Mathlib.LinearAlgebra.DirectSum.Finsupp | (R : Type u_1) →
(M : Type u_3) →
(ι : Type u_5) →
(κ : Type u_6) →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → TensorProduct R (ι →₀ M) (κ →₀ R) ≃ₗ[R] ι × κ →₀ M | A variant of `finsuppTensorFinsupp` where the second module is the ground ring. | true |
Nat.not_dvd_of_pos_of_lt | Init.Data.Nat.Lemmas | ∀ {n m : ℕ}, 0 < n → n < m → ¬m ∣ n | null | true |
CategoryTheory.Pseudofunctor.DescentData'.comm | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} {ι : Type t} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} {sq : (i j : ι) → CategoryTheory.Limits.ChosenPullback (f i) (f j)}
{sq₃ : (i₁ i₂ i₃ : ι) → CategoryTheory.Li... | null | true |
_private.Std.Time.Date.Unit.Year.0.Std.Time.Year.instTransOrdOffset._proof_1 | Std.Time.Date.Unit.Year | Std.TransOrd Std.Time.Year.Offset | null | false |
instDecidableEqFreeMagma.decEq | Mathlib.Algebra.Free | {α : Type u_1} → [DecidableEq α] → (x x_1 : FreeMagma α) → Decidable (x = x_1) | null | true |
CategoryTheory.IndParallelPairPresentation.F₂ | Mathlib.CategoryTheory.Limits.Indization.ParallelPair | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{A B : CategoryTheory.Functor Cᵒᵖ (Type v₁)} →
{f g : A ⟶ B} → (self : CategoryTheory.IndParallelPairPresentation f g) → CategoryTheory.Functor self.I C | The diagram presenting `B`. | true |
Lean.Grind.AC.instBEqExpr | Init.Grind.AC | BEq Lean.Grind.AC.Expr | null | true |
Finset.card_mono | Mathlib.Data.Finset.Card | ∀ {α : Type u_1}, Monotone Finset.card | null | true |
Std.Time.HourMarker.rec | Std.Time.Time.HourMarker | {motive : Std.Time.HourMarker → Sort u} →
motive Std.Time.HourMarker.am → motive Std.Time.HourMarker.pm → (t : Std.Time.HourMarker) → motive t | null | false |
volume_iUnion_setOfPred_liouvilleWith | Mathlib.NumberTheory.Transcendental.Liouville.Measure | MeasureTheory.volume (⋃ p, ⋃ (_ : 2 < p), {x | LiouvilleWith p x}) = 0 | The set of numbers satisfying the Liouville condition with some exponent `p > 2` has Lebesgue
measure zero. | true |
MonotoneOn.inv | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} {β : Type u_1} [inst : Group α] [inst_1 : Preorder α] [MulLeftMono α] [MulRightMono α]
[inst_4 : Preorder β] {f : β → α} {s : Set β}, MonotoneOn f s → AntitoneOn (fun x => (f x)⁻¹) s | null | true |
CategoryTheory.MorphismProperty.Under.mapPushoutAdj._proof_9 | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] (P Q : CategoryTheory.MorphismProperty T)
[inst_1 : Q.IsMultiplicative] {X Y : T} [inst_2 : P.IsStableUnderComposition] (f : X ⟶ Y) [P.HasPushoutsAlong f]
(hPf : P f) (A : P.Under Q Y),
CategoryTheory.Limits.HasPushout ((CategoryTheory.MorphismPropert... | null | false |
_private.Mathlib.NumberTheory.LSeries.ZMod.0.ZMod.LFunction_one_sub._simp_1_5 | Mathlib.NumberTheory.LSeries.ZMod | ∀ {a : Prop}, (a → a) = True | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.