name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
HasFDerivAt.sub_const | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{f' : E →L[𝕜] F} {x : E} (c : F), HasFDerivAt f f' x → HasFDerivAt (fun x => f x - c) f' x |
Mathlib.Meta.NormNum.isNat_abs_nonneg | Mathlib.Tactic.NormNum.Abs | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : Lattice α] [IsOrderedRing α] {a : α} {na : ℕ},
Mathlib.Meta.NormNum.IsNat a na → Mathlib.Meta.NormNum.IsNat |a| na |
Pi.single_mul_left_apply | Mathlib.Algebra.GroupWithZero.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MulZeroClass (α i)] [inst_1 : DecidableEq ι] (i j : ι) (a : α i)
(f : (i : ι) → α i), Pi.single i (a * f i) j = Pi.single i a j * f j |
AddCommGroupWithOne.toNatCast | Mathlib.Data.Int.Cast.Defs | {R : Type u} → [self : AddCommGroupWithOne R] → NatCast R |
Affine.Simplex.centroid_reindex | Mathlib.LinearAlgebra.AffineSpace.Simplex.Centroid | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {m n : ℕ} (s : Affine.Simplex k P m) (e : Fin (m + 1) ≃ Fin (n + 1)),
(s.reindex e).centroid = s.centroid |
ENNReal.div_lt_top | Mathlib.Data.ENNReal.Inv | ∀ {x y : ENNReal}, x ≠ ⊤ → y ≠ 0 → x / y < ⊤ |
List.length_range | Init.Data.List.Range | ∀ {n : ℕ}, (List.range n).length = n |
Lean.Elab.Do.mkMonadicType | Lean.Elab.Do.Basic | Lean.Expr → Lean.Elab.Do.DoElabM Lean.Expr |
MeasureTheory.integral_union_eq_left_of_forall | Mathlib.MeasureTheory.Integral.Bochner.Set | ∀ {X : Type u_1} {E : Type u_3} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
{s t : Set X} {μ : MeasureTheory.Measure X} {f : X → E},
MeasurableSet t → (∀ x ∈ t, f x = 0) → ∫ (x : X) in s ∪ t, f x ∂μ = ∫ (x : X) in s, f x ∂μ |
ModuleCat.linearOverField._proof_2 | Mathlib.Algebra.Category.ModuleCat.Algebra | ∀ {k : Type u_3} [inst : Field k] {A : Type u_2} [inst_1 : Ring A] [inst_2 : Algebra k A] (X Y Z : ModuleCat A) (r : k)
(f : X ⟶ Y) (g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp (r • f) g = r • CategoryTheory.CategoryStruct.comp f g |
ContDiffWithinAt.sinh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {x : E} {s : Set E}
{n : WithTop ℕ∞}, ContDiffWithinAt ℝ n f s x → ContDiffWithinAt ℝ n (fun x => Real.sinh (f x)) s x |
_private.Init.Data.Vector.Count.0.Vector.count_le_count_map._simp_1_1 | Init.Data.Vector.Count | ∀ {α : Type u_2} [inst : BEq α] [LawfulBEq α] {β : Type u_1} [inst_2 : BEq β] [LawfulBEq β] {xs : Array α} {f : α → β}
{x : α}, (Array.count x xs ≤ Array.count (f x) (Array.map f xs)) = True |
_private.Lean.Meta.Tactic.Grind.Theorems.0.Lean.Meta.Grind.Theorems.mk.noConfusion | Lean.Meta.Tactic.Grind.Theorems | {α : Type} →
{P : Sort u} →
{smap : Lean.PHashMap Lean.Name (List α)} →
{origins erased : Lean.PHashSet Lean.Meta.Grind.Origin} →
{omap : Lean.PHashMap Lean.Meta.Grind.Origin (List α)} →
{smap' : Lean.PHashMap Lean.Name (List α)} →
{origins' erased' : Lean.PHashSet Lean.Meta.Grind.Origin} →
{omap' : Lean.PHashMap Lean.Meta.Grind.Origin (List α)} →
{ smap := smap, origins := origins, erased := erased, omap := omap } =
{ smap := smap', origins := origins', erased := erased', omap := omap' } →
(smap ≍ smap' → origins = origins' → erased = erased' → omap ≍ omap' → P) → P |
CategoryTheory.RigidCategory.ctorIdx | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.MonoidalCategory C} → CategoryTheory.RigidCategory C → ℕ |
Array.all_subtype | Init.Data.Array.Attach | ∀ {α : Type u_1} {stop : ℕ} {p : α → Prop} {xs : Array { x // p x }} {f : { x // p x } → Bool} {g : α → Bool},
(∀ (x : α) (h : p x), f ⟨x, h⟩ = g x) → stop = xs.size → xs.all f 0 stop = xs.unattach.all g |
gcd_comm | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] (a b : α), gcd a b = gcd b a |
BoxIntegral.Box.instPartialOrder._proof_3 | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_1} (a b : BoxIntegral.Box ι), a < b ↔ a ≤ b ∧ ¬b ≤ a |
_private.Std.Data.ExtDHashMap.Lemmas.0.Std.ExtDHashMap.map_eq_empty_iff._simp_1_2 | Std.Data.ExtDHashMap.Lemmas | ∀ {a b : Bool}, (a = true ↔ b = true) = (a = b) |
groupHomology.H0π_comp_H0Iso_hom_assoc | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep k G) {Z : ModuleCat k}
(h : (Rep.coinvariantsFunctor k G).obj A ⟶ Z),
CategoryTheory.CategoryStruct.comp (groupHomology.H0π A)
(CategoryTheory.CategoryStruct.comp (groupHomology.H0Iso A).hom h) =
CategoryTheory.CategoryStruct.comp ((Rep.coinvariantsMk k G).app A) h |
Finsupp.support_indicator_subset | Mathlib.Data.Finsupp.Indicator | ∀ {ι : Type u_1} {α : Type u_2} [inst : Zero α] (s : Finset ι) (f : (i : ι) → i ∈ s → α),
↑(Finsupp.indicator s f).support ⊆ ↑s |
AddSubsemigroup.centerToAddOpposite._proof_4 | Mathlib.GroupTheory.Submonoid.Center | ∀ {M : Type u_1} [inst : Add M] (r : ↥(AddSubsemigroup.center Mᵃᵒᵖ)), AddOpposite.unop ↑r ∈ Set.addCenter M |
Substring.Raw.Valid.data_drop | Batteries.Data.String.Lemmas | ∀ {s : Substring.Raw}, s.Valid → ∀ (n : ℕ), (s.drop n).toString.toList = List.drop n s.toString.toList |
_private.Mathlib.MeasureTheory.Integral.IntervalAverage.0.exists_eq_interval_average_of_noAtoms._proof_1_1 | Mathlib.MeasureTheory.Integral.IntervalAverage | ∀ {a b : ℝ} ⦃x : ℝ⦄, min a b < x → x < max a b → x ∈ Set.uIoc a b |
_private.Mathlib.Algebra.Category.ModuleCat.Semi.0.SemimoduleCat.mk | Mathlib.Algebra.Category.ModuleCat.Semi | {R : Type u} →
[inst : Semiring R] →
(carrier : Type v) → [isAddCommMonoid : AddCommMonoid carrier] → [isModule : Module R carrier] → SemimoduleCat R |
SimplicialObject.Split.rec | Mathlib.AlgebraicTopology.SimplicialObject.Split | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{motive : SimplicialObject.Split C → Sort u} →
((X : CategoryTheory.SimplicialObject C) → (s : SimplicialObject.Splitting X) → motive { X := X, s := s }) →
(t : SimplicialObject.Split C) → motive t |
QuasiconcaveOn.dual | Mathlib.Analysis.Convex.Quasiconvex | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_3} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : LE β] [inst_4 : SMul 𝕜 E] {s : Set E} {f : E → β},
QuasiconcaveOn 𝕜 s f → QuasiconvexOn 𝕜 s (⇑OrderDual.toDual ∘ f) |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order.0.isStrictlyPositive_add._proof_1_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | ∀ {A : Type u_1} [inst : CStarAlgebra A] [inst_1 : PartialOrder A] [StarOrderedRing A] {a b : A},
IsStrictlyPositive a ∧ 0 ≤ b ∨ 0 ≤ a ∧ IsStrictlyPositive b → IsStrictlyPositive (a + b) |
Std.ExtDTreeMap.Const.alter_eq_empty_iff | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{k : α} {f : Option β → Option β},
Std.ExtDTreeMap.Const.alter t k f = ∅ ↔ (t = ∅ ∨ t.size = 1 ∧ k ∈ t) ∧ f (Std.ExtDTreeMap.Const.get? t k) = none |
Lean.Server.FileWorker.WorkerState.mk.injEq | Lean.Server.FileWorker | ∀ (doc : Lean.Server.FileWorker.EditableDocument) (reporterCancelTk : IO.CancelToken)
(importCachingTask? : Option (Lean.Server.ServerTask (Except IO.Error Lean.Server.FileWorker.AvailableImportsCache)))
(pendingRequests : Lean.Server.FileWorker.PendingRequestMap)
(rpcSessions : Std.TreeMap UInt64 (IO.Ref Lean.Server.FileWorker.RpcSession) compare)
(doc_1 : Lean.Server.FileWorker.EditableDocument) (reporterCancelTk_1 : IO.CancelToken)
(importCachingTask?_1 :
Option (Lean.Server.ServerTask (Except IO.Error Lean.Server.FileWorker.AvailableImportsCache)))
(pendingRequests_1 : Lean.Server.FileWorker.PendingRequestMap)
(rpcSessions_1 : Std.TreeMap UInt64 (IO.Ref Lean.Server.FileWorker.RpcSession) compare),
({ doc := doc, reporterCancelTk := reporterCancelTk, importCachingTask? := importCachingTask?,
pendingRequests := pendingRequests, rpcSessions := rpcSessions } =
{ doc := doc_1, reporterCancelTk := reporterCancelTk_1, importCachingTask? := importCachingTask?_1,
pendingRequests := pendingRequests_1, rpcSessions := rpcSessions_1 }) =
(doc = doc_1 ∧
reporterCancelTk = reporterCancelTk_1 ∧
importCachingTask? = importCachingTask?_1 ∧ pendingRequests = pendingRequests_1 ∧ rpcSessions = rpcSessions_1) |
Finset.gcd_congr | Mathlib.Algebra.GCDMonoid.Finset | ∀ {α : Type u_2} {β : Type u_3} [inst : CommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] {s₁ s₂ : Finset β}
{f g : β → α}, s₁ = s₂ → (∀ a ∈ s₂, f a = g a) → s₁.gcd f = s₂.gcd g |
_private.Mathlib.NumberTheory.ModularForms.QExpansion.0.ModularFormClass.qExpansion_coeff_eq_intervalIntegral._simp_1_7 | Mathlib.NumberTheory.ModularForms.QExpansion | (Real.pi = 0) = False |
Std.TreeMap.getKeyD_insert_self | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {a fallback : α}
{b : β}, (t.insert a b).getKeyD a fallback = a |
List.length_mapFinIdx | Init.Data.List.MapIdx | ∀ {α : Type u_1} {β : Type u_2} {as : List α} {f : (i : ℕ) → α → i < as.length → β}, (as.mapFinIdx f).length = as.length |
Subalgebra.normedCommRing._proof_1 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {𝕜 : Type u_2} [inst : CommRing 𝕜] {E : Type u_1} [inst_1 : NormedCommRing E] [inst_2 : Algebra 𝕜 E]
(s : Subalgebra 𝕜 E) {x y : ↥s}, dist x y = 0 → x = y |
RelSeries.head_fromListIsChain | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} (l : List α) (l_ne_nil : l ≠ []) (hl : List.IsChain (fun x1 x2 => (x1, x2) ∈ r) l),
(RelSeries.fromListIsChain l l_ne_nil hl).head = l.head l_ne_nil |
_private.Mathlib.Tactic.Hint.0.Mathlib.Tactic.Hint._aux_Mathlib_Tactic_Hint___elabRules_Mathlib_Tactic_Hint_registerHintStx_1._sparseCasesOn_1 | Mathlib.Tactic.Hint | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
_private.Mathlib.Data.Seq.Basic.0.Stream'.Seq.take.match_1.splitter | Mathlib.Data.Seq.Basic | {α : Type u_1} →
(motive : ℕ → Stream'.Seq α → Sort u_2) →
(x : ℕ) →
(x_1 : Stream'.Seq α) →
((x : Stream'.Seq α) → motive 0 x) → ((n : ℕ) → (s : Stream'.Seq α) → motive n.succ s) → motive x x_1 |
ExteriorAlgebra.ι_inj._simp_1 | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | ∀ (R : Type u1) [inst : CommRing R] {M : Type u2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] (x y : M),
((ExteriorAlgebra.ι R) x = (ExteriorAlgebra.ι R) y) = (x = y) |
CategoryTheory.NatTrans.leftOpWhiskerRight_assoc | Mathlib.CategoryTheory.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor C Dᵒᵖ} {E : Type u_1} [inst_2 : CategoryTheory.Category.{v_1, u_1} E]
{H : CategoryTheory.Functor E C} (α : F ⟶ G) {Z : CategoryTheory.Functor Eᵒᵖ D} (h : (H.comp F).leftOp ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.NatTrans.leftOp (H.whiskerLeft α)) h =
CategoryTheory.CategoryStruct.comp (H.leftOpComp G).hom
(CategoryTheory.CategoryStruct.comp (H.op.whiskerLeft (CategoryTheory.NatTrans.leftOp α))
(CategoryTheory.CategoryStruct.comp (H.leftOpComp F).inv h)) |
edist_nndist | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] (x y : α), edist x y = ↑(nndist x y) |
linearOrderOfSTO._proof_1 | Mathlib.Order.RelClasses | ∀ {α : Type u_1} (r : α → α → Prop) [IsStrictTotalOrder α r] (x y : α), ¬r y x ↔ x = y ∨ r x y |
Lean.Expr.proj.elim | Lean.Expr | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
t.ctorIdx = 11 →
((typeName : Lean.Name) → (idx : ℕ) → (struct : Lean.Expr) → motive (Lean.Expr.proj typeName idx struct)) →
motive t |
CategoryTheory.PreZeroHypercoverFamily._sizeOf_inst | Mathlib.CategoryTheory.Sites.Hypercover.ZeroFamily | (C : Type u) →
{inst : CategoryTheory.Category.{v, u} C} → [SizeOf C] → SizeOf (CategoryTheory.PreZeroHypercoverFamily C) |
Lean.Lsp.InitializationOptions.ctorIdx | Lean.Data.Lsp.InitShutdown | Lean.Lsp.InitializationOptions → ℕ |
instDecidableIrrationalSqrtOfNatReal | Mathlib.NumberTheory.Real.Irrational | {n : ℕ} → [inst : n.AtLeastTwo] → Decidable (Irrational √(OfNat.ofNat n)) |
ZeroAtInftyContinuousMap.rec | Mathlib.Topology.ContinuousMap.ZeroAtInfty | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] →
[inst_1 : Zero β] →
[inst_2 : TopologicalSpace β] →
{motive : ZeroAtInftyContinuousMap α β → Sort u_1} →
((toContinuousMap : C(α, β)) →
(zero_at_infty' : Filter.Tendsto toContinuousMap.toFun (Filter.cocompact α) (nhds 0)) →
motive { toContinuousMap := toContinuousMap, zero_at_infty' := zero_at_infty' }) →
(t : ZeroAtInftyContinuousMap α β) → motive t |
Submonoid.closure_insert_one | Mathlib.Algebra.Group.Submonoid.Basic | ∀ {M : Type u_1} [inst : MulOneClass M] (s : Set M), Submonoid.closure (insert 1 s) = Submonoid.closure s |
Std.DHashMap.Const.size_le_size_insertMany_list | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] {l : List (α × β)}, m.size ≤ (Std.DHashMap.Const.insertMany m l).size |
AdjoinRoot.instCommRing | Mathlib.RingTheory.AdjoinRoot | {R : Type u_1} → [inst : CommRing R] → (f : Polynomial R) → CommRing (AdjoinRoot f) |
MeasurableSet.image_of_measurable_injOn | Mathlib.MeasureTheory.Constructions.Polish.Basic | ∀ {γ : Type u_3} {α : Type u_4} [inst : MeasurableSpace α] {s : Set γ} {f : γ → α}
[MeasurableSpace.CountablySeparated α] [inst_2 : MeasurableSpace γ] [StandardBorelSpace γ],
MeasurableSet s → Measurable f → Set.InjOn f s → MeasurableSet (f '' s) |
RelEmbedding.recOn | Mathlib.Order.RelIso.Basic | {α : Type u_5} →
{β : Type u_6} →
{r : α → α → Prop} →
{s : β → β → Prop} →
{motive : r ↪r s → Sort u} →
(t : r ↪r s) →
((toEmbedding : α ↪ β) →
(map_rel_iff' : ∀ {a b : α}, s (toEmbedding a) (toEmbedding b) ↔ r a b) →
motive { toEmbedding := toEmbedding, map_rel_iff' := map_rel_iff' }) →
motive t |
CategoryTheory.Limits.WidePullbackShape.Hom.id.elim | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | {J : Type w} →
{motive : (a a_1 : CategoryTheory.Limits.WidePullbackShape J) → a.Hom a_1 → Sort u} →
{a a_1 : CategoryTheory.Limits.WidePullbackShape J} →
(t : a.Hom a_1) →
t.ctorIdx = 0 →
((X : CategoryTheory.Limits.WidePullbackShape J) →
motive X X (CategoryTheory.Limits.WidePullbackShape.Hom.id X)) →
motive a a_1 t |
Set.smul_set_univ | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Group α] [inst_1 : MulAction α β] {a : α}, a • Set.univ = Set.univ |
UInt16.reduceLT | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | Lean.Meta.Simp.Simproc |
DilationEquiv.symm_bijective | Mathlib.Topology.MetricSpace.DilationEquiv | ∀ {X : Type u_1} {Y : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : PseudoEMetricSpace Y],
Function.Bijective DilationEquiv.symm |
Valuation.HasExtension.instIsLocalHomValuationInteger | Mathlib.RingTheory.Valuation.Extension | ∀ {R : Type u_1} [inst : CommRing R] {ΓR : Type u_6} [inst_1 : LinearOrderedCommGroupWithZero ΓR] {vR : Valuation R ΓR}
{S : Type u_9} {ΓS : Type u_10} [inst_2 : CommRing S] [inst_3 : LinearOrderedCommGroupWithZero ΓS]
[inst_4 : Algebra R S] [IsLocalHom (algebraMap R S)] {vS : Valuation S ΓS} [inst_6 : vR.HasExtension vS],
IsLocalHom (algebraMap ↥vR.integer ↥vS.integer) |
Vector.instOrientedCmpCompareLex | Init.Data.Ord.Vector | ∀ {α : Type u_1} {cmp : α → α → Ordering} [Std.OrientedCmp cmp] {n : ℕ}, Std.OrientedCmp (Vector.compareLex cmp) |
DFinsupp.instDFunLike | Mathlib.Data.DFinsupp.Defs | {ι : Type u} → {β : ι → Type v} → [inst : (i : ι) → Zero (β i)] → DFunLike (Π₀ (i : ι), β i) ι β |
Mathlib.Meta.FunProp.Mor.Arg.noConfusionType | Mathlib.Tactic.FunProp.Mor | Sort u → Mathlib.Meta.FunProp.Mor.Arg → Mathlib.Meta.FunProp.Mor.Arg → Sort u |
SimpleGraph.isMaximalIndepSet_compl._simp_1 | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_3} {G : SimpleGraph α} (s : Finset α), Maximal Gᶜ.IsIndepSet ↑s = Maximal G.IsClique ↑s |
Std.Format.group.injEq | Init.Data.Format.Basic | ∀ (a : Std.Format) (behavior : Std.Format.FlattenBehavior) (a_1 : Std.Format) (behavior_1 : Std.Format.FlattenBehavior),
(a.group behavior = a_1.group behavior_1) = (a = a_1 ∧ behavior = behavior_1) |
RingQuot.instRing._proof_8 | Mathlib.Algebra.RingQuot | ∀ {R : Type u_1} [inst : Ring R] (r : R → R → Prop) (n : ℕ),
{ toQuot := Quot.mk (RingQuot.Rel r) ↑↑n } = { toQuot := Quot.mk (RingQuot.Rel r) ↑n } |
Sym2.rec.match_1 | Mathlib.Data.Sym.Sym2 | {α : Type u_1} → (motive : α × α → Sort u_2) → (x : α × α) → ((a b : α) → motive (a, b)) → motive x |
AlgebraicGeometry.isSmooth_isStableUnderBaseChange | Mathlib.AlgebraicGeometry.Morphisms.Smooth | CategoryTheory.MorphismProperty.IsStableUnderBaseChange @AlgebraicGeometry.Smooth |
_private.Mathlib.Algebra.Homology.Localization.0.HomotopyCategory.quotient_map_mem_quasiIso_iff._simp_1_1 | Mathlib.Algebra.Homology.Localization | ∀ {ι : Type u_1} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {c : ComplexShape ι} {K L : HomologicalComplex C c}
[inst_2 : CategoryTheory.CategoryWithHomology C] (f : K ⟶ L), HomologicalComplex.quasiIso C c f = QuasiIso f |
ByteArray.forIn.loop._proof_4 | Init.Data.ByteArray.Basic | ∀ (as : ByteArray), ∀ i < as.size, i ≤ as.size |
AddMonoidAlgebra.opRingEquiv_symm_single | Mathlib.Algebra.MonoidAlgebra.Opposite | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : Add M] (r : Rᵐᵒᵖ) (x : Mᵃᵒᵖ),
AddMonoidAlgebra.opRingEquiv.symm (AddMonoidAlgebra.single x r) =
MulOpposite.op (AddMonoidAlgebra.single (AddOpposite.unop x) (MulOpposite.unop r)) |
CategoryTheory.Functor.mapHomologicalComplexIdIso._proof_2 | Mathlib.Algebra.Homology.Additive | ∀ {ι : Type u_1} (W₁ : Type u_3) [inst : CategoryTheory.Category.{u_2, u_3} W₁]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms W₁] (c : ComplexShape ι) (K : HomologicalComplex W₁ c) (i j : ι),
c.Rel i j →
CategoryTheory.CategoryStruct.comp
((fun x => CategoryTheory.Iso.refl ((((CategoryTheory.Functor.id W₁).mapHomologicalComplex c).obj K).X x))
i).hom
(((CategoryTheory.Functor.id (HomologicalComplex W₁ c)).obj K).d i j) =
CategoryTheory.CategoryStruct.comp ((((CategoryTheory.Functor.id W₁).mapHomologicalComplex c).obj K).d i j)
((fun x => CategoryTheory.Iso.refl ((((CategoryTheory.Functor.id W₁).mapHomologicalComplex c).obj K).X x))
j).hom |
cfcₙ.congr_simp | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | ∀ {R : Type u_3} {A : Type u_4} {p p_1 : A → Prop} (e_p : p = p_1) [inst : CommSemiring R] [inst_1 : Nontrivial R]
[inst_2 : StarRing R] [inst_3 : MetricSpace R] [inst_4 : IsTopologicalSemiring R] [inst_5 : ContinuousStar R]
[inst_6 : NonUnitalRing A] [inst_7 : StarRing A] [inst_8 : TopologicalSpace A] [inst_9 : Module R A]
[inst_10 : IsScalarTower R A A] [inst_11 : SMulCommClass R A A]
[instCFCₙ : NonUnitalContinuousFunctionalCalculus R A p] (f f_1 : R → R),
f = f_1 → ∀ (a a_1 : A), a = a_1 → cfcₙ f a = cfcₙ f_1 a_1 |
Matrix.specialOrthogonalGroup | Mathlib.LinearAlgebra.UnitaryGroup | (n : Type u) →
[inst : DecidableEq n] → [inst_1 : Fintype n] → (R : Type v) → [inst_2 : CommRing R] → Submonoid (Matrix n n R) |
Equiv.mulOneClass | Mathlib.Algebra.Group.TransferInstance | {α : Type u_2} → {β : Type u_3} → α ≃ β → [MulOneClass β] → MulOneClass α |
_private.Mathlib.Combinatorics.Matroid.Map.0.Matroid.mapSetEmbedding._simp_1 | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u} {s : Set α}, (s ⊆ ∅) = (s = ∅) |
IsCyclotomicExtension.Rat.galEquivZMod.eq_1 | Mathlib.NumberTheory.NumberField.Cyclotomic.Galois | ∀ (n : ℕ) [inst : NeZero n] (K : Type u_1) [inst_1 : Field K] [inst_2 : NumberField K]
[hK : IsCyclotomicExtension {n} ℚ K],
IsCyclotomicExtension.Rat.galEquivZMod n K = IsCyclotomicExtension.autEquivPow K ⋯ |
_private.Mathlib.Data.List.Sort.0.List.erase_orderedInsert_of_notMem._proof_1_1 | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {r : α → α → Prop} [inst : DecidableRel r] [inst_1 : DecidableEq α] {x : α},
(List.orderedInsert r x []).erase x = [] |
_private.Mathlib.RingTheory.Ideal.MinimalPrime.Basic.0.Ideal.map_sup_mem_minimalPrimes_of_map_quotientMk_mem_minimalPrimes.match_1_1 | Mathlib.RingTheory.Ideal.MinimalPrime.Basic | ∀ {R : Type u_2} [inst : CommSemiring R] {S : Type u_1} [inst_1 : CommRing S] [inst_2 : Algebra R S] {I : Ideal R}
{J : Ideal S} (q : Ideal S) (motive : q.IsPrime ∧ Ideal.map (algebraMap R S) I ⊔ J ≤ q → Prop)
(x : q.IsPrime ∧ Ideal.map (algebraMap R S) I ⊔ J ≤ q),
(∀ (left : q.IsPrime) (hleq : Ideal.map (algebraMap R S) I ⊔ J ≤ q), motive ⋯) → motive x |
Module.Basis.toMatrix_smul | Mathlib.LinearAlgebra.Matrix.Basis | ∀ {ι : Type u_1} {R₁ : Type u_9} {S : Type u_10} [inst : CommSemiring R₁] [inst_1 : Semiring S] [inst_2 : Algebra R₁ S]
[inst_3 : Fintype ι] [inst_4 : DecidableEq ι] (x : S) (b : Module.Basis ι R₁ S) (w : ι → S),
b.toMatrix (x • w) = (Algebra.leftMulMatrix b) x * b.toMatrix w |
ENNReal.ofReal_essSup | Mathlib.MeasureTheory.Function.EssSup | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ℝ},
Filter.IsCoboundedUnder (fun x1 x2 => x1 ≤ x2) (MeasureTheory.ae μ) f →
Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) (MeasureTheory.ae μ) f →
ENNReal.ofReal (essSup f μ) = essSup (fun a => ENNReal.ofReal (f a)) μ |
_private.Mathlib.RingTheory.LocalRing.ResidueField.Ideal.0.instIsFractionRingQuotientIdealResidueField._simp_3 | Mathlib.RingTheory.LocalRing.ResidueField.Ideal | ∀ {R : Type u} [inst : Ring R] {I : Ideal R} [inst_1 : I.IsTwoSided] (x y : R),
(x - y ∈ I) = ((Ideal.Quotient.mk I) x = (Ideal.Quotient.mk I) y) |
HomotopyEquiv.toHomologyIso._proof_1 | Mathlib.Algebra.Homology.Homotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_3}
{c : ComplexShape ι} {K L : HomologicalComplex C c} (h : HomotopyEquiv K L) (i : ι) [inst_2 : K.HasHomology i]
[inst_3 : L.HasHomology i],
CategoryTheory.CategoryStruct.comp (HomologicalComplex.homologyMap h.hom i) (HomologicalComplex.homologyMap h.inv i) =
CategoryTheory.CategoryStruct.id (K.homology i) |
IsOpen.is_const_of_deriv_eq_zero | Mathlib.Analysis.Calculus.MeanValue | ∀ {𝕜 : Type u_3} {G : Type u_4} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup G] [inst_2 : NormedSpace 𝕜 G] {f : 𝕜 → G}
{s : Set 𝕜},
IsOpen s → IsPreconnected s → DifferentiableOn 𝕜 f s → Set.EqOn (deriv f) 0 s → ∀ {x y : 𝕜}, x ∈ s → y ∈ s → f x = f y |
Std.IterM.fold_filterMapM | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β γ δ : Type w} {m : Type w → Type w'} {n : Type w → Type w''} [inst : Std.Iterator α m β]
[Std.Iterators.Finite α m] [inst_2 : Monad m] [LawfulMonad m] [inst_4 : Monad n] [inst_5 : MonadAttach n]
[LawfulMonad n] [WeaklyLawfulMonadAttach n] [inst_8 : Std.IteratorLoop α m n] [Std.LawfulIteratorLoop α m n]
[inst_10 : MonadLiftT m n] [LawfulMonadLiftT m n] {f : β → n (Option γ)} {g : δ → γ → δ} {init : δ}
{it : Std.IterM m β},
Std.IterM.fold g init (Std.IterM.filterMapM f it) =
Std.IterM.foldM
(fun d b => do
let __discr ← f b
match __discr with
| some c => pure (g d c)
| x => pure d)
init it |
CategoryTheory.PreGaloisCategory.PointedGaloisObject.Hom.mk | Mathlib.CategoryTheory.Galois.Prorepresentability | {C : Type u₁} →
[inst : CategoryTheory.Category.{u₂, u₁} C] →
[inst_1 : CategoryTheory.GaloisCategory C] →
{F : CategoryTheory.Functor C FintypeCat} →
{A B : CategoryTheory.PreGaloisCategory.PointedGaloisObject F} →
(val : A.obj ⟶ B.obj) →
autoParam ((CategoryTheory.ConcreteCategory.hom (F.map val)) A.pt = B.pt)
CategoryTheory.PreGaloisCategory.PointedGaloisObject.Hom.comp._autoParam →
A.Hom B |
Std.DTreeMap.Internal.Impl.getKeyLE?.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] (k : α),
Std.DTreeMap.Internal.Impl.getKeyLE? k = Std.DTreeMap.Internal.Impl.getKeyLE?.go k none |
MulAction.stabilizer_smul_eq_right | Mathlib.GroupTheory.GroupAction.Defs | ∀ {G : Type u_1} {β : Type u_3} [inst : Group G] [inst_1 : MulAction G β] {α : Type u_4} [inst_2 : Group α]
[inst_3 : MulAction α β] [SMulCommClass G α β] (a : α) (b : β),
MulAction.stabilizer G (a • b) = MulAction.stabilizer G b |
map_eq_zero._simp_1 | Mathlib.Algebra.GroupWithZero.Units.Lemmas | ∀ {G₀ : Type u_3} {M₀' : Type u_4} {F : Type u_6} [inst : GroupWithZero G₀] [inst_1 : MulZeroOneClass M₀']
[Nontrivial M₀'] [inst_3 : FunLike F G₀ M₀'] [MonoidWithZeroHomClass F G₀ M₀'] (f : F) {a : G₀}, (f a = 0) = (a = 0) |
Std.Internal.IO.Async.System.OSInfo.mk.inj | Std.Internal.Async.System | ∀ {name release version machine name_1 release_1 version_1 machine_1 : String},
{ name := name, release := release, version := version, machine := machine } =
{ name := name_1, release := release_1, version := version_1, machine := machine_1 } →
name = name_1 ∧ release = release_1 ∧ version = version_1 ∧ machine = machine_1 |
Lean.Expr.NumApps.State.counters | Lean.Util.NumApps | Lean.Expr.NumApps.State → Lean.NameMap ℕ |
_private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnModule.smul_add._simp_1_1 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {α : Type u_2} [inst : Preorder α] {s t : Set α}, (s ∪ t).IsPWO = (s.IsPWO ∧ t.IsPWO) |
NumberField.IsCMField.isConj_complexConj | 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] (φ : K →+* ℂ),
NumberField.ComplexEmbedding.IsConj φ (NumberField.IsCMField.complexConj K) |
Nat.nth_add_one | Mathlib.Data.Nat.Nth | ∀ {p : ℕ → Prop} {n : ℕ}, ¬p 0 → Nat.nth p n ≠ 0 → Nat.nth (fun i => p (i + 1)) n + 1 = Nat.nth p n |
_private.Mathlib.Combinatorics.SimpleGraph.Bipartite.0.SimpleGraph.completeBipartiteGraph_isContained_iff.match_1_7 | Mathlib.Combinatorics.SimpleGraph.Bipartite | ∀ {V : Type u_2} {G : SimpleGraph V} {α : Type u_3} {β : Type u_1} [inst : Fintype β]
(f : (completeBipartiteGraph α β).Copy G) (x : V)
(motive : (∃ a ∈ Finset.univ, { toFun := ⇑f ∘ Sum.inr, inj' := ⋯ } a = x) → Prop)
(hr : ∃ a ∈ Finset.univ, { toFun := ⇑f ∘ Sum.inr, inj' := ⋯ } a = x),
(∀ (w : β) (left : w ∈ Finset.univ) (hr : { toFun := ⇑f ∘ Sum.inr, inj' := ⋯ } w = x), motive ⋯) → motive hr |
CategoryTheory.ComposableArrows.fourδ₁Toδ₀._proof_2 | Mathlib.CategoryTheory.ComposableArrows.Four | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {i₀ i₁ i₂ i₃ i₄ : C} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂)
(f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₁₂ : i₀ ⟶ i₂),
CategoryTheory.CategoryStruct.comp f₁ f₂ = f₁₂ →
CategoryTheory.CategoryStruct.comp
((CategoryTheory.ComposableArrows.mk₃ f₁₂ f₃ f₄).map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4
_proof_290✝)
(CategoryTheory.CategoryStruct.id ((CategoryTheory.ComposableArrows.mk₃ f₁₂ f₃ f₄).obj' 1 _proof_290✝¹)) =
CategoryTheory.CategoryStruct.comp f₁
((CategoryTheory.ComposableArrows.mk₃ f₂ f₃ f₄).map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4
_proof_290✝²) |
CategoryTheory.Pseudofunctor.CoGrothendieck.noConfusion | Mathlib.CategoryTheory.Bicategory.Grothendieck | {P : Sort u} →
{𝒮 : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} 𝒮} →
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮ᵒᵖ) CategoryTheory.Cat} →
{t : F.CoGrothendieck} →
{𝒮' : Type u₁} →
{inst' : CategoryTheory.Category.{v₁, u₁} 𝒮'} →
{F' : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮'ᵒᵖ) CategoryTheory.Cat} →
{t' : F'.CoGrothendieck} →
𝒮 = 𝒮' →
inst ≍ inst' → F ≍ F' → t ≍ t' → CategoryTheory.Pseudofunctor.CoGrothendieck.noConfusionType P t t' |
CochainComplex.HomComplex.CohomologyClass.toSmallShiftedHom | Mathlib.Algebra.Homology.DerivedCategory.SmallShiftedHom | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
{K L : CochainComplex C ℤ} →
{n : ℤ} →
[inst_2 :
CategoryTheory.Localization.HasSmallLocalizedShiftedHom
(HomologicalComplex.quasiIso C (ComplexShape.up ℤ)) ℤ K L] →
CochainComplex.HomComplex.CohomologyClass K L n →
CategoryTheory.Localization.SmallShiftedHom (HomologicalComplex.quasiIso C (ComplexShape.up ℤ)) K L n |
Function.Surjective.involutiveNeg._proof_1 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_2} {M₂ : Type u_1} [inst : Neg M₂] [inst_1 : InvolutiveNeg M₁] (f : M₁ → M₂),
(∀ (x : M₁), f (-x) = -f x) → ∀ (x : M₁), - -f x = f x |
_private.Init.Data.Array.Find.0.Array.getElem?_zero_flatten._simp_1_1 | Init.Data.Array.Find | ∀ {α : Type u_1} {l : List α}, l[0]? = l.head? |
Std.DTreeMap.Raw.Equiv.forIn_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} {δ : Type w}
{m : Type w → Type w'} [Std.TransCmp cmp] [inst : Monad m] [LawfulMonad m] {b : δ}
{f : (a : α) × β a → δ → m (ForInStep δ)}, t₁.WF → t₂.WF → t₁.Equiv t₂ → forIn t₁ b f = forIn t₂ b f |
Subgroup.mulSingle_mem_pi._simp_2 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {η : Type u_7} {f : η → Type u_8} [inst : (i : η) → Group (f i)] [inst_1 : DecidableEq η] {I : Set η}
{H : (i : η) → Subgroup (f i)} (i : η) (x : f i), (Pi.mulSingle i x ∈ Subgroup.pi I H) = (i ∈ I → x ∈ H i) |
_private.Mathlib.Algebra.Homology.DerivedCategory.TStructure.0.DerivedCategory.TStructure.t._proof_12 | Mathlib.Algebra.Homology.DerivedCategory.TStructure | (ComplexShape.embeddingUpIntLE 0).IsTruncLE |
_private.Init.Omega.Int.0.Lean.Omega.Fin.ne_iff_lt_or_gt._simp_1_1 | Init.Omega.Int | ∀ {a b : ℕ}, (a ≠ b) = (a < b ∨ b < a) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.