name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
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 | true |
_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 | 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 | false |
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)) | true |
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) | true |
padicValInt | Mathlib.NumberTheory.Padics.PadicVal.Basic | ℕ → ℤ → ℕ | true |
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 | true |
Partition.mem_removeBot | Mathlib.Order.Partition.Basic | ∀ {α : Type u_1} {s x : α} [inst : CompleteLattice α] (P : Set α) (indep : sSupIndep P) (sSup_eq : sSup P = s),
x ∈ Partition.removeBot P indep sSup_eq ↔ x ∈ P ∧ x ≠ ⊥ | true |
_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' | false |
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 | true |
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 ⋯ | true |
MeasureTheory.Measure.singularPart_eq_zero | Mathlib.MeasureTheory.Measure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} (μ ν : MeasureTheory.Measure α) [μ.HaveLebesgueDecomposition ν],
μ.singularPart ν = 0 ↔ μ.AbsolutelyContinuous ν | true |
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) | false |
_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) | false |
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 | true |
_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 | false |
_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 | false |
Function.Surjective.comp_left | Mathlib.Logic.Function.Basic | ∀ {α : Sort u} {β : Sort v} {γ : Sort w} {g : β → γ}, Function.Surjective g → Function.Surjective fun x => g ∘ x | true |
Lean.Widget.instInhabitedStrictOrLazy | Lean.Widget.InteractiveDiagnostic | {a : Type} → [Inhabited a] → {a_1 : Type} → Inhabited (Lean.Widget.StrictOrLazy a a_1) | true |
List.headD.eq_2 | Init.Data.List.Lemmas | ∀ {α : Type u} (x a : α) (as : List α), (a :: as).headD x = a | true |
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 | true |
_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✝ | true |
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 | false |
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 | false |
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 | true |
SSet.horn₂₀.ι₀₂._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | 1 ≠ 0 | false |
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], ↑⊥ = ⊥ | true |
Equiv.decidableEq | Mathlib.Logic.Equiv.Defs | {α : Sort u} → {β : Sort v} → α ≃ β → [DecidableEq β] → DecidableEq α | true |
MulOpposite.instNonUnitalCommCStarAlgebra._proof_2 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [inst : NonUnitalCommCStarAlgebra A], CStarRing Aᵐᵒᵖ | false |
Lean.Parser.Command.namespace.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer | true |
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 | true |
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) | true |
RCLike.instPosMulReflectLE | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], PosMulReflectLE K | true |
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 | true |
_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 | 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 ⋯ | false |
instCircularOrderZMod._proof_8 | Mathlib.Order.Circular.ZMod | ∀ {a b c d : ZMod 0}, sbtw a b c → sbtw b d c → sbtw a d c | false |
_private.Mathlib.Algebra.Category.Ring.Basic.0.RingCat.Hom.mk | Mathlib.Algebra.Category.Ring.Basic | {R S : RingCat} → (↑R →+* ↑S) → R.Hom S | true |
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 | true |
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) | true |
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) | true |
_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) | false |
_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 ⋯ | false |
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 | false |
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) | true |
instReprVector | Init.Data.Vector.Basic | {α : Type u_1} → {n : ℕ} → [Repr α] → Repr (Vector α n) | true |
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 | true |
_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) | false |
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 | false |
pointedToBipointedSndBipointedToPointedSndAdjunction | Mathlib.CategoryTheory.Category.Bipointed | pointedToBipointedSnd ⊣ bipointedToPointedSnd | true |
RatFunc.instDiv | Mathlib.FieldTheory.RatFunc.Basic | {K : Type u} → [inst : CommRing K] → [IsDomain K] → Div (RatFunc K) | true |
_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 | false |
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 | true |
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 | true |
Lean.MonadRecDepth.getRecDepth | Lean.Exception | {m : Type → Type} → [self : Lean.MonadRecDepth m] → m ℕ | true |
List.le_sum_of_subadditive_on_pred | Mathlib.Algebra.Order.BigOperators.Group.List | ∀ {α : Type u_5} {β : Type u_6} [inst : AddMonoid α] [inst_1 : AddCommMonoid β] [inst_2 : Preorder β]
[IsOrderedAddMonoid β] (f : α → β) (p : α → Prop),
f 0 ≤ 0 →
p 0 →
(∀ (a b : α), p a → p b → f (a + b) ≤ f a + f b) →
(∀ (a b : α), p a → p b → p (a + b)) → ∀ (l : List α), (∀ a ∈ l, p a) → f l.sum ≤ (List.map f l).sum | true |
Units.ofPow._proof_1 | Mathlib.Algebra.Group.Commute.Units | ∀ {M : Type u_1} [inst : Monoid M] (u : Mˣ) (x : M) {n : ℕ}, n ≠ 0 → x ^ n = ↑u → x * x ^ (n - 1) = ↑u | false |
Array.exists_mem_empty | Init.Data.Array.Lemmas | ∀ {α : Type u_1} (p : α → Prop), ¬∃ x, ∃ (_ : x ∈ #[]), p x | true |
Function.Injective.unique | Mathlib.Logic.Unique | {α : Sort u_1} → {β : Sort u_2} → {f : α → β} → [Inhabited α] → [Subsingleton β] → Function.Injective f → Unique α | true |
InnerProductSpace.Core.inner_smul_left | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[c : PreInnerProductSpace.Core 𝕜 F] (x y : F) {r : 𝕜}, inner 𝕜 (r • x) y = (starRingEnd 𝕜) r * inner 𝕜 x y | true |
_private.Mathlib.RingTheory.PrincipalIdealDomain.0.Ideal.nonPrincipals_eq_empty_iff._simp_1_1 | Mathlib.RingTheory.PrincipalIdealDomain | ∀ {α : Type u} {s : Set α}, (s = ∅) = ∀ (x : α), x ∉ s | false |
_private.Mathlib.Analysis.SpecialFunctions.Complex.LogBounds.0.Complex.norm_log_sub_logTaylor_le._simp_1_8 | Mathlib.Analysis.SpecialFunctions.Complex.LogBounds | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | false |
Lean.Lsp.DeclInfo.mk | Lean.Data.Lsp.Internal | ℕ → ℕ → ℕ → ℕ → ℕ → ℕ → ℕ → ℕ → Lean.Lsp.DeclInfo | true |
AddSubgroup.le_normalClosure | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G}, H ≤ AddSubgroup.normalClosure ↑H | true |
AddCommute.op | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : Add α] {x y : α}, AddCommute x y → AddCommute (AddOpposite.op x) (AddOpposite.op y) | true |
MeasureTheory.Lp.instModule._proof_5 | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_2} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] [inst_1 : NormedRing 𝕜] [inst_2 : Module 𝕜 E] [inst_3 : IsBoundedSMul 𝕜 E] (r s : 𝕜)
(x : ↥(MeasureTheory.Lp E p μ)), (r + s) • x = r • x + s • x | false |
CategoryTheory.Limits.Cone.fromStructuredArrow._proof_2 | Mathlib.CategoryTheory.Limits.ConeCategory | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] {C : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} C] {D : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} D]
(F : CategoryTheory.Functor C D) {X : D} (G : CategoryTheory.Functor J (CategoryTheory.StructuredArrow X F))
⦃X_1 Y : J⦄ (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.Functor.const J).obj X).map f) (G.obj Y).hom =
CategoryTheory.CategoryStruct.comp (G.obj X_1).hom
((G.comp ((CategoryTheory.StructuredArrow.proj X F).comp F)).map f) | false |
_private.Mathlib.Order.Disjoint.0.disjoint_assoc._proof_1_1 | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b c : α}, Disjoint (a ⊓ b) c ↔ Disjoint a (b ⊓ c) | false |
AlgebraicGeometry.IsFinite.rec | Mathlib.AlgebraicGeometry.Morphisms.Finite | {X Y : AlgebraicGeometry.Scheme} →
{f : X ⟶ Y} →
{motive : AlgebraicGeometry.IsFinite f → Sort u} →
([toIsAffineHom : AlgebraicGeometry.IsAffineHom f] →
(finite_app :
∀ (U : Y.Opens),
AlgebraicGeometry.IsAffineOpen U →
(CommRingCat.Hom.hom (AlgebraicGeometry.Scheme.Hom.app f U)).Finite) →
motive ⋯) →
(t : AlgebraicGeometry.IsFinite f) → motive t | false |
Num.toZNum_inj | Mathlib.Data.Num.Lemmas | ∀ {m n : Num}, m.toZNum = n.toZNum ↔ m = n | true |
Std.DTreeMap.Internal.Impl.getEntryLT | Std.Data.DTreeMap.Internal.Queries | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
[Std.TransOrd α] →
(k : α) →
(t : Std.DTreeMap.Internal.Impl α β) → t.Ordered → (∃ a ∈ t, compare a k = Ordering.lt) → (a : α) × β a | true |
Lean.Meta.Grind.Arith.Cutsat.LeCnstr.brecOn.eq | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ {motive_1 : Lean.Meta.Grind.Arith.Cutsat.EqCnstr → Sort u}
{motive_2 : Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof → Sort u}
{motive_3 : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → Sort u}
{motive_4 : Lean.Meta.Grind.Arith.Cutsat.CooperSplitPred → Sort u}
{motive_5 : Lean.Meta.Grind.Arith.Cutsat.CooperSplit → Sort u}
{motive_6 : Lean.Meta.Grind.Arith.Cutsat.CooperSplitProof → Sort u}
{motive_7 : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof → Sort u}
{motive_8 : Lean.Meta.Grind.Arith.Cutsat.LeCnstr → Sort u}
{motive_9 : Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof → Sort u}
{motive_10 : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr → Sort u}
{motive_11 : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof → Sort u}
{motive_12 : Lean.Meta.Grind.Arith.Cutsat.UnsatProof → Sort u}
{motive_13 : Array (Lean.Expr × ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr) → Sort u}
{motive_14 : Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr → Sort u}
{motive_15 : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → Sort u}
{motive_16 : Array (Lean.FVarId × Lean.Meta.Grind.Arith.Cutsat.UnsatProof) → Sort u}
{motive_17 : List (Lean.Expr × ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr) → Sort u}
{motive_18 : List (Lean.FVarId × Lean.Meta.Grind.Arith.Cutsat.UnsatProof) → Sort u}
{motive_19 : Lean.Expr × ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr → Sort u}
{motive_20 : Lean.FVarId × Lean.Meta.Grind.Arith.Cutsat.UnsatProof → Sort u}
{motive_21 : ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr → Sort u} (t : Lean.Meta.Grind.Arith.Cutsat.LeCnstr)
(F_1 : (t : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) → t.below → motive_1 t)
(F_2 : (t : Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof) → t.below → motive_2 t)
(F_3 : (t : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) → t.below → motive_3 t)
(F_4 : (t : Lean.Meta.Grind.Arith.Cutsat.CooperSplitPred) → t.below → motive_4 t)
(F_5 : (t : Lean.Meta.Grind.Arith.Cutsat.CooperSplit) → t.below → motive_5 t)
(F_6 : (t : Lean.Meta.Grind.Arith.Cutsat.CooperSplitProof) → t.below → motive_6 t)
(F_7 : (t : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof) → t.below → motive_7 t)
(F_8 : (t : Lean.Meta.Grind.Arith.Cutsat.LeCnstr) → t.below → motive_8 t)
(F_9 : (t : Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof) → t.below → motive_9 t)
(F_10 : (t : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr) → t.below → motive_10 t)
(F_11 : (t : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof) → t.below → motive_11 t)
(F_12 : (t : Lean.Meta.Grind.Arith.Cutsat.UnsatProof) → t.below → motive_12 t)
(F_13 :
(t : Array (Lean.Expr × ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr)) →
Lean.Meta.Grind.Arith.Cutsat.EqCnstr.below_1 t → motive_13 t)
(F_14 :
(t : Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr) → Lean.Meta.Grind.Arith.Cutsat.EqCnstr.below_2 t → motive_14 t)
(F_15 :
(t : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) → Lean.Meta.Grind.Arith.Cutsat.EqCnstr.below_3 t → motive_15 t)
(F_16 :
(t : Array (Lean.FVarId × Lean.Meta.Grind.Arith.Cutsat.UnsatProof)) →
Lean.Meta.Grind.Arith.Cutsat.EqCnstr.below_4 t → motive_16 t)
(F_17 :
(t : List (Lean.Expr × ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr)) →
Lean.Meta.Grind.Arith.Cutsat.EqCnstr.below_5 t → motive_17 t)
(F_18 :
(t : List (Lean.FVarId × Lean.Meta.Grind.Arith.Cutsat.UnsatProof)) →
Lean.Meta.Grind.Arith.Cutsat.EqCnstr.below_6 t → motive_18 t)
(F_19 :
(t : Lean.Expr × ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
Lean.Meta.Grind.Arith.Cutsat.EqCnstr.below_7 t → motive_19 t)
(F_20 :
(t : Lean.FVarId × Lean.Meta.Grind.Arith.Cutsat.UnsatProof) →
Lean.Meta.Grind.Arith.Cutsat.EqCnstr.below_8 t → motive_20 t)
(F_21 :
(t : ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr) → Lean.Meta.Grind.Arith.Cutsat.EqCnstr.below_9 t → motive_21 t),
t.brecOn F_1 F_2 F_3 F_4 F_5 F_6 F_7 F_8 F_9 F_10 F_11 F_12 F_13 F_14 F_15 F_16 F_17 F_18 F_19 F_20 F_21 =
F_8 t
(Lean.Meta.Grind.Arith.Cutsat.LeCnstr.brecOn.go t F_1 F_2 F_3 F_4 F_5 F_6 F_7 F_8 F_9 F_10 F_11 F_12 F_13 F_14
F_15 F_16 F_17 F_18 F_19 F_20 F_21).2 | true |
Metric.diam_cthickening_le | Mathlib.Topology.MetricSpace.Thickening | ∀ {ε : ℝ} {α : Type u_2} [inst : PseudoMetricSpace α] (s : Set α),
0 ≤ ε → Metric.diam (Metric.cthickening ε s) ≤ Metric.diam s + 2 * ε | true |
CategoryTheory.Monoidal.instMonoidalTransportedInverseEquivalenceTransported._proof_4 | Mathlib.CategoryTheory.Monoidal.Transport | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_4} [inst_2 : CategoryTheory.Category.{u_2, u_4} D] (e : C ≌ D)
{X₁ Y₁ X₂ Y₂ : CategoryTheory.Monoidal.Transported e} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
e.inverse.map (CategoryTheory.MonoidalCategoryStruct.tensorHom f g) =
CategoryTheory.CategoryStruct.comp
(e.unitIso.app (CategoryTheory.MonoidalCategoryStruct.tensorObj (e.inverse.obj X₁) (e.inverse.obj X₂))).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom (e.inverse.map f) (e.inverse.map g))
(e.unitIso.app (CategoryTheory.MonoidalCategoryStruct.tensorObj (e.inverse.obj Y₁) (e.inverse.obj Y₂))).hom) | false |
Module.Grassmannian._sizeOf_inst | Mathlib.RingTheory.Grassmannian | (R : Type u) →
{inst : CommRing R} →
(M : Type v) →
{inst_1 : AddCommGroup M} →
{inst_2 : Module R M} → (k : ℕ) → [SizeOf R] → [SizeOf M] → SizeOf (Module.Grassmannian R M k) | false |
CategoryTheory.Limits.ProductsFromFiniteCofiltered.liftToFinsetLimitCone_cone_π_app | Mathlib.CategoryTheory.Limits.Constructions.Filtered | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {α : Type w}
[inst_1 : CategoryTheory.Limits.HasFiniteProducts C]
[inst_2 : CategoryTheory.Limits.HasLimitsOfShape (Finset (CategoryTheory.Discrete α))ᵒᵖ C]
(F : CategoryTheory.Functor (CategoryTheory.Discrete α) C) (j : CategoryTheory.Discrete α),
(CategoryTheory.Limits.ProductsFromFiniteCofiltered.liftToFinsetLimitCone F).cone.π.app j =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.limit.π (CategoryTheory.Limits.ProductsFromFiniteCofiltered.liftToFinsetObj F)
(Opposite.op {j}))
(CategoryTheory.Limits.Pi.π (fun x => F.obj ↑x) ⟨j, ⋯⟩) | true |
Function.IsFixedPt.image_iterate | Mathlib.Dynamics.FixedPoints.Basic | ∀ {α : Type u} {f : α → α} {s : Set α},
Function.IsFixedPt (Set.image f) s → ∀ (n : ℕ), Function.IsFixedPt (Set.image f^[n]) s | true |
WittVector.instCommRing._proof_9 | Mathlib.RingTheory.WittVector.Basic | ∀ (p : ℕ) (R : Type u_1) [inst : CommRing R] [inst_1 : Fact (Nat.Prime p)] (z : ℤ)
(x : WittVector p (MvPolynomial R ℤ)),
WittVector.mapFun (⇑(MvPolynomial.counit R)) (z • x) = z • WittVector.mapFun (⇑(MvPolynomial.counit R)) x | false |
Lean.Compiler.LCNF.Simp.ConstantFold.folderExt | Lean.Compiler.LCNF.Simp.ConstantFold | Lean.PersistentEnvExtension Lean.Compiler.LCNF.Simp.ConstantFold.FolderOleanEntry
Lean.Compiler.LCNF.Simp.ConstantFold.FolderEntry
(List Lean.Compiler.LCNF.Simp.ConstantFold.FolderEntry ×
Lean.SMap Lean.Name Lean.Compiler.LCNF.Simp.ConstantFold.Folder) | true |
ULift.seminormedRing._proof_17 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedRing α] (a : ULift.{u_1, u_2} α), -a + a = 0 | false |
Aesop.Nanos.nanos | Aesop.Nanos | Aesop.Nanos → ℕ | true |
Set.Ioc_add_bij | Mathlib.Algebra.Order.Interval.Set.Monoid | ∀ {M : Type u_1} [inst : AddCommMonoid M] [inst_1 : PartialOrder M] [IsOrderedCancelAddMonoid M] [ExistsAddOfLE M]
(a b d : M), Set.BijOn (fun x => x + d) (Set.Ioc a b) (Set.Ioc (a + d) (b + d)) | true |
_private.Batteries.Data.UnionFind.Basic.0.Batteries.UnionFind.setParentBump_rankD_lt._proof_1 | Batteries.Data.UnionFind.Basic | ∀ {arr' : Array Batteries.UFNode} {arr : Array Batteries.UFNode} {x : Fin arr.size} {y : Fin arr.size} {i : ℕ},
¬↑x < arr.size → False | false |
Polynomial.Monic.add_of_left | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R}, p.Monic → q.degree < p.degree → (p + q).Monic | true |
_private.Mathlib.NumberTheory.NumberField.Completion.FinitePlace.0.NumberField.FinitePlace.add_le._proof_1_4 | Mathlib.NumberTheory.NumberField.Completion.FinitePlace | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K]
(w : IsDedekindDomain.HeightOneSpectrum (NumberField.RingOfIntegers K)),
IsUniformAddGroup (WithVal (IsDedekindDomain.HeightOneSpectrum.valuation K w)) | false |
setOf_riemannianEDist_lt_subset_nhds' | Mathlib.Geometry.Manifold.Riemannian.Basic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type u_2} [inst_2 : TopologicalSpace H]
(I : ModelWithCorners ℝ E H) {M : Type u_3} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M]
[inst_5 : Bundle.RiemannianBundle fun x => TangentSpace I x] [inst_6 : IsManifold I 1 M]
[IsContinuousRiemannianBundle E fun x => TangentSpace I x] [RegularSpace M] {x : M} {s : Set M},
s ∈ nhds x → ∃ c > 0, {y | Manifold.riemannianEDist I x y < c} ⊆ s | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_725 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w_1 : α),
List.findIdxNth (fun x => decide (x = w_1)) [g a, g (g a)] [g (g a)].length + 1 ≤
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length →
List.findIdxNth (fun x => decide (x = w_1)) [g a, g (g a)] [g (g a)].length <
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length | false |
Bundle.Pullback.lift | Mathlib.Data.Bundle | {B : Type u_1} →
{F : Type u_2} →
{E : B → Type u_3} → {B' : Type u_4} → (f : B' → B) → Bundle.TotalSpace F (f *ᵖ E) → Bundle.TotalSpace F E | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic.0.WeierstrassCurve.Projective.Y_eq_of_equiv._simp_1_2 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | ∀ {R : Type r} [inst : CommRing R] (P : Fin 3 → R) (u : R), (u • P) 1 = u * P 1 | false |
Matrix.diagonalLinearMap._proof_1 | Mathlib.Data.Matrix.Basic | ∀ (n : Type u_2) (α : Type u_1) [inst : DecidableEq n] [inst_1 : AddCommMonoid α] (x y : n → α),
(↑(Matrix.diagonalAddMonoidHom n α)).toFun (x + y) =
(↑(Matrix.diagonalAddMonoidHom n α)).toFun x + (↑(Matrix.diagonalAddMonoidHom n α)).toFun y | false |
Turing.TM1.SupportsStmt.eq_2 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} (S : Finset Λ) (a : Γ → σ → Γ) (q : Turing.TM1.Stmt Γ Λ σ),
Turing.TM1.SupportsStmt S (Turing.TM1.Stmt.write a q) = Turing.TM1.SupportsStmt S q | true |
Ideal.exists_finset_card_eq_height_of_isNoetherianRing | Mathlib.RingTheory.Ideal.KrullsHeightTheorem | ∀ {R : Type u_1} [inst : CommRing R] [IsNoetherianRing R] (p : Ideal R) [p.IsPrime],
∃ s, p ∈ (Ideal.span ↑s).minimalPrimes ∧ ↑s.card = p.height | true |
_private.Mathlib.Data.Fin.Tuple.Finset.0.Fin.mem_piFinset_iff_last_init._simp_1_2 | Mathlib.Data.Fin.Tuple.Finset | ∀ {n : ℕ} {P : Fin (n + 1) → Prop}, (∀ (i : Fin (n + 1)), P i) = ((∀ (i : Fin n), P i.castSucc) ∧ P (Fin.last n)) | false |
Mathlib.Tactic.Widget.StringDiagram.PenroseVar.indices | Mathlib.Tactic.Widget.StringDiagram | Mathlib.Tactic.Widget.StringDiagram.PenroseVar → List ℕ | true |
Lean.Meta.NormCast.NormCastExtension.up | Lean.Meta.Tactic.NormCast | Lean.Meta.NormCast.NormCastExtension → Lean.Meta.SimpExtension | true |
CategoryTheory.Localization.Lifting | Mathlib.CategoryTheory.Localization.Predicate | {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] →
{E : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} E] →
CategoryTheory.Functor C D →
CategoryTheory.MorphismProperty C →
CategoryTheory.Functor C E → CategoryTheory.Functor D E → Type (max u_1 v_3) | true |
CategoryTheory.MorphismProperty.HasRightCalculusOfFractions.exists_rightFraction | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {W : CategoryTheory.MorphismProperty C}
[self : W.HasRightCalculusOfFractions] ⦃X Y : C⦄ (φ : W.LeftFraction X Y),
∃ ψ, CategoryTheory.CategoryStruct.comp ψ.s φ.f = CategoryTheory.CategoryStruct.comp ψ.f φ.s | true |
CategoryTheory.Limits.prod.inl.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (X Y : C)
[inst_2 : CategoryTheory.Limits.HasBinaryProduct X Y],
CategoryTheory.Limits.prod.inl X Y = CategoryTheory.Limits.prod.lift (CategoryTheory.CategoryStruct.id X) 0 | true |
Nat.succ_injective | Mathlib.Data.Nat.Basic | Function.Injective Nat.succ | true |
_private.Mathlib.RingTheory.Localization.Away.Basic.0.IsLocalization.Away.map_injective_iff._simp_1_1 | Mathlib.RingTheory.Localization.Away.Basic | ∀ {M : Type u_1} [inst : Monoid M] (x z : M), (x ∈ Submonoid.powers z) = ∃ n, z ^ n = x | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.