name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
CategoryTheory.Lax.OplaxTrans.ctorIdx | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} →
{inst_1 : CategoryTheory.Bicategory C} →
{F G : CategoryTheory.LaxFunctor B C} → CategoryTheory.Lax.OplaxTrans F G → ℕ |
Lean.TransformStep.toStep | Lean.Meta.Tactic.Simp.Types | Lean.TransformStep → Lean.Meta.Simp.Step |
_private.Lean.Meta.Constructions.SparseCasesOn.0.Lean.Meta.SparseCasesOnKey.rec | Lean.Meta.Constructions.SparseCasesOn | {motive : Lean.Meta.SparseCasesOnKey✝ → Sort u} →
((indName : Lean.Name) →
(ctors : Array Lean.Name) →
(isPrivate : Bool) → motive { indName := indName, ctors := ctors, isPrivate := isPrivate }) →
(t : Lean.Meta.SparseCasesOnKey✝¹) → motive t |
_private.Mathlib.Algebra.Order.Monovary.0.monovary_iff_forall_smul_nonneg._simp_1_2 | Mathlib.Algebra.Order.Monovary | ∀ (p : True → Prop), (∀ (x : True), p x) = p True.intro |
Lean.Parser.many1.formatter | Lean.Parser.Extra | Lean.PrettyPrinter.Formatter → Lean.PrettyPrinter.Formatter |
_private.Mathlib.Analysis.AbsoluteValue.Equivalence.0.AbsoluteValue.exists_one_lt_lt_one_pi_of_one_lt._simp_1_2 | Mathlib.Analysis.AbsoluteValue.Equivalence | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] [Nonempty α] {s : Set α},
(s ∈ Filter.atTop) = ∃ a, ∀ b ≥ a, b ∈ s |
ConvexOn.monotoneOn_deriv | Mathlib.Analysis.Convex.Deriv | ∀ {S : Set ℝ} {f : ℝ → ℝ}, ConvexOn ℝ S f → (∀ x ∈ S, DifferentiableAt ℝ f x) → MonotoneOn (deriv f) S |
Std.DTreeMap.minKey!_insertIfNew_of_isEmpty | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α] {k : α} {v : β k}, t.isEmpty = true → (t.insertIfNew k v).minKey! = k |
Algebra.TensorProduct.tensorQuotientEquiv._proof_9 | Mathlib.RingTheory.TensorProduct.Quotient | ∀ (S : Type u_1) [inst : CommRing S], RingHomCompTriple (RingHom.id S) (RingHom.id S) (RingHom.id S) |
CategoryTheory.StructuredArrow.map₂_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]
{A : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} A] {B : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} B] {L : D} {R : CategoryTheory.Functor C D} {L' : B}
{R' : CategoryTheory.Functor A B} {F : CategoryTheory.Functor C A} {G : CategoryTheory.Functor D B} (α : L' ⟶ G.obj L)
(β : R.comp G ⟶ F.comp R') (X : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit L) R),
((CategoryTheory.StructuredArrow.map₂ α β).obj X).right = F.obj X.right |
Aesop.Goal.setMVars | Aesop.Tree.Data | Aesop.UnorderedArraySet Lean.MVarId → Aesop.Goal → Aesop.Goal |
Positive.addRightCancelSemigroup._proof_1 | Mathlib.Algebra.Order.Positive.Ring | ∀ {M : Type u_1} [inst : AddRightCancelMonoid M] [inst_1 : Preorder M] [inst_2 : AddLeftStrictMono M],
IsRightCancelAdd { x // 0 < x } |
Lean.Meta.Grind.Goal | Lean.Meta.Tactic.Grind.Types | Type |
Std.TreeSet.Raw.compare_get?_self | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α}, Option.all (fun x => decide (cmp x k = Ordering.eq)) (t.get? k) = true |
_private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnSeries.map_mul._simp_1_3 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] (x : HahnSeries Γ R) (a : Γ),
(a ∈ x.support) = (x.coeff a ≠ 0) |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.bullet.go | Lean.DocString.Parser | List Lean.Doc.Parser.UnorderedListType → Lean.Parser.ParserFn |
MeasureTheory.le_eLpNorm_of_bddBelow | Mathlib.MeasureTheory.Function.LpSeminorm.Monotonicity | ∀ {α : Type u_1} {F : Type u_3} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup F],
p ≠ 0 →
p ≠ ⊤ →
∀ {f : α → F} (C : NNReal) {s : Set α},
MeasurableSet s → (∀ᵐ (x : α) ∂μ, x ∈ s → C ≤ ‖f x‖₊) → C • μ s ^ (1 / p.toReal) ≤ MeasureTheory.eLpNorm f p μ |
groupHomology.boundaries₂ | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | {k G : Type u} → [inst : CommRing k] → [inst_1 : Group G] → (A : Rep k G) → Submodule k (G × G →₀ ↑A.V) |
Asymptotics.IsLittleOTVS.fun_add | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommGroup F]
[inst_5 : TopologicalSpace F] [inst_6 : Module 𝕜 F] [ContinuousAdd E] [ContinuousSMul 𝕜 E] {f₁ f₂ : α → E} {g : α → F}
{l : Filter α}, f₁ =o[𝕜; l] g → f₂ =o[𝕜; l] g → (fun i => f₁ i + f₂ i) =o[𝕜; l] g |
AddMonoidHom.independent_range_of_coprime_order | Mathlib.GroupTheory.NoncommPiCoprod | ∀ {G : Type u_1} [inst : AddGroup G] {ι : Type u_2} {H : ι → Type u_3} [inst_1 : (i : ι) → AddGroup (H i)]
(ϕ : (i : ι) → H i →+ G),
(Pairwise fun i j => ∀ (x : H i) (y : H j), AddCommute ((ϕ i) x) ((ϕ j) y)) →
∀ [Finite ι] [inst_3 : (i : ι) → Fintype (H i)],
(Pairwise fun i j => (Fintype.card (H i)).Coprime (Fintype.card (H j))) → iSupIndep fun i => (ϕ i).range |
LinearOrderedAddCommGroup.wellFoundedOn_setOf_le_lt_iff_nonempty_discrete | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {G : Type u_2} [inst : AddCommGroup G] [inst_1 : LinearOrder G] [IsOrderedAddMonoid G] [Nontrivial G] {g : G},
({x | g ≤ x}.WellFoundedOn fun x1 x2 => x1 < x2) ↔ Nonempty (G ≃+o ℤ) |
ContinuousLinearMap.toSpanSingletonLE._proof_2 | Mathlib.Topology.Algebra.Module.LinearMap | ∀ (R : Type u_2) (M : Type u_1) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : TopologicalSpace M] [inst_4 : TopologicalSpace R] [inst_5 : ContinuousSMul R M] (x : M),
(fun f => f 1) (ContinuousLinearMap.toSpanSingleton R x) = x |
_private.Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs.0.AffineSubspace.mem_direction_iff_eq_vsub_left.match_1_1 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_3} {V : Type u_1} {P : Type u_2} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {s : AffineSubspace k P} {p : P} (v : V) (motive : v ∈ (fun x => p -ᵥ x) '' ↑s → Prop)
(x : v ∈ (fun x => p -ᵥ x) '' ↑s), (∀ (p₂ : P) (hp₂ : p₂ ∈ ↑s) (hv : (fun x => p -ᵥ x) p₂ = v), motive ⋯) → motive x |
Set.Icc.convexCombo | Mathlib.Topology.UnitInterval | {a b : ℝ} → ↑(Set.Icc a b) → ↑(Set.Icc a b) → ↑unitInterval → ↑(Set.Icc a b) |
Digraph.sdiff_adj | Mathlib.Combinatorics.Digraph.Basic | ∀ {V : Type u_2} (x y : Digraph V) (v w : V), (x \ y).Adj v w ↔ x.Adj v w ∧ ¬y.Adj v w |
smul_add | Mathlib.Algebra.GroupWithZero.Action.Defs | ∀ {M : Type u_1} {A : Type u_7} [inst : AddZeroClass A] [inst_1 : DistribSMul M A] (a : M) (b₁ b₂ : A),
a • (b₁ + b₂) = a • b₁ + a • b₂ |
HomotopicalAlgebra.LeftHomotopyRel.rightHomotopy._proof_4 | Mathlib.AlgebraicTopology.ModelCategory.Homotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : HomotopicalAlgebra.ModelCategory C] {X Y : C}
{f g : X ⟶ Y} [inst_2 : HomotopicalAlgebra.IsCofibrant X] (h : HomotopicalAlgebra.LeftHomotopyRel f g)
(Q : HomotopicalAlgebra.PathObject Y) [inst_3 : Q.IsGood] (h_1 : ⋯.choose.LeftHomotopy f g) (h' : ⋯.choose.IsGood)
(sq :
CategoryTheory.CommSq (CategoryTheory.CategoryStruct.comp f Q.ι) ⋯.choose.i₀ Q.p
(CategoryTheory.Limits.prod.lift (CategoryTheory.CategoryStruct.comp ⋯.choose.π f) h_1.h)),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp ⋯.choose.i₁ sq.lift) Q.p₁ = g |
Lean.IR.SimpleGroundExpr.recOn | Lean.Compiler.IR.SimpleGroundExpr | {motive : Lean.IR.SimpleGroundExpr → Sort u} →
(t : Lean.IR.SimpleGroundExpr) →
((cidx : ℕ) →
(objArgs : Array Lean.IR.SimpleGroundArg) →
(usizeArgs : Array USize) →
(scalarArgs : Array UInt8) → motive (Lean.IR.SimpleGroundExpr.ctor cidx objArgs usizeArgs scalarArgs)) →
((data : String) → motive (Lean.IR.SimpleGroundExpr.string data)) →
((func : Lean.IR.FunId) →
(args : Array Lean.IR.SimpleGroundArg) → motive (Lean.IR.SimpleGroundExpr.pap func args)) →
((args : Array (Lean.Name × UInt64)) → motive (Lean.IR.SimpleGroundExpr.nameMkStr args)) →
((n : Lean.Name) → motive (Lean.IR.SimpleGroundExpr.reference n)) → motive t |
PNat.caseStrongInductionOn | Mathlib.Data.PNat.Basic | {p : ℕ+ → Sort u_1} → (a : ℕ+) → p 1 → ((n : ℕ+) → ((m : ℕ+) → m ≤ n → p m) → p (n + 1)) → p a |
Std.DTreeMap.Internal.Impl.View.mk._flat_ctor | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
{size : ℕ} → (k : α) → β k → Std.DTreeMap.Internal.Impl.Tree α β size → Std.DTreeMap.Internal.Impl.View α β size |
Function.not_lt_argmin | Mathlib.Order.WellFounded | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) [inst : LT β] [inst_1 : WellFoundedLT β] [inst_2 : Nonempty α] (a : α),
¬f a < f (Function.argmin f) |
Ordinal.le_nfp | Mathlib.SetTheory.Ordinal.FixedPoint | ∀ (f : Ordinal.{u_1} → Ordinal.{u_1}) (a : Ordinal.{u_1}), a ≤ Ordinal.nfp f a |
Finset.product_disjUnion | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t t' : Finset β} (ht : Disjoint t t'),
s ×ˢ t.disjUnion t' ht = (s ×ˢ t).disjUnion (s ×ˢ t') ⋯ |
_private.Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber.0.CircleDeg1Lift.coe_pow.match_1_1 | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x |
Bundle.zeroSection_snd | Mathlib.Topology.VectorBundle.Basic | ∀ {B : Type u_2} (F : Type u_3) (E : B → Type u_4) [inst : (x : B) → Zero (E x)] (x : B),
(Bundle.zeroSection F E x).snd = 0 |
Std.ExtDTreeMap.Const.getKey!_insertManyIfNewUnit_list_of_mem | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α (fun x => Unit) cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {l : List α} {k : α},
k ∈ t → (Std.ExtDTreeMap.Const.insertManyIfNewUnit t l).getKey! k = t.getKey! k |
MeasureTheory.measurePreserving_prod_div_swap | Mathlib.MeasureTheory.Group.Prod | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : Group G] [MeasurableMul₂ G] (μ ν : MeasureTheory.Measure G)
[MeasureTheory.SFinite ν] [MeasureTheory.SFinite μ] [MeasurableInv G] [μ.IsMulRightInvariant],
MeasureTheory.MeasurePreserving (fun z => (z.2, z.1 / z.2)) (μ.prod ν) (ν.prod μ) |
Lean.RBNode.WellFormed.recOn | Lean.Data.RBMap | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}
{motive : (a : Lean.RBNode α β) → Lean.RBNode.WellFormed cmp a → Prop} {a : Lean.RBNode α β}
(t : Lean.RBNode.WellFormed cmp a),
motive Lean.RBNode.leaf ⋯ →
(∀ {n n' : Lean.RBNode α β} {k : α} {v : β k} (a : Lean.RBNode.WellFormed cmp n)
(a_1 : n' = Lean.RBNode.insert cmp n k v), motive n a → motive n' ⋯) →
(∀ {n n' : Lean.RBNode α β} {k : α} (a : Lean.RBNode.WellFormed cmp n) (a_1 : n' = Lean.RBNode.erase cmp k n),
motive n a → motive n' ⋯) →
motive a t |
Nat.Subtype.orderIsoOfNat | Mathlib.Order.OrderIsoNat | (s : Set ℕ) → [Infinite ↑s] → ℕ ≃o ↑s |
_private.Mathlib.Algebra.MvPolynomial.Rename.0.MvPolynomial.killCompl_map._simp_1_1 | Mathlib.Algebra.MvPolynomial.Rename | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B), ⇑f = ⇑↑f |
CompleteSublattice.mem_sSup | Mathlib.Order.CompleteLattice.SetLike | ∀ {X : Type u_1} {L : CompleteSublattice (Set X)} {𝒮 : Set ↥L} {x : X}, x ∈ sSup 𝒮 ↔ ∃ T ∈ 𝒮, x ∈ T |
Multiset.coe_attach | Mathlib.Data.Multiset.Defs | ∀ {α : Type u_1} (l : List α), (↑l).attach = ↑l.attach |
_private.Mathlib.Tactic.HigherOrder.0.Tactic.mkHigherOrderType._sparseCasesOn_1 | Mathlib.Tactic.HigherOrder | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
SemilinearIsometryEquivClass.mk | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {𝓕 : Type u_11} {R : outParam (Type u_12)} {R₂ : outParam (Type u_13)} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : outParam (R →+* R₂)} {σ₂₁ : outParam (R₂ →+* R)} [inst_2 : RingHomInvPair σ₁₂ σ₂₁]
[inst_3 : RingHomInvPair σ₂₁ σ₁₂] {E : outParam (Type u_14)} {E₂ : outParam (Type u_15)}
[inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E] [inst_7 : Module R₂ E₂]
[inst_8 : EquivLike 𝓕 E E₂] [toSemilinearEquivClass : SemilinearEquivClass 𝓕 σ₁₂ E E₂],
(∀ (f : 𝓕) (x : E), ‖f x‖ = ‖x‖) → SemilinearIsometryEquivClass 𝓕 σ₁₂ E E₂ |
StieltjesFunction.measure_univ | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (f : StieltjesFunction R)
[inst_2 : OrderTopology R] [inst_3 : CompactIccSpace R] [inst_4 : MeasurableSpace R] [inst_5 : BorelSpace R]
[inst_6 : SecondCountableTopology R] [inst_7 : DenselyOrdered R] [Nonempty R] {l u : ℝ},
Filter.Tendsto (↑f) Filter.atBot (nhds l) →
Filter.Tendsto (↑f) Filter.atTop (nhds u) → f.measure Set.univ = ENNReal.ofReal (u - l) |
Lean.ParseImports.keyword | Lean.Elab.ParseImportsFast | String → Lean.ParseImports.Parser |
CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso_inv_app_hom₁ | Mathlib.CategoryTheory.Triangulated.Opposite.Triangle | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ]
(X : CategoryTheory.Pretriangulated.Triangle Cᵒᵖ),
((CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso C).inv.app X).hom₁ =
CategoryTheory.CategoryStruct.id X.obj₁ |
Preorder.frestrictLe₂.congr_simp | Mathlib.Probability.Kernel.IonescuTulcea.Maps | ∀ {α : Type u_1} [inst : Preorder α] {π : α → Type u_2} [inst_1 : LocallyFiniteOrderBot α] {a b : α} (hab : a ≤ b)
(f f_1 : (i : ↥(Finset.Iic b)) → π ↑i),
f = f_1 → ∀ (i : ↥(Finset.Iic a)), Preorder.frestrictLe₂ hab f i = Preorder.frestrictLe₂ hab f_1 i |
Matroid.uniqueBaseOn_restrict | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {E I : Set α},
I ⊆ E → ∀ (R : Set α), (Matroid.uniqueBaseOn I E).restrict R = Matroid.uniqueBaseOn (I ∩ R) R |
FirstOrder.Language.Term.realize_var | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} (v : α → M) (k : α),
FirstOrder.Language.Term.realize v (FirstOrder.Language.var k) = v k |
GromovHausdorff.instInhabitedGHSpace._proof_2 | Mathlib.Topology.MetricSpace.GromovHausdorff | {0}.Nonempty |
Substring.Raw.ValidFor.dropWhile | Batteries.Data.String.Lemmas | ∀ {l m r : List Char} (p : Char → Bool) {s : Substring.Raw},
Substring.Raw.ValidFor l m r s →
Substring.Raw.ValidFor (l ++ List.takeWhile p m) (List.dropWhile p m) r (s.dropWhile p) |
CategoryTheory.GrothendieckTopology.plusMap_toPlus | Mathlib.CategoryTheory.Sites.Plus | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type w}
[inst_1 : CategoryTheory.Category.{w', w} D]
[inst_2 :
∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)]
(P : CategoryTheory.Functor Cᵒᵖ D) [inst_3 : ∀ (X : C), CategoryTheory.Limits.HasColimitsOfShape (J.Cover X)ᵒᵖ D],
J.plusMap (J.toPlus P) = J.toPlus (J.plusObj P) |
ZMod.eq_one_or_isUnit_sub_one | Mathlib.FieldTheory.Finite.Basic | ∀ {n p k : ℕ} [Fact (Nat.Prime p)], n = p ^ k → ∀ (a : ZMod n), (orderOf a).Coprime n → a = 1 ∨ IsUnit (a - 1) |
Lean.Compiler.LCNF.SpecEntry.alreadySpecialized | Lean.Compiler.LCNF.SpecInfo | Lean.Compiler.LCNF.SpecEntry → Bool |
NumberField.IsCMField.starRing._proof_2 | Mathlib.NumberTheory.NumberField.CMField | ∀ (K : Type u_1) [inst : Field K] [inst_1 : CharZero K] [inst_2 : NumberField.IsCMField K]
[inst_3 : Algebra.IsIntegral ℚ K] (x x_1 : K),
(NumberField.IsCMField.complexConj K) (x + x_1) =
(NumberField.IsCMField.complexConj K) x + (NumberField.IsCMField.complexConj K) x_1 |
MeasurableSpace.DynkinSystem.ext | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_3} {d₁ d₂ : MeasurableSpace.DynkinSystem α}, (∀ (s : Set α), d₁.Has s ↔ d₂.Has s) → d₁ = d₂ |
_private.Mathlib.Analysis.Calculus.BumpFunction.SmoothApprox.0.ContinuousMap.dense_setOf_contDiff._simp_1_2 | Mathlib.Analysis.Calculus.BumpFunction.SmoothApprox | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) |
CategoryTheory.Abelian.PreservesCoimageImageComparison.iso_inv_left | Mathlib.CategoryTheory.Limits.Preserves.Shapes.AbelianImages | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D]
(F : CategoryTheory.Functor C D) [inst_4 : F.PreservesZeroMorphisms] {X Y : C} (f : X ⟶ Y)
[inst_5 : CategoryTheory.Limits.HasKernel f] [inst_6 : CategoryTheory.Limits.HasCokernel f]
[inst_7 : CategoryTheory.Limits.HasKernel (CategoryTheory.Limits.cokernel.π f)]
[inst_8 : CategoryTheory.Limits.HasCokernel (CategoryTheory.Limits.kernel.ι f)]
[inst_9 : CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.parallelPair f 0) F]
[inst_10 : CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.parallelPair f 0) F]
[inst_11 :
CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.parallelPair (CategoryTheory.Limits.cokernel.π f) 0) F]
[inst_12 :
CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.parallelPair (CategoryTheory.Limits.kernel.ι f) 0) F]
[inst_13 : CategoryTheory.Limits.HasKernel (CategoryTheory.Limits.cokernel.π (F.map f))]
[inst_14 : CategoryTheory.Limits.HasCokernel (CategoryTheory.Limits.kernel.ι (F.map f))],
(CategoryTheory.Abelian.PreservesCoimageImageComparison.iso F f).inv.left =
(CategoryTheory.Abelian.PreservesCoimage.iso F f).inv |
CategoryTheory.Idempotents.Karoubi.decompId_i_f | Mathlib.CategoryTheory.Idempotents.Karoubi | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P : CategoryTheory.Idempotents.Karoubi C),
P.decompId_i.f = P.p |
_private.Mathlib.Combinatorics.SimpleGraph.VertexCover.0.SimpleGraph.isVertexCover_empty._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.VertexCover | ∀ {V : Type u} {G : SimpleGraph V}, (G = ⊥) = ∀ (a b : V), ¬G.Adj a b |
CategoryTheory.Limits.yonedaCompLimIsoCocones_inv_app | Mathlib.CategoryTheory.Limits.Types.Yoneda | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
(F : CategoryTheory.Functor J C) (X : C) (a : F.cocones.obj X),
(CategoryTheory.Limits.yonedaCompLimIsoCocones F).inv.app X a =
(CategoryTheory.Limits.Types.limitEquivSections (F.op.comp (CategoryTheory.yoneda.obj X))).symm
((CategoryTheory.Limits.opCompYonedaSectionsEquiv F X).symm a) |
CategoryTheory.ShortComplex.opcyclesMap'_neg | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ : S₁ ⟶ S₂} (h₁ : S₁.RightHomologyData) (h₂ : S₂.RightHomologyData),
CategoryTheory.ShortComplex.opcyclesMap' (-φ) h₁ h₂ = -CategoryTheory.ShortComplex.opcyclesMap' φ h₁ h₂ |
Mathlib.Tactic.Monoidal.Context | Mathlib.Tactic.CategoryTheory.Monoidal.Datatypes | Type |
toModuleCatFromModuleCatLinearEquiv._proof_3 | Mathlib.RingTheory.Morita.Matrix | ∀ (R : Type u_3) {ι : Type u_1} [inst : Ring R] [inst_1 : Fintype ι] [inst_2 : DecidableEq ι]
(M : ModuleCat (Matrix ι ι R)) (j : ι) (x x_1 : ↑M),
(fun i => ⟨Matrix.single j i 1 • (x + x_1), ⋯⟩) =
(fun i => ⟨Matrix.single j i 1 • x, ⋯⟩) + fun i => ⟨Matrix.single j i 1 • x_1, ⋯⟩ |
_private.Lean.Compiler.IR.EmitUtil.0.Lean.IR.CollectUsedDecls.collectFnBody._sparseCasesOn_4 | Lean.Compiler.IR.EmitUtil | {motive_2 : Lean.IR.FnBody → Sort u} →
(t : Lean.IR.FnBody) →
((x : Lean.IR.VarId) →
(ty : Lean.IR.IRType) → (e : Lean.IR.Expr) → (b : Lean.IR.FnBody) → motive_2 (Lean.IR.FnBody.vdecl x ty e b)) →
((j : Lean.IR.JoinPointId) →
(xs : Array Lean.IR.Param) → (v b : Lean.IR.FnBody) → motive_2 (Lean.IR.FnBody.jdecl j xs v b)) →
((tid : Lean.Name) →
(x : Lean.IR.VarId) →
(xType : Lean.IR.IRType) → (cs : Array Lean.IR.Alt) → motive_2 (Lean.IR.FnBody.case tid x xType cs)) →
(Nat.hasNotBit 515 t.ctorIdx → motive_2 t) → motive_2 t |
Nat.EqResult.false.injEq | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | ∀ (p p_1 : Lean.Expr), (Nat.EqResult.false p = Nat.EqResult.false p_1) = (p = p_1) |
Int.add | Init.Data.Int.Basic | ℤ → ℤ → ℤ |
CategoryTheory.GrothendieckTopology.Cover.instInhabited | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} → {J : CategoryTheory.GrothendieckTopology C} → Inhabited (J.Cover X) |
Std.Do.SPred.entails_3._simp_1 | Std.Do.SPred.DerivedLaws | ∀ {σ₁ σ₂ σ₃ : Type u_1} {P Q : Std.Do.SPred [σ₁, σ₂, σ₃]},
(P ⊢ₛ Q) = ∀ (s₁ : σ₁) (s₂ : σ₂) (s₃ : σ₃), (P s₁ s₂ s₃).down → (Q s₁ s₂ s₃).down |
List.forall₂_reverse_iff | Mathlib.Data.List.Forall2 | ∀ {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {l₁ : List α} {l₂ : List β},
List.Forall₂ R l₁.reverse l₂.reverse ↔ List.Forall₂ R l₁ l₂ |
Lean.Elab.Tactic.TacticParsedSnapshot.below | Lean.Elab.Term.TermElabM | {motive_1 : Lean.Elab.Tactic.TacticParsedSnapshot → Sort u} →
{motive_2 : Option (Lean.Language.SnapshotTask Lean.Elab.Tactic.TacticParsedSnapshot) → Sort u} →
{motive_3 : Array (Lean.Language.SnapshotTask Lean.Elab.Tactic.TacticParsedSnapshot) → Sort u} →
{motive_4 : Lean.Language.SnapshotTask Lean.Elab.Tactic.TacticParsedSnapshot → Sort u} →
{motive_5 : List (Lean.Language.SnapshotTask Lean.Elab.Tactic.TacticParsedSnapshot) → Sort u} →
{motive_6 : Task Lean.Elab.Tactic.TacticParsedSnapshot → Sort u} →
Lean.Elab.Tactic.TacticParsedSnapshot → Sort (max 1 u) |
ENat.iSup_add_iSup_of_monotone | Mathlib.Data.ENat.Lattice | ∀ {ι : Type u_4} [inst : Preorder ι] [IsDirectedOrder ι] {f g : ι → ℕ∞},
Monotone f → Monotone g → iSup f + iSup g = ⨆ a, f a + g a |
Aesop.Frontend.Parser.«feature(_)» | Aesop.Frontend.RuleExpr | Lean.ParserDescr |
_private.Mathlib.Analysis.Complex.Conformal.0.isConformalMap_complex_linear._simp_1_4 | Mathlib.Analysis.Complex.Conformal | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False |
Std.ExtTreeSet.get!_min! | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] [inst_1 : Inhabited α],
t ≠ ∅ → t.get! t.min! = t.min! |
Subgroup.subgroupOf_inj._simp_2 | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : Group G] {H₁ H₂ K : Subgroup G}, (H₁.subgroupOf K = H₂.subgroupOf K) = (H₁ ⊓ K = H₂ ⊓ K) |
LinearIsometry.coe_toSpanSingleton | Mathlib.Analysis.Normed.Operator.Basic | ∀ {𝕜 : Type u_1} {E : Type u_4} [inst : SeminormedAddCommGroup E] [inst_1 : NontriviallyNormedField 𝕜]
[inst_2 : NormedSpace 𝕜 E] {v : E} (hv : ‖v‖ = 1),
(LinearIsometry.toSpanSingleton 𝕜 E hv).toLinearMap = LinearMap.toSpanSingleton 𝕜 E v |
HasDerivWithinAt.mono | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜} {s t : Set 𝕜},
HasDerivWithinAt f f' t x → s ⊆ t → HasDerivWithinAt f f' s x |
_private.Mathlib.Order.Interval.Set.Basic.0.Set.instNoMinOrderElemIoc.match_1 | Mathlib.Order.Interval.Set.Basic | ∀ (α : Type u_1) [inst : Preorder α] {x y : α} (motive : ↑(Set.Ioc x y) → Prop) (x_1 : ↑(Set.Ioc x y)),
(∀ (a : α) (ha : a ∈ Set.Ioc x y), motive ⟨a, ha⟩) → motive x_1 |
List.Perm.pairwise_iff | Init.Data.List.Perm | ∀ {α : Type u_1} {R : α → α → Prop},
(∀ {x y : α}, R x y → R y x) → ∀ {l₁ l₂ : List α}, l₁.Perm l₂ → (List.Pairwise R l₁ ↔ List.Pairwise R l₂) |
Set.Ioo.pos | Mathlib.Algebra.Order.Interval.Set.Instances | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] (x : ↑(Set.Ioo 0 1)), 0 < ↑x |
IsFractionRing.algHom_commutes | Mathlib.RingTheory.Localization.FractionRing | ∀ {A : Type u_4} [inst : CommRing A] {B : Type u_6} [inst_1 : CommRing B] [inst_2 : Algebra A B] {K₁ : Type u_8}
{K₂ : Type u_9} [inst_3 : Field K₁] [inst_4 : Field K₂] [inst_5 : Algebra A K₁] [inst_6 : Algebra A K₂]
[IsFractionRing A K₁] {L₁ : Type u_10} {L₂ : Type u_11} [inst_8 : Field L₁] [inst_9 : Field L₂]
[inst_10 : Algebra B L₁] [inst_11 : Algebra B L₂] [inst_12 : Algebra K₁ L₁] [inst_13 : Algebra K₂ L₂]
[inst_14 : Algebra A L₁] [inst_15 : Algebra A L₂] [IsScalarTower A K₁ L₁] [IsScalarTower A K₂ L₂]
[IsScalarTower A B L₁] [IsScalarTower A B L₂] (e : K₁ →ₐ[A] K₂) (f : L₁ →ₐ[B] L₂) (x : K₁),
(algebraMap K₂ L₂) (e x) = f ((algebraMap K₁ L₁) x) |
_private.Lean.Meta.Tactic.FunInd.0.Lean.Tactic.FunInd.M2.branch | Lean.Meta.Tactic.FunInd | {α : Type} → Lean.Tactic.FunInd.M2✝ α → Lean.Tactic.FunInd.M2✝¹ α |
OrderIso.smulRight_symm_apply | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : GroupWithZero α] [inst_1 : Preorder α] [inst_2 : Preorder β]
[inst_3 : MulAction α β] [inst_4 : PosSMulMono α β] [inst_5 : PosSMulReflectLE α β] {a : α} (ha : 0 < a) (b : β),
(RelIso.symm (OrderIso.smulRight ha)) b = a⁻¹ • b |
_private.Mathlib.RingTheory.Ideal.GoingUp.0.Ideal.isMaximal_of_isIntegral_of_isMaximal_comap.match_1_1 | Mathlib.RingTheory.Ideal.GoingUp | ∀ {S : Type u_1} [inst : CommRing S] (I x : Ideal S) (motive : (I ≤ x ∧ ∃ x_1 ∈ x, x_1 ∉ I) → Prop)
(x_1 : I ≤ x ∧ ∃ x_1 ∈ x, x_1 ∉ I),
(∀ (I_le_J : I ≤ x) (x_2 : S) (hxJ : x_2 ∈ x) (hxI : x_2 ∉ I), motive ⋯) → motive x_1 |
MultilinearMap.freeFinsuppEquiv._proof_7 | Mathlib.LinearAlgebra.Multilinear.Finsupp | ∀ {ι' : Type u_1} {R : Type u_2} [inst : CommSemiring R], LinearMap.CompatibleSMul (Π₀ (x : ι'), R) (ι' →₀ R) R R |
Lean.Elab.Term.mkNoImplicitLambdaAnnotation | Lean.Elab.Term.TermElabM | Lean.Expr → Lean.Expr |
MeasureTheory.piContent_eq_measure_pi | Mathlib.Probability.ProductMeasure | ∀ {ι : Type u_1} {X : ι → Type u_2} {mX : (i : ι) → MeasurableSpace (X i)} (μ : (i : ι) → MeasureTheory.Measure (X i))
[hμ : ∀ (i : ι), MeasureTheory.IsProbabilityMeasure (μ i)] [inst : Fintype ι] {s : Set ((i : ι) → X i)},
MeasurableSet s → (MeasureTheory.piContent μ) s = (MeasureTheory.Measure.pi μ) s |
Matrix.transpose_eq_natCast | Mathlib.Data.Matrix.Diagonal | ∀ {n : Type u_3} {α : Type v} [inst : DecidableEq n] [inst_1 : AddMonoidWithOne α] {M : Matrix n n α} {d : ℕ},
M.transpose = ↑d ↔ M = ↑d |
Lean.Elab.Do.ContInfo.toContInfoRef | Lean.Elab.Do.Basic | Lean.Elab.Do.ContInfo → Lean.Elab.Do.ContInfoRef |
Batteries.UnionFind.recOn | Batteries.Data.UnionFind.Basic | {motive : Batteries.UnionFind → Sort u} →
(t : Batteries.UnionFind) →
((arr : Array Batteries.UFNode) →
(parentD_lt : ∀ {i : ℕ}, i < arr.size → Batteries.UnionFind.parentD arr i < arr.size) →
(rankD_lt :
∀ {i : ℕ},
Batteries.UnionFind.parentD arr i ≠ i →
Batteries.UnionFind.rankD arr i < Batteries.UnionFind.rankD arr (Batteries.UnionFind.parentD arr i)) →
motive { arr := arr, parentD_lt := parentD_lt, rankD_lt := rankD_lt }) →
motive t |
derivationOfSectionOfKerSqZero_apply_coe | Mathlib.RingTheory.Smooth.Kaehler | ∀ {R : Type u_1} {P : Type u_2} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : CommRing S]
[inst_3 : Algebra R P] [inst_4 : Algebra R S] (f : P →ₐ[R] S) (hf' : RingHom.ker f ^ 2 = ⊥) (g : S →ₐ[R] P)
(hg : f.comp g = AlgHom.id R S) (x : P), ↑((derivationOfSectionOfKerSqZero f hf' g hg) x) = x - g (f x) |
Finset.coe_zero | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : Zero α], ↑0 = 0 |
«term_≃⋆+*_» | Mathlib.Algebra.Star.StarRingHom | Lean.TrailingParserDescr |
_private.Mathlib.RingTheory.Smooth.IntegralClosure.0.exists_derivative_mul_eq_and_isIntegral_coeff._simp_1_8 | Mathlib.RingTheory.Smooth.IntegralClosure | ∀ {α : Sort u_2} {β : Sort u_1} {f : α → β} {p : α → Prop} {q : β → Prop},
(∀ (b : β) (a : α), p a → f a = b → q b) = ∀ (a : α), p a → q (f a) |
CategoryTheory.CosimplicialObject.augmentOfIsInitial_right | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject C) {T : C}
(hT : CategoryTheory.Limits.IsInitial T), (X.augmentOfIsInitial hT).right = X |
_private.Mathlib.Analysis.CStarAlgebra.Unitary.Connected.0.expUnitary_argSelfAdjoint._simp_1_1 | Mathlib.Analysis.CStarAlgebra.Unitary.Connected | NormedSpace.exp = Complex.exp |
Lean.Parser.instCoeParserParserAliasValue | Lean.Parser.Extension | Coe Lean.Parser.Parser Lean.Parser.ParserAliasValue |
OpenPartialHomeomorph.trans._proof_2 | Mathlib.Topology.OpenPartialHomeomorph.Composition | ∀ {X : Type u_2} {Y : Type u_1} {Z : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] (e : OpenPartialHomeomorph X Y) (e' : OpenPartialHomeomorph Y Z),
(e.symm.restrOpen e'.source ⋯).symm.target = (e'.restrOpen e.target ⋯).source |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.