name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
AddEquiv.isSimpleAddGroup | Mathlib.GroupTheory.Subgroup.Simple | ∀ {G : Type u_1} [inst : AddGroup G] {H : Type u_3} [inst_1 : AddGroup H] [IsSimpleAddGroup H] (e : G ≃+ H),
IsSimpleAddGroup G |
CategoryTheory.Limits.WidePullbackShape.equivalenceOfEquiv._proof_6 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type u_2} (J' : Type u_1) (h : J ≃ J') (val : J'),
((CategoryTheory.Limits.WidePullbackShape.wideCospan none (fun j => some (h.invFun j)) fun j =>
CategoryTheory.Limits.WidePullbackShape.Hom.term (h.invFun j)).comp
(CategoryTheory.Limits.WidePullbackShape.wideCospan none (fun j => some (h j)) fun j =>
CategoryTheory.Limits.WidePullbackShape.Hom.term (h j))).obj
(some val) =
(CategoryTheory.Functor.id (CategoryTheory.Limits.WidePullbackShape J')).obj (some val) |
WithTop.orderIsoSumLexPUnit_toLex | Mathlib.Data.Sum.Order | ∀ {α : Type u_1} [inst : LE α] (a : α), WithTop.orderIsoSumLexPUnit ↑a = toLex (Sum.inl a) |
_private.Std.Data.DHashMap.Internal.Model.0.Std.DHashMap.Internal.Raw₀.Const.insertListₘ.match_1.eq_1 | Std.Data.DHashMap.Internal.Model | ∀ {α : Type u_2} {β : Type u_1} (motive : List (α × β) → Sort u_3) (h_1 : Unit → motive [])
(h_2 : (hd : α × β) → (tl : List (α × β)) → motive (hd :: tl)),
(match [] with
| [] => h_1 ()
| hd :: tl => h_2 hd tl) =
h_1 () |
BitVec.rotateRight | Init.Data.BitVec.Basic | {w : ℕ} → BitVec w → ℕ → BitVec w |
nhdsSet | Mathlib.Topology.Defs.Filter | {X : Type u_1} → [TopologicalSpace X] → Set X → Filter X |
Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.cooper₂.injEq | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (c c_1 : Lean.Meta.Grind.Arith.Cutsat.CooperSplit),
(Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.cooper₂ c = Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.cooper₂ c_1) =
(c = c_1) |
Lean.Meta.KExprMap.insert | Lean.Meta.KExprMap | {α : Type} → Lean.Meta.KExprMap α → Lean.Expr → α → Lean.MetaM (Lean.Meta.KExprMap α) |
CharTwo.sum_sq | Mathlib.Algebra.CharP.Two | ∀ {R : Type u_1} {ι : Type u_2} [inst : CommSemiring R] [CharP R 2] (s : Finset ι) (f : ι → R),
(∑ i ∈ s, f i) ^ 2 = ∑ i ∈ s, f i ^ 2 |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.ediv_lt_ediv_iff_of_dvd_of_pos_of_neg._simp_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, a < b → (a = b) = False |
Std.Do._aux_Std_Do_PostCond___unexpand_Std_Do_ExceptConds_imp_1 | Std.Do.PostCond | Lean.PrettyPrinter.Unexpander |
HasFibers.Fib.isoMk._proof_1 | Mathlib.CategoryTheory.FiberedCategory.HasFibers | ∀ {𝒮 : Type u_1} {𝒳 : Type u_3} [inst : CategoryTheory.Category.{u_4, u_1} 𝒮]
[inst_1 : CategoryTheory.Category.{u_2, u_3} 𝒳] {p : CategoryTheory.Functor 𝒳 𝒮} [inst_2 : HasFibers p] {S : 𝒮}
{a b : HasFibers.Fib p S} (Φ : (HasFibers.ι S).obj a ≅ (HasFibers.ι S).obj b),
p.IsHomLift (CategoryTheory.CategoryStruct.id S) Φ.hom → p.IsHomLift (CategoryTheory.CategoryStruct.id S) Φ.inv |
Lean.Core.mkFreshUserName | Lean.CoreM | Lean.Name → Lean.CoreM Lean.Name |
CategoryTheory.PreZeroHypercover.inv_inv_h₀_comp_f | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E F : CategoryTheory.PreZeroHypercover S} (e : E ≅ F)
(i : F.I₀), CategoryTheory.CategoryStruct.comp (CategoryTheory.inv (e.inv.h₀ i)) (F.f i) = E.f (e.inv.s₀ i) |
_private.Lean.Compiler.MetaAttr.0.Lean.declMetaExt._sparseCasesOn_1 | Lean.Compiler.MetaAttr | {motive : Lean.OLeanLevel → Sort u} →
(t : Lean.OLeanLevel) → motive Lean.OLeanLevel.private → (Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t |
IsLocalization.algEquivOfAlgEquiv._proof_4 | Mathlib.RingTheory.Localization.Basic | ∀ {A : Type u_5} [inst : CommSemiring A] {R : Type u_3} [inst_1 : CommSemiring R] [inst_2 : Algebra A R]
{M : Submonoid R} (S : Type u_2) [inst_3 : CommSemiring S] [inst_4 : Algebra R S] [inst_5 : IsLocalization M S]
{P : Type u_4} [inst_6 : CommSemiring P] [inst_7 : Algebra A P] {T : Submonoid P} (Q : Type u_1)
[inst_8 : CommSemiring Q] [inst_9 : Algebra P Q] [inst_10 : IsLocalization T Q] (h : R ≃ₐ[A] P)
(H : Submonoid.map h M = T) (x y : S),
(IsLocalization.ringEquivOfRingEquiv S Q h.toRingEquiv H).toFun (x + y) =
(IsLocalization.ringEquivOfRingEquiv S Q h.toRingEquiv H).toFun x +
(IsLocalization.ringEquivOfRingEquiv S Q h.toRingEquiv H).toFun y |
LinearPMap.HasCore.recOn | Mathlib.Topology.Algebra.Module.LinearPMap | {R : Type u_1} →
{E : Type u_2} →
{F : Type u_3} →
[inst : CommRing R] →
[inst_1 : AddCommGroup E] →
[inst_2 : AddCommGroup F] →
[inst_3 : Module R E] →
[inst_4 : Module R F] →
[inst_5 : TopologicalSpace E] →
[inst_6 : TopologicalSpace F] →
[inst_7 : ContinuousAdd E] →
[inst_8 : ContinuousAdd F] →
[inst_9 : TopologicalSpace R] →
[inst_10 : ContinuousSMul R E] →
[inst_11 : ContinuousSMul R F] →
{f : E →ₗ.[R] F} →
{S : Submodule R E} →
{motive : f.HasCore S → Sort u} →
(t : f.HasCore S) →
((le_domain : S ≤ f.domain) →
(closure_eq : (f.domRestrict S).closure = f) → motive ⋯) →
motive t |
AlexDisc._sizeOf_inst | Mathlib.Topology.Order.Category.AlexDisc | SizeOf AlexDisc |
CategoryTheory.HasLiftingProperty.transfiniteComposition.SqStruct | Mathlib.CategoryTheory.SmallObject.TransfiniteCompositionLifting | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : LinearOrder J] →
[inst_2 : OrderBot J] →
{F : CategoryTheory.Functor J C} →
(c : CategoryTheory.Limits.Cocone F) → {X Y : C} → (X ⟶ Y) → (F.obj ⊥ ⟶ X) → (c.pt ⟶ Y) → J → Type v |
NONote.instMul._proof_1 | Mathlib.SetTheory.Ordinal.Notation | ∀ (x y : NONote), (↑x * ↑y).NF |
String.Pos.toSlice_lt_toSlice_iff | Init.Data.String.Basic | ∀ {s : String} {p q : s.Pos}, p.toSlice < q.toSlice ↔ p < q |
_private.Mathlib.Algebra.Module.ZLattice.Basic.0.ZLattice.comap_equiv._simp_6 | Mathlib.Algebra.Module.ZLattice.Basic | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) |
Diffeomorph.prodCongr_symm | Mathlib.Geometry.Manifold.Diffeomorph | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {E' : Type u_3} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E'] {F : Type u_4}
[inst_5 : NormedAddCommGroup F] [inst_6 : NormedSpace 𝕜 F] {H : Type u_5} [inst_7 : TopologicalSpace H]
{H' : Type u_6} [inst_8 : TopologicalSpace H'] {G : Type u_7} [inst_9 : TopologicalSpace G] {G' : Type u_8}
[inst_10 : TopologicalSpace G'] {I : ModelWithCorners 𝕜 E H} {I' : ModelWithCorners 𝕜 E' H'}
{J : ModelWithCorners 𝕜 F G} {J' : ModelWithCorners 𝕜 F G'} {M : Type u_9} [inst_11 : TopologicalSpace M]
[inst_12 : ChartedSpace H M] {M' : Type u_10} [inst_13 : TopologicalSpace M'] [inst_14 : ChartedSpace H' M']
{N : Type u_11} [inst_15 : TopologicalSpace N] [inst_16 : ChartedSpace G N] {N' : Type u_12}
[inst_17 : TopologicalSpace N'] [inst_18 : ChartedSpace G' N'] {n : WithTop ℕ∞} (h₁ : Diffeomorph I I' M M' n)
(h₂ : Diffeomorph J J' N N' n), (h₁.prodCongr h₂).symm = h₁.symm.prodCongr h₂.symm |
ProbabilityTheory.integrable_condCDF | Mathlib.Probability.Kernel.Disintegration.CondCDF | ∀ {α : Type u_1} {mα : MeasurableSpace α} (ρ : MeasureTheory.Measure (α × ℝ)) [MeasureTheory.IsFiniteMeasure ρ] (x : ℝ),
MeasureTheory.Integrable (fun a => ↑(ProbabilityTheory.condCDF ρ a) x) ρ.fst |
_private.Batteries.Data.List.Lemmas.0.List.getElem_filter_eq_getElem_getElem_findIdxs_sub._proof_1_4 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {i : ℕ}, i < (List.filter p []).length → i < (List.filter p []).length |
Lean.Grind.IntModule | Init.Grind.Module.Basic | Type u → Type u |
CategoryTheory.epi_comp' | Mathlib.CategoryTheory.Category.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.Epi f → CategoryTheory.Epi g → CategoryTheory.Epi (CategoryTheory.CategoryStruct.comp f g) |
List.isChain_split | Mathlib.Data.List.Chain | ∀ {α : Type u} {R : α → α → Prop} {c : α} {l₁ l₂ : List α},
List.IsChain R (l₁ ++ c :: l₂) ↔ List.IsChain R (l₁ ++ [c]) ∧ List.IsChain R (c :: l₂) |
MeasureTheory.stronglyMeasurable_zero | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_1} {β : Type u_2} {x : MeasurableSpace α} [inst : TopologicalSpace β] [inst_1 : Zero β],
MeasureTheory.StronglyMeasurable 0 |
Order.Ideal.instInhabited | Mathlib.Order.Ideal | {P : Type u_1} → [inst : Preorder P] → [Inhabited P] → Inhabited (Order.Ideal P) |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.Extension.addEMatchAttr.match_1 | Lean.Meta.Tactic.Grind.EMatchTheorem | (motive : Lean.Meta.Grind.EMatchTheoremKind → Sort u_1) →
(thmKind : Lean.Meta.Grind.EMatchTheoremKind) →
((gen : Bool) → motive (Lean.Meta.Grind.EMatchTheoremKind.eqLhs gen)) →
((gen : Bool) → motive (Lean.Meta.Grind.EMatchTheoremKind.eqRhs gen)) →
((gen : Bool) → motive (Lean.Meta.Grind.EMatchTheoremKind.eqBoth gen)) →
((x : Lean.Meta.Grind.EMatchTheoremKind) → motive x) → motive thmKind |
Subtype.semilatticeInf._proof_3 | Mathlib.Order.Lattice | ∀ {α : Type u_1} [inst : SemilatticeInf α] {P : α → Prop} (x x_1 : { x // P x }), ↑x ⊓ ↑x_1 ≤ ↑x_1 |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_413 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax |
IsLeftRegular.mul_left_eq_zero_iff | Mathlib.Algebra.GroupWithZero.Regular | ∀ {R : Type u_1} [inst : MulZeroClass R] {a b : R}, IsLeftRegular b → (b * a = 0 ↔ a = 0) |
FreeGroup.lift._proof_1 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Group β] (f : α → β) (a b : FreeGroup α),
Quot.lift (FreeGroup.Lift.aux f) ⋯ (a * b) =
Quot.lift (FreeGroup.Lift.aux f) ⋯ a * Quot.lift (FreeGroup.Lift.aux f) ⋯ b |
Sym2.coe_lift₂_symm_apply | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (F : Sym2 α → Sym2 β → γ) (a₁ a₂ : α) (b₁ b₂ : β),
↑(Sym2.lift₂.symm F) a₁ a₂ b₁ b₂ = F s(a₁, a₂) s(b₁, b₂) |
Complex.instNNRatCast | Mathlib.Data.Complex.Basic | NNRatCast ℂ |
Booleanisation.instSemilatticeSup | Mathlib.Order.Booleanisation | {α : Type u_1} → [GeneralizedBooleanAlgebra α] → SemilatticeSup (Booleanisation α) |
LocallyFiniteOrder.mk.noConfusion | Mathlib.Order.Interval.Finset.Defs | {α : Type u_1} →
{inst : Preorder α} →
{P : Sort u} →
{finsetIcc finsetIco finsetIoc finsetIoo : α → α → Finset α} →
{finset_mem_Icc : ∀ (a b x : α), x ∈ finsetIcc a b ↔ a ≤ x ∧ x ≤ b} →
{finset_mem_Ico : ∀ (a b x : α), x ∈ finsetIco a b ↔ a ≤ x ∧ x < b} →
{finset_mem_Ioc : ∀ (a b x : α), x ∈ finsetIoc a b ↔ a < x ∧ x ≤ b} →
{finset_mem_Ioo : ∀ (a b x : α), x ∈ finsetIoo a b ↔ a < x ∧ x < b} →
{finsetIcc' finsetIco' finsetIoc' finsetIoo' : α → α → Finset α} →
{finset_mem_Icc' : ∀ (a b x : α), x ∈ finsetIcc' a b ↔ a ≤ x ∧ x ≤ b} →
{finset_mem_Ico' : ∀ (a b x : α), x ∈ finsetIco' a b ↔ a ≤ x ∧ x < b} →
{finset_mem_Ioc' : ∀ (a b x : α), x ∈ finsetIoc' a b ↔ a < x ∧ x ≤ b} →
{finset_mem_Ioo' : ∀ (a b x : α), x ∈ finsetIoo' a b ↔ a < x ∧ x < b} →
{ finsetIcc := finsetIcc, finsetIco := finsetIco, finsetIoc := finsetIoc,
finsetIoo := finsetIoo, finset_mem_Icc := finset_mem_Icc,
finset_mem_Ico := finset_mem_Ico, finset_mem_Ioc := finset_mem_Ioc,
finset_mem_Ioo := finset_mem_Ioo } =
{ finsetIcc := finsetIcc', finsetIco := finsetIco', finsetIoc := finsetIoc',
finsetIoo := finsetIoo', finset_mem_Icc := finset_mem_Icc',
finset_mem_Ico := finset_mem_Ico', finset_mem_Ioc := finset_mem_Ioc',
finset_mem_Ioo := finset_mem_Ioo' } →
(finsetIcc ≍ finsetIcc' →
finsetIco ≍ finsetIco' → finsetIoc ≍ finsetIoc' → finsetIoo ≍ finsetIoo' → P) →
P |
GradedMonoid.GradeZero.monoid._proof_3 | Mathlib.Algebra.GradedMonoid | ∀ {ι : Type u_1} (A : ι → Type u_2) [inst : AddMonoid ι] [inst_1 : GradedMonoid.GMonoid A] (a b : A 0),
GradedMonoid.mk 0 (a • b) = GradedMonoid.mk 0 a * GradedMonoid.mk 0 b |
Metric.Snowflaking.image_toSnowflaking_closedEBall | Mathlib.Topology.MetricSpace.Snowflaking | ∀ {X : Type u_1} {α : ℝ} {hα₀ : 0 < α} {hα₁ : α ≤ 1} [inst : PseudoEMetricSpace X] (x : X) (r : ENNReal),
⇑Metric.Snowflaking.toSnowflaking '' Metric.closedEBall x r =
Metric.closedEBall (Metric.Snowflaking.toSnowflaking x) (r ^ α) |
_private.Mathlib.LinearAlgebra.LinearIndependent.Lemmas.0.Fintype.linearIndependent_iff'._simp_1_3 | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x |
Polynomial.evalEval_multiset_prod | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u_1} [inst : CommSemiring R] (x y : R) (l : Multiset (Polynomial (Polynomial R))),
Polynomial.evalEval x y l.prod = (Multiset.map (Polynomial.evalEval x y) l).prod |
«term_++_» | Init.Notation | Lean.TrailingParserDescr |
MeasureTheory.Measure.hausdorffMeasure_mono | Mathlib.MeasureTheory.Measure.Hausdorff | ∀ {X : Type u_2} [inst : EMetricSpace X] [inst_1 : MeasurableSpace X] [inst_2 : BorelSpace X] {d₁ d₂ : ℝ},
d₁ ≤ d₂ → ∀ (s : Set X), (MeasureTheory.Measure.hausdorffMeasure d₂) s ≤ (MeasureTheory.Measure.hausdorffMeasure d₁) s |
Finmap.mk.injEq | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} (entries : Multiset (Sigma β)) (nodupKeys : entries.NodupKeys)
(entries_1 : Multiset (Sigma β)) (nodupKeys_1 : entries_1.NodupKeys),
({ entries := entries, nodupKeys := nodupKeys } = { entries := entries_1, nodupKeys := nodupKeys_1 }) =
(entries = entries_1) |
_private.Mathlib.CategoryTheory.ConnectedComponents.0.CategoryTheory.instIsConnectedComponent._proof_5 | Mathlib.CategoryTheory.ConnectedComponents | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J] (j₁ j₂ : J)
(hj₁ : CategoryTheory.ConnectedComponents.objectProperty (Quotient.mk'' j₂) j₁) (l : List J)
(hf : ∀ a ∈ l, CategoryTheory.Zigzag a j₂),
({ obj := j₁, property := ⋯ } :: List.pmap (fun x h => { obj := x, property := ⋯ }) l ⋯).length - 1 <
({ obj := j₁, property := ⋯ } :: List.pmap (fun x h => { obj := x, property := ⋯ }) l ⋯).length |
Homeomorph.subLeft._proof_1 | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G] (x : G),
Continuous (Equiv.subLeft x).toFun |
_private.Mathlib.Analysis.Normed.Module.Ball.Pointwise.0.cthickening_thickening._simp_1_1 | Mathlib.Analysis.Normed.Module.Ball.Pointwise | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {δ : ℝ} {s : Set α} {x : α},
(x ∈ Metric.cthickening δ s) = (Metric.infEDist x s ≤ ENNReal.ofReal δ) |
SimpleGraph.completeEquipartiteGraph_adj | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | ∀ {r t : ℕ} {v w : Fin r × Fin t}, (SimpleGraph.completeEquipartiteGraph r t).Adj v w ↔ v.1 ≠ w.1 |
SimpleGraph.TripartiteFromTriangles.cliqueFinset_eq_image | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (t : Finset (α × β × γ)) [inst : DecidableEq α] [inst_1 : DecidableEq β]
[inst_2 : DecidableEq γ] [inst_3 : Fintype α] [inst_4 : Fintype β] [inst_5 : Fintype γ]
[SimpleGraph.TripartiteFromTriangles.NoAccidental t],
(SimpleGraph.TripartiteFromTriangles.graph t).cliqueFinset 3 =
Finset.image (⇑SimpleGraph.TripartiteFromTriangles.toTriangle) t |
SemimoduleCat.Hom.mk | Mathlib.Algebra.Category.ModuleCat.Semi | {R : Type u} → [inst : Semiring R] → {M N : SemimoduleCat R} → (↑M →ₗ[R] ↑N) → M.Hom N |
Pullback.continuous_proj | Mathlib.Topology.FiberBundle.Constructions | ∀ {B : Type u} (F : Type v) (E : B → Type w₁) {B' : Type w₂} [inst : TopologicalSpace B']
[inst_1 : TopologicalSpace (Bundle.TotalSpace F E)] (f : B' → B), Continuous Bundle.TotalSpace.proj |
Lean.JsonRpc.ErrorCode.noConfusionType | Lean.Data.JsonRpc | Sort v✝ → Lean.JsonRpc.ErrorCode → Lean.JsonRpc.ErrorCode → Sort v✝ |
WithVal.ofVal_eq_zero._simp_1 | Mathlib.Topology.Algebra.Valued.WithVal | ∀ {R : Type u_1} {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] [inst_1 : Ring R] (v : Valuation R Γ₀)
(x : WithVal v), (x.ofVal = 0) = (x = 0) |
Lean.LibrarySuggestions.Config.mk.injEq | Lean.LibrarySuggestions.Basic | ∀ (maxSuggestions : ℕ) (caller : Option String) (filter : Lean.Name → Lean.MetaM Bool) (hint : Option String)
(maxSuggestions_1 : ℕ) (caller_1 : Option String) (filter_1 : Lean.Name → Lean.MetaM Bool) (hint_1 : Option String),
({ maxSuggestions := maxSuggestions, caller := caller, filter := filter, hint := hint } =
{ maxSuggestions := maxSuggestions_1, caller := caller_1, filter := filter_1, hint := hint_1 }) =
(maxSuggestions = maxSuggestions_1 ∧ caller = caller_1 ∧ filter = filter_1 ∧ hint = hint_1) |
CategoryTheory.Limits.limitOfTerminal | Mathlib.CategoryTheory.Limits.Shapes.Terminal | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} J] →
(F : CategoryTheory.Functor J C) →
[inst_2 : CategoryTheory.Limits.HasTerminal J] →
[inst_3 : ∀ (i j : J) (f : i ⟶ j), CategoryTheory.IsIso (F.map f)] →
CategoryTheory.Limits.limit F ≅ F.obj (⊤_ J) |
TestFunction.postcompCLM._proof_4 | Mathlib.Analysis.Distribution.TestFunction | ∀ {𝕜 : Type u_4} [inst : NontriviallyNormedField 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_3} [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F] {F' : Type u_2} [inst_6 : NormedAddCommGroup F']
[inst_7 : NormedSpace ℝ F'] [inst_8 : NormedSpace 𝕜 F'] {n : ℕ∞} [inst_9 : Algebra ℝ 𝕜]
[inst_10 : IsScalarTower ℝ 𝕜 F] [inst_11 : IsScalarTower ℝ 𝕜 F'] (T : F →L[𝕜] F') (x : TopologicalSpace.Compacts E)
(x_1 : ↑x ⊆ ↑Ω) (x_2 : ContDiffMapSupportedIn E F n x),
(fun f => { toFun := ⇑T ∘ ⇑f, contDiff' := ⋯, hasCompactSupport' := ⋯, tsupport_subset' := ⋯ })
(TestFunction.ofSupportedIn x_1 x_2) =
((fun K K_sub_Ω => (TestFunction.ofSupportedInCLM 𝕜 K_sub_Ω).comp (ContDiffMapSupportedIn.postcompCLM T)) x x_1) x_2 |
Set.forall_inv_mem._simp_2 | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : InvolutiveInv α] {s : Set α} {p : α → Prop}, (∀ (x : α), x⁻¹ ∈ s → p x) = ∀ x ∈ s, p x⁻¹ |
Submonoid.subtype._proof_2 | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_1} [inst : MulOneClass M] (S : Submonoid M), ↑1 = ↑1 |
_private.Lean.Meta.Tactic.Grind.AC.Proof.0.Lean.Meta.Grind.AC.mkContext | Lean.Meta.Tactic.Grind.AC.Proof | Lean.Expr → Lean.Meta.Grind.AC.ProofM Lean.Expr |
Std.Do.EStateM.instWP | Std.Do.WP.Basic | {ε σ : Type u_1} → Std.Do.WP (EStateM ε σ) (Std.Do.PostShape.except ε (Std.Do.PostShape.arg σ Std.Do.PostShape.pure)) |
_private.Mathlib.Topology.Order.Priestley.0.exists_isClopen_lower_of_not_le.match_1_1 | Mathlib.Topology.Order.Priestley | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : Preorder α] {x y : α}
(motive : (∃ U, IsClopen U ∧ IsUpperSet U ∧ x ∈ U ∧ y ∉ U) → Prop)
(x_1 : ∃ U, IsClopen U ∧ IsUpperSet U ∧ x ∈ U ∧ y ∉ U),
(∀ (U : Set α) (hU : IsClopen U) (hU' : IsUpperSet U) (hx : x ∈ U) (hy : y ∉ U), motive ⋯) → motive x_1 |
ENormSMulClass.recOn | Mathlib.Analysis.Normed.MulAction | {α : Type u_3} →
{β : Type u_4} →
[inst : ENorm α] →
[inst_1 : ENorm β] →
[inst_2 : SMul α β] →
{motive : ENormSMulClass α β → Sort u} →
(t : ENormSMulClass α β) → ((enorm_smul : ∀ (r : α) (x : β), ‖r • x‖ₑ = ‖r‖ₑ * ‖x‖ₑ) → motive ⋯) → motive t |
Manifold.wrapped._@.Mathlib.Geometry.Manifold.Immersion.3457767310._hygCtx._hyg.128 | Mathlib.Geometry.Manifold.Immersion | Subtype (Eq @Manifold.definition✝) |
CategoryTheory.OverClass.rec | Mathlib.CategoryTheory.Comma.Over.OverClass | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X S : C} →
{motive : CategoryTheory.OverClass X S → Sort u_1} →
((hom : X ⟶ S) → motive { hom := hom }) → (t : CategoryTheory.OverClass X S) → motive t |
linter.tacticAnalysis.dummy | Mathlib.Tactic.TacticAnalysis | Lean.Option Bool |
Matroid.Indep.not_dep | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} {I : Set α}, M.Indep I → ¬M.Dep I |
Topology.RelCWComplex.Subcomplex.copy._proof_2 | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] {C D : Set X} [inst : Topology.RelCWComplex C D]
(E : Topology.RelCWComplex.Subcomplex C) (F : Set X),
F = ↑E →
∀ (J : (n : ℕ) → Set (Topology.RelCWComplex.cell C n)),
J = E.I → D ∪ ⋃ n, ⋃ j, Topology.RelCWComplex.openCell n ↑j = F |
SimpleGraph.cycleGraph._proof_1 | Mathlib.Combinatorics.SimpleGraph.Circulant | ∀ (n : ℕ), NeZero (n + 1) |
Lean.Elab.Tactic.hasErrorMessages | Lean.Elab.Tactic.Basic | List Lean.Message → Bool |
CategoryTheory.Idempotents.Karoubi.ext | Mathlib.CategoryTheory.Idempotents.Karoubi | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P Q : CategoryTheory.Idempotents.Karoubi C}
(h_X : P.X = Q.X),
CategoryTheory.CategoryStruct.comp P.p (CategoryTheory.eqToHom h_X) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom h_X) Q.p →
P = Q |
ultrafilter_comap_pure_nhds | Mathlib.Topology.Compactification.StoneCech | ∀ {α : Type u} (b : Ultrafilter α), Filter.comap pure (nhds b) ≤ ↑b |
LLVM.Attribute.ptr | Lean.Compiler.IR.LLVMBindings | {ctx : LLVM.Context} → LLVM.Attribute ctx → USize |
CategoryTheory.ShortComplex.Hom.comm₂₃ | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (self : S₁.Hom S₂),
CategoryTheory.CategoryStruct.comp self.τ₂ S₂.g = CategoryTheory.CategoryStruct.comp S₁.g self.τ₃ |
_private.Mathlib.Analysis.Normed.Lp.PiLp.0.PiLp.uniformity_aux | Mathlib.Analysis.Normed.Lp.PiLp | ∀ (p : ENNReal) {ι : Type u_2} (β : ι → Type u_4) [inst : Fact (1 ≤ p)] [inst_1 : (i : ι) → PseudoEMetricSpace (β i)]
[inst_2 : Fintype ι], uniformity (PiLp p β) = uniformity (WithLp p ((i : ι) → β i)) |
Lean.Meta.Grind.Order.ProofInfo.mk.injEq | Lean.Meta.Tactic.Grind.Order.Types | ∀ (w : Lean.Meta.Grind.Order.NodeId) (k : Lean.Meta.Grind.Order.Weight) (proof : Lean.Expr)
(w_1 : Lean.Meta.Grind.Order.NodeId) (k_1 : Lean.Meta.Grind.Order.Weight) (proof_1 : Lean.Expr),
({ w := w, k := k, proof := proof } = { w := w_1, k := k_1, proof := proof_1 }) =
(w = w_1 ∧ k = k_1 ∧ proof = proof_1) |
Semiring.toGrindSemiring._proof_17 | Mathlib.Algebra.Ring.GrindInstances | ∀ (α : Type u_1) [s : Semiring α] (x : ℕ), OfNat.ofNat x = ↑x |
Std.DTreeMap.Raw.Equiv.diff_left | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
{t₃ : Std.DTreeMap.Raw α β cmp}, t₁.WF → t₂.WF → t₃.WF → t₁.Equiv t₂ → (t₁ \ t₃).Equiv (t₂ \ t₃) |
CategoryTheory.IsGrothendieckAbelian.rec | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
{motive : CategoryTheory.IsGrothendieckAbelian.{w, v, u} C → Sort u_1} →
((locallySmall : CategoryTheory.LocallySmall.{w, v, u} C) →
(hasFilteredColimitsOfSize : CategoryTheory.Limits.HasFilteredColimitsOfSize.{w, w, v, u} C) →
(ab5OfSize : CategoryTheory.AB5OfSize.{w, w, v, u} C) →
(hasSeparator : CategoryTheory.HasSeparator C) → motive ⋯) →
(t : CategoryTheory.IsGrothendieckAbelian.{w, v, u} C) → motive t |
HomotopicalAlgebra.PrepathObject.p₀ | Mathlib.AlgebraicTopology.ModelCategory.PathObject | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] → {A : C} → (self : HomotopicalAlgebra.PrepathObject A) → self.P ⟶ A |
MvPolynomial.mem_supported | Mathlib.Algebra.MvPolynomial.Supported | ∀ {σ : Type u_1} {R : Type u} [inst : CommSemiring R] {p : MvPolynomial σ R} {s : Set σ},
p ∈ MvPolynomial.supported R s ↔ ↑p.vars ⊆ s |
CFC.norm_star_mul_mul_self_of_nonneg._auto_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Isometric | Lean.Syntax |
CompletelyPositiveMapClass | Mathlib.Analysis.CStarAlgebra.CompletelyPositiveMap | (F : Type u_1) →
(A₁ : Type u_2) →
(A₂ : Type u_3) →
[inst : NonUnitalCStarAlgebra A₁] →
[inst_1 : NonUnitalCStarAlgebra A₂] →
[inst_2 : PartialOrder A₁] →
[inst_3 : PartialOrder A₂] → [StarOrderedRing A₁] → [StarOrderedRing A₂] → [FunLike F A₁ A₂] → Prop |
isAddUnit_zero | Mathlib.Algebra.Group.Units.Defs | ∀ {M : Type u_1} [inst : AddMonoid M], IsAddUnit 0 |
CategoryTheory.Pi.opLaxMonoidalPi'._proof_6 | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type u_2} {C : I → Type u_3} [inst : (i : I) → CategoryTheory.Category.{u_1, u_3} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] {D : Type u_5}
[inst_2 : CategoryTheory.Category.{u_4, u_5} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : (i : I) → CategoryTheory.Functor D (C i)) [inst_4 : (i : I) → (F i).OplaxMonoidal] (X Y Z : D),
CategoryTheory.CategoryStruct.comp
(fun i => CategoryTheory.Functor.OplaxMonoidal.δ (F i) (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) Z)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (fun i => CategoryTheory.Functor.OplaxMonoidal.δ (F i) X Y)
((CategoryTheory.Functor.pi' F).obj Z))
(CategoryTheory.MonoidalCategoryStruct.associator ((CategoryTheory.Functor.pi' F).obj X)
((CategoryTheory.Functor.pi' F).obj Y) ((CategoryTheory.Functor.pi' F).obj Z)).hom) =
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Functor.pi' F).map (CategoryTheory.MonoidalCategoryStruct.associator X Y Z).hom)
(CategoryTheory.CategoryStruct.comp
(fun i => CategoryTheory.Functor.OplaxMonoidal.δ (F i) X (CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z))
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft ((CategoryTheory.Functor.pi' F).obj X) fun i =>
CategoryTheory.Functor.OplaxMonoidal.δ (F i) Y Z)) |
CategoryTheory.MorphismProperty.colimitsOfShape_le_of_final | Mathlib.CategoryTheory.MorphismProperty.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C) {J : Type u_1}
[inst_1 : CategoryTheory.Category.{v_1, u_1} J] {J' : Type u_2} [inst_2 : CategoryTheory.Category.{v_2, u_2} J']
(F : CategoryTheory.Functor J J') [F.Final], W.colimitsOfShape J' ≤ W.colimitsOfShape J |
_private.Mathlib.Algebra.Polynomial.Monic.0.Polynomial.Monic.nextCoeff_multiset_prod._simp_1_5 | Mathlib.Algebra.Polynomial.Monic | ∀ {α : Sort u_1}, (∀ (a : α), True) = True |
FiniteField.frobeniusAlgEquiv_apply | Mathlib.FieldTheory.Finite.Basic | ∀ (K : Type u_1) (R : Type u_2) [inst : Field K] [inst_1 : Fintype K] [inst_2 : CommRing R] [inst_3 : Algebra K R]
(p : ℕ) [inst_4 : ExpChar R p] [inst_5 : PerfectRing R p] (a : R),
(FiniteField.frobeniusAlgEquiv K R p) a = a ^ Fintype.card K |
Std.Iterators.Types.Flatten.rec | Init.Data.Iterators.Combinators.Monadic.FlatMap | {α α₂ β : Type w} →
{m : Type w → Type u_1} →
{motive : Std.Iterators.Types.Flatten α α₂ β m → Sort u} →
((it₁ : Std.IterM m (Std.IterM m β)) → (it₂ : Option (Std.IterM m β)) → motive { it₁ := it₁, it₂ := it₂ }) →
(t : Std.Iterators.Types.Flatten α α₂ β m) → motive t |
NumberField.Units.fun_eq_repr | Mathlib.NumberTheory.NumberField.Units.DirichletTheorem | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K] {x ζ : (NumberField.RingOfIntegers K)ˣ}
{f : Fin (NumberField.Units.rank K) → ℤ},
ζ ∈ NumberField.Units.torsion K →
x = ζ * ∏ i, NumberField.Units.fundSystem K i ^ f i →
f = ⇑((NumberField.Units.basisModTorsion K).repr (Additive.ofMul ↑x)) |
_private.Mathlib.Data.Finset.Union.0.Finset.mem_biUnion._simp_1_2 | Mathlib.Data.Finset.Union | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α}, (a ∈ s.dedup) = (a ∈ s) |
CategoryTheory.Equivalence.trans | Mathlib.CategoryTheory.Equivalence | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{E : Type u₃} → [inst_2 : CategoryTheory.Category.{v₃, u₃} E] → (C ≌ D) → (D ≌ E) → (C ≌ E) |
HurwitzZeta.completedHurwitzZetaOdd.eq_1 | Mathlib.NumberTheory.LSeries.HurwitzZetaOdd | ∀ (a : UnitAddCircle) (s : ℂ),
HurwitzZeta.completedHurwitzZetaOdd a s = (HurwitzZeta.hurwitzOddFEPair a).Λ ((s + 1) / 2) / 2 |
isAddUnit_iff_eq_zero._simp_1 | Mathlib.Algebra.Group.Units.Defs | ∀ {M : Type u_1} [inst : AddMonoid M] {a : M} [Subsingleton (AddUnits M)], IsAddUnit a = (a = 0) |
Lean.Parser.Tactic.omega | Init.Tactics | Lean.ParserDescr |
Manifold.IsImmersionAt.congr_of_eventuallyEq | Mathlib.Geometry.Manifold.Immersion | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} {E'' : Type u} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup E''] [inst_4 : NormedSpace 𝕜 E''] {H : Type u_7}
[inst_5 : TopologicalSpace H] {G : Type u_9} [inst_6 : TopologicalSpace G] {I : ModelWithCorners 𝕜 E H}
{J : ModelWithCorners 𝕜 E'' G} {M : Type u_11} [inst_7 : TopologicalSpace M] [inst_8 : ChartedSpace H M]
{N : Type u_13} [inst_9 : TopologicalSpace N] [inst_10 : ChartedSpace G N] {n : WithTop ℕ∞} {f g : M → N} {x : M},
Manifold.IsImmersionAt I J n f x → f =ᶠ[nhds x] g → Manifold.IsImmersionAt I J n g x |
PontryaginDual.instCommGroup | Mathlib.Topology.Algebra.PontryaginDual | {A : Type u_1} → [inst : Monoid A] → [inst_1 : TopologicalSpace A] → CommGroup (PontryaginDual A) |
SubmonoidClass.coe_finset_prod._simp_2 | Mathlib.Algebra.Group.Submonoid.BigOperators | ∀ {B : Type u_3} {S : B} {ι : Type u_4} {M : Type u_5} [inst : CommMonoid M] [inst_1 : SetLike B M]
[inst_2 : SubmonoidClass B M] (f : ι → ↥S) (s : Finset ι), ∏ i ∈ s, ↑(f i) = ↑(∏ i ∈ s, f i) |
CategoryTheory.Functor.shiftMap_comp | Mathlib.CategoryTheory.Shift.ShiftSequence | ∀ {C : Type u_1} {A : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} A] (F : CategoryTheory.Functor C A) {M : Type u_3} [inst_2 : AddMonoid M]
[inst_3 : CategoryTheory.HasShift C M] [inst_4 : F.ShiftSequence M] {X Y Z : C} {n : M}
(f : X ⟶ (CategoryTheory.shiftFunctor C n).obj Y) (g : Y ⟶ Z) (a a' : M) (ha' : n + a = a'),
F.shiftMap (CategoryTheory.CategoryStruct.comp f ((CategoryTheory.shiftFunctor C n).map g)) a a' ha' =
CategoryTheory.CategoryStruct.comp (F.shiftMap f a a' ha') ((F.shift a').map g) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.