name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Compiler.LCNF.Simp.ConstantFold.0.Lean.Compiler.LCNF.Simp.ConstantFold.getFolder | Lean.Compiler.LCNF.Simp.ConstantFold | Lean.Name → Lean.CoreM Lean.Compiler.LCNF.Simp.ConstantFold.Folder | null | true |
SmoothBumpCovering.mk.inj | Mathlib.Geometry.Manifold.PartitionOfUnity | ∀ {ι : Type uι} {E : Type uE} {inst : NormedAddCommGroup E} {inst_1 : NormedSpace ℝ E} {H : Type uH}
{inst_2 : TopologicalSpace H} {I : ModelWithCorners ℝ E H} {M : Type uM} {inst_3 : TopologicalSpace M}
{inst_4 : ChartedSpace H M} {inst_5 : FiniteDimensional ℝ E} {s : Set M} {c : ι → M}
{toFun : (i : ι) → Smooth... | null | true |
CategoryTheory.ObjectProperty.fullSubcategoryCongr_functor | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P P' : CategoryTheory.ObjectProperty C} (h : P = P'),
(CategoryTheory.ObjectProperty.fullSubcategoryCongr h).functor = CategoryTheory.ObjectProperty.ιOfLE ⋯ | null | true |
Filter.comap_embedding_atBot | Mathlib.Order.Filter.AtTopBot.Tendsto | ∀ {β : Type u_4} {γ : Type u_5} [inst : Preorder β] [inst_1 : Preorder γ] {e : β → γ},
(∀ (b₁ b₂ : β), e b₂ ≤ e b₁ ↔ b₂ ≤ b₁) → (∀ (c : γ), ∃ b, e b ≤ c) → Filter.comap e Filter.atBot = Filter.atBot | null | true |
LieSubmodule.instAddCommMonoid._proof_1 | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u_1} {L : Type u_2} {M : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (x : LieSubmodule R L M), 0 • x = 0 | null | false |
LocalizedModule.liftOn._proof_2 | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_2} [inst : CommSemiring R] {S : Submonoid R} {M : Type u_1} [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] {α : Type u_3} (f : M × ↥S → α),
(∀ (p p' : M × ↥S), p ≈ p' → f p = f p') → ∀ (a b : M × ↥S), a ≈ b → f a = f b | null | false |
SemiNormedGrp.Hom.mk.injEq | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ {M N : SemiNormedGrp} (hom' hom'_1 : NormedAddGroupHom M.carrier N.carrier),
({ hom' := hom' } = { hom' := hom'_1 }) = (hom' = hom'_1) | null | true |
CategoryTheory.GrothendieckTopology.Cover.preOneHypercover_p₂ | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C}
(S : J.Cover X) (x x_1 : S.Arrow) (r : x.Relation x_1), S.preOneHypercover.p₂ r = r.g₂ | null | true |
Std.ExtHashMap.getD_diff_of_mem_right | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {fallback : β}, k ∈ m₂ → (m₁ \ m₂).getD k fallback = fallback | null | true |
OrderAddMonoidHom.coe_comp_orderHom | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
[inst_3 : AddZeroClass α] [inst_4 : AddZeroClass β] [inst_5 : AddZeroClass γ] (f : β →+o γ) (g : α →+o β),
↑(f.comp g) = (↑f).comp ↑g | null | true |
CategoryTheory.CostructuredArrow.homMk'_id._proof_2 | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {T : D} {S : CategoryTheory.Functor C D}
(f : CategoryTheory.CostructuredArrow S T),
CategoryTheory.CostructuredArrow.mk
(CategoryTheory.CategoryStruct.comp (S.map (CategoryTheory.Ca... | null | false |
Set.pairwise_iUnion₂_iff | Mathlib.Data.Set.Pairwise.Lattice | ∀ {α : Type u_1} {r : α → α → Prop} {s : Set (Set α)},
DirectedOn (fun x1 x2 => x1 ⊆ x2) s → ((⋃ a ∈ s, a).Pairwise r ↔ ∀ a ∈ s, a.Pairwise r) | null | true |
Lean.Meta.forallMetaTelescopeReducingUntilDefEq | Mathlib.Lean.Meta.Basic | Lean.Expr →
Lean.Expr →
optParam Lean.MetavarKind Lean.MetavarKind.natural →
Lean.MetaM (Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr) | This function is similar to `forallMetaTelescopeReducing`: Given `e` of the
form `forall ..xs, A`, this combinator will create a new metavariable for
each `x` in `xs` until it reaches an `x` whose type is defeq to `t`,
and instantiate `A` with these, while also reducing `A` if needed.
It uses `forallMetaTelescopeReduci... | true |
CategoryTheory.CommSq.mk._flat_ctor | Mathlib.CategoryTheory.CommSq | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z}
{i : Y ⟶ Z},
autoParam (CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g i)
CategoryTheory.CommSq.w._autoParam →
CategoryTheory.CommSq f g h i | null | false |
surjective_of_isLocalized_span | Mathlib.RingTheory.LocalProperties.Exactness | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (s : Set R),
Ideal.span s = ⊤ →
∀ (Mₚ : ↑s → Type u_5) [inst_5 : (r : ↑s) → AddCommMonoid (Mₚ r)] [inst_6 : (r : ↑s) → Module R (Mₚ r)]
(... | null | true |
_private.Mathlib.SetTheory.Cardinal.CountableCover.0.Cardinal.mk_subtype_le_of_countable_eventually_mem._simp_1_1 | Mathlib.SetTheory.Cardinal.CountableCover | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | null | false |
_private.Mathlib.Order.Interval.Set.Pi.0.Set.Icc_sdiff_pi_univ_Ioo_subset._simp_1_10 | Mathlib.Order.Interval.Set.Pi | ∀ {α : Sort u_1} {p q : α → Prop}, ((∃ x, p x) ∨ ∃ x, q x) = ∃ x, p x ∨ q x | null | false |
CategoryTheory.IsCardinalFiltered.coeq_condition | Mathlib.CategoryTheory.Presentable.IsCardinalFiltered | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {κ : Cardinal.{w}} [hκ : Fact κ.IsRegular]
[inst_1 : CategoryTheory.IsCardinalFiltered J κ] {K : Type v'} {j j' : J} (f : K → (j ⟶ j')) (hK : HasCardinalLT K κ)
(k : K),
CategoryTheory.CategoryStruct.comp (f k) (CategoryTheory.IsCardinalFiltered.coeqHom f h... | null | true |
List.TProd.elim._proof_1 | Mathlib.Data.Prod.TProd | ∀ {ι : Type u_1} (i : ι) (is : List ι), ∀ j ∈ i :: is, ¬j = i → j ∈ is | null | false |
BooleanSubalgebra.instTopCoe | Mathlib.Order.BooleanSubalgebra | {α : Type u_2} → [inst : BooleanAlgebra α] → {L : BooleanSubalgebra α} → Top ↥L | A Boolean subalgebra of a lattice inherits a top element. | true |
MeasureTheory.Measure.tprod | Mathlib.MeasureTheory.Constructions.Pi | {δ : Type u_4} →
{X : δ → Type u_5} →
[inst : (i : δ) → MeasurableSpace (X i)] →
(l : List δ) → ((i : δ) → MeasureTheory.Measure (X i)) → MeasureTheory.Measure (List.TProd X l) | A product of measures in `tprod α l`. | true |
Polynomial.Chebyshev.C_add_two | Mathlib.RingTheory.Polynomial.Chebyshev | ∀ (R : Type u_1) [inst : CommRing R] (n : ℤ),
Polynomial.Chebyshev.C R (n + 2) = Polynomial.X * Polynomial.Chebyshev.C R (n + 1) - Polynomial.Chebyshev.C R n | null | true |
Lean.Import._sizeOf_1 | Lean.Setup | Lean.Import → ℕ | null | false |
CommGrpCat.id_apply | Mathlib.Algebra.Category.Grp.Basic | ∀ (X : CommGrpCat) (x : ↑X), (CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X)) x = x | null | true |
HasProd.mul_isCompl | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α} {a b : α}
[ContinuousMul α] {s t : Set β},
IsCompl s t → HasProd (f ∘ Subtype.val) a → HasProd (f ∘ Subtype.val) b → HasProd f (a * b) | null | true |
Interval.«_aux_Mathlib_Order_Interval_Set_UnorderedInterval___macroRules_Interval_term[[_,_]]_1» | Mathlib.Order.Interval.Set.UnorderedInterval | Lean.Macro | null | false |
MonomialOrder.degree_smul_of_mem_nonZeroDivisors | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommSemiring R] {r : R},
r ∈ nonZeroDivisors R → ∀ {f : MvPolynomial σ R}, m.degree (r • f) = m.degree f | null | true |
RatFunc.laurent_laurent | Mathlib.FieldTheory.Laurent | ∀ {R : Type u} [inst : CommRing R] (r s : R) (f : RatFunc R) [inst_1 : IsDomain R],
(RatFunc.laurent r) ((RatFunc.laurent s) f) = (RatFunc.laurent (r + s)) f | null | true |
MeasurableEquiv.mulLeft.congr_simp | Mathlib.MeasureTheory.Group.LIntegral | ∀ {G : Type u_1} [inst : Group G] [inst_1 : MeasurableSpace G] [inst_2 : MeasurableMul G] (g g_1 : G),
g = g_1 → MeasurableEquiv.mulLeft g = MeasurableEquiv.mulLeft g_1 | null | true |
Filter.lift_lift_same_le_lift | Mathlib.Order.Filter.Lift | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Set α → Set α → Filter β},
(f.lift fun s => f.lift (g s)) ≤ f.lift fun s => g s s | null | true |
BooleanSubalgebra.copy | Mathlib.Order.BooleanSubalgebra | {α : Type u_2} → [inst : BooleanAlgebra α] → (L : BooleanSubalgebra α) → (s : Set α) → s = ↑L → BooleanSubalgebra α | Copy of a Boolean subalgebra with a new `carrier` equal to the old one. Useful to fix
definitional equalities. | true |
FirstOrder.Language.partialOrderTheory.eq_1 | Mathlib.ModelTheory.Order | ∀ (L : FirstOrder.Language) [inst : L.IsOrdered],
L.partialOrderTheory = insert FirstOrder.Language.leSymb.antisymmetric L.preorderTheory | null | true |
MonomialOrder.withBotDegree_sum_le | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommSemiring R] {α : Type u_3} {s : Finset α}
{f : α → MvPolynomial σ R},
m.toWithBotSyn (m.withBotDegree (∑ x ∈ s, f x)) ≤ s.sup fun x => m.toWithBotSyn (m.withBotDegree (f x)) | null | true |
CompactlySupportedContinuousMap.coeFnMonoidHom._proof_2 | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : AddMonoid β]
[inst_3 : ContinuousAdd β] (f g : CompactlySupportedContinuousMap α β), ⇑(f + g) = ⇑f + ⇑g | null | false |
IsIntegralClosure.equiv.congr_simp | Mathlib.Topology.Algebra.Valued.WithVal | ∀ (R : Type u_1) (A : Type u_2) (B : Type u_3) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R B] [inst_4 : Algebra A B] [inst_5 : IsIntegralClosure A R B] (A' : Type u_4)
[inst_6 : CommRing A'] [inst_7 : Algebra A' B] [inst_8 : IsIntegralClosure A' R B] [inst_9 : Algebra R A]
... | null | true |
Std.ExtDTreeMap.instDecidableMem | Std.Data.ExtDTreeMap.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} → [inst : Std.TransCmp cmp] → {m : Std.ExtDTreeMap α β cmp} → {a : α} → Decidable (a ∈ m) | null | true |
Std.DHashMap.Raw | Std.Data.DHashMap.RawDef | (α : Type u) → (α → Type v) → Type (max u v) | Dependent hash maps without a bundled well-formedness invariant, suitable for use in nested
inductive types. The well-formedness invariant is called `Raw.WF`. When in doubt, prefer `DHashMap`
over `DHashMap.Raw`. Lemmas about the operations on `Std.Data.DHashMap.Raw` are available in the
module `Std.Data.DHashMap.RawLe... | true |
Ideal.quotientEquiv._proof_6 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u_1} [inst : Ring R] {S : Type u_2} [inst_1 : Ring S], RingHomClass (S →+* R) S R | null | false |
CategoryTheory.GlueData'.t''._proof_14 | Mathlib.CategoryTheory.GlueData | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (D : CategoryTheory.GlueData' C) (i : D.J), D.U i = D.U i | null | false |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne.0.NumberField.mixedEmbedding.fundamentalCone.expMap_smul._simp_1_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | null | false |
Std.ExtTreeMap.getKey!_minKey! | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α], t ≠ ∅ → t.getKey! t.minKey! = t.minKey! | null | true |
MeasureTheory.quasiMeasurePreserving_sub_left | Mathlib.MeasureTheory.Group.Prod | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : AddGroup G] [MeasurableAdd₂ G] (μ : MeasureTheory.Measure G)
[MeasureTheory.SFinite μ] [MeasurableNeg G] [μ.IsAddLeftInvariant] (g : G),
MeasureTheory.QuasiMeasurePreserving (fun h => g - h) μ μ | null | true |
Std.DTreeMap.Internal.Impl.Const.isSome_apply_of_contains_filterMap! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Std.DTreeMap.Internal.Impl α fun x => β}
[inst : Std.TransOrd α] {f : α → β → Option γ} {k : α} (h : t.WF)
(h' : Std.DTreeMap.Internal.Impl.contains k (Std.DTreeMap.Internal.Impl.filterMap! f t) = true),
(f (t.getKey k ⋯) (Std.DTreeMap.Internal.Impl.... | null | true |
ProbabilityTheory.measure_condCDF_univ | Mathlib.Probability.Kernel.Disintegration.CondCDF | ∀ {α : Type u_1} {mα : MeasurableSpace α} (ρ : MeasureTheory.Measure (α × ℝ)) (a : α),
(ProbabilityTheory.condCDF ρ a).measure Set.univ = 1 | null | true |
_private.Mathlib.RingTheory.LocalRing.Module.0.IsLocalRing.map_tensorProduct_mk_eq_top._proof_1_4 | Mathlib.RingTheory.LocalRing.Module | ∀ {R : Type u_2} {M : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : IsLocalRing R] (b : M ⧸ IsLocalRing.maximalIdeal R • ⊤), 1 • b = b | null | false |
CategoryTheory.Limits.hasProducts_opposite | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Products | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasCoproducts C],
CategoryTheory.Limits.HasProducts Cᵒᵖ | null | true |
Module.Flat.instPreservesFiniteLimitsModuleCatTensorRightOfCarrier | Mathlib.RingTheory.Flat.CategoryTheory | ∀ {R : Type u} [inst : CommRing R] (M : ModuleCat R) [Module.Flat R ↑M],
CategoryTheory.Limits.PreservesFiniteLimits (CategoryTheory.MonoidalCategory.tensorRight M) | null | true |
ProbabilityTheory.covarianceBilin_real | Mathlib.Probability.Moments.CovarianceBilin | ∀ {μ : MeasureTheory.Measure ℝ} [MeasureTheory.IsFiniteMeasure μ] (x y : ℝ),
((ProbabilityTheory.covarianceBilin μ) x) y = x * y * ProbabilityTheory.variance id μ | null | true |
Std.Http.CustomStatus.casesOn | Std.Http.Data.Status | {motive : Std.Http.CustomStatus → Sort u} →
(t : Std.Http.CustomStatus) →
((code : UInt16) →
(phrase : String) →
(validReasonPhrase : Std.Http.IsValidReasonPhrase phrase) →
(validCode : 100 ≤ code ∧ code ≤ 999) →
(validUnknown : ¬Std.Http.isKnownStatusCode code = true) ... | null | false |
Std.Roi.eq_succMany?_of_toList_eq_append_cons | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Roi α} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerableLT α]
[inst_5 : Std.Rxi.IsAlwaysFinite α] {pref suff : List α} {cur : α} (h : r.toList = pref ++ cur :: suff),
cu... | null | true |
Mathlib.TacticAnalysis.ComplexConfig.test | Mathlib.Tactic.TacticAnalysis | (self : Mathlib.TacticAnalysis.ComplexConfig) →
Lean.Elab.ContextInfo → Lean.Elab.TacticInfo → self.ctx → Lean.MVarId → Lean.Elab.Command.CommandElabM self.out | Code to run in the context of the tactic, for example an alternative tactic. | true |
Metric.Snowflaking.preimage_toSnowflaking_eball | Mathlib.Topology.MetricSpace.Snowflaking | ∀ {X : Type u_1} {α : ℝ} {hα₀ : 0 < α} {hα₁ : α ≤ 1} [inst : PseudoEMetricSpace X] (x : Metric.Snowflaking X α hα₀ hα₁)
(d : ENNReal),
⇑Metric.Snowflaking.toSnowflaking ⁻¹' Metric.eball x d = Metric.eball (Metric.Snowflaking.ofSnowflaking x) (d ^ α⁻¹) | null | true |
List.Shortlex.cons | Mathlib.Data.List.Shortlex | ∀ {α : Type u_1} {r : α → α → Prop} [Std.Irrefl r] {a : α} {s t : List α},
List.Shortlex r s t → List.Shortlex r (a :: s) (a :: t) | **Alias** of the reverse direction of `List.shortlex_cons_iff`. | true |
_private.Lake.Util.Version.0.Lake.ToolchainVer.ofString._sparseCasesOn_1 | Lake.Util.Version | {ε : Type u} →
{α : Type v} →
{motive : Except ε α → Sort u_1} →
(t : Except ε α) → ((a : α) → motive (Except.ok a)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Min.casesOn | Init.Prelude | {α : Type u} → {motive : Min α → Sort u_1} → (t : Min α) → ((min : α → α → α) → motive { min := min }) → motive t | null | false |
CFC.neg_negPart_le | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.PosPart.Basic | ∀ {A : Type u_1} [inst : NonUnitalRing A] [inst_1 : Module ℝ A] [inst_2 : SMulCommClass ℝ A A]
[inst_3 : IsScalarTower ℝ A A] [inst_4 : StarRing A] [inst_5 : TopologicalSpace A]
[inst_6 : NonUnitalContinuousFunctionalCalculus ℝ A IsSelfAdjoint] [inst_7 : PartialOrder A] [StarOrderedRing A]
{a : A}, autoParam (IsS... | null | true |
CategoryTheory.Equivalence.mapCommMon_inverse | Mathlib.CategoryTheory.Monoidal.CommMon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u₂} [inst_3 : CategoryTheory.Category.{v₂, u₂} D]
[inst_4 : CategoryTheory.MonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D] (e : C ≌ D)
[ins... | null | true |
Homeomorph.comp_isOpenMap_iff._simp_1 | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] (h : X ≃ₜ Y) {f : Z → X}, IsOpenMap (⇑h ∘ f) = IsOpenMap f | null | false |
CategoryTheory.Limits.walkingCospanOpEquiv_inverse_obj | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ (X : CategoryTheory.Limits.WidePushoutShape CategoryTheory.Limits.WalkingPair),
CategoryTheory.Limits.walkingCospanOpEquiv.inverse.obj X = Opposite.op X | null | true |
CategoryTheory.IsSplitMono.casesOn | Mathlib.CategoryTheory.EpiMono | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y : C} →
{f : X ⟶ Y} →
{motive : CategoryTheory.IsSplitMono f → Sort u} →
(t : CategoryTheory.IsSplitMono f) →
((exists_splitMono : Nonempty (CategoryTheory.SplitMono f)) → motive ⋯) → motive t | null | false |
MultilinearMap.domDomCongr_eq_iff._simp_1 | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type uR} {M₂ : Type v₂} {M₃ : Type v₃} [inst : Semiring R] [inst_1 : AddCommMonoid M₂]
[inst_2 : AddCommMonoid M₃] [inst_3 : Module R M₂] [inst_4 : Module R M₃] {ι₁ : Type u_1} {ι₂ : Type u_2}
(σ : ι₁ ≃ ι₂) (f g : MultilinearMap R (fun x => M₂) M₃),
(MultilinearMap.domDomCongr σ f = MultilinearMap.domDomCo... | null | false |
_private.Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basic.0.Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries.monomialRpow.match_1.splitter | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basic | (motive : ℕ → Sort u_1) → (n : ℕ) → (Unit → motive 0) → ((m : ℕ) → motive m.succ) → motive n | null | true |
MeasureTheory.Measure.toOuterMeasure_top | Mathlib.MeasureTheory.Measure.CompleteLattice | ∀ {α : Type u_1} {mα : MeasurableSpace α}, ⊤.toOuterMeasure = ⊤ | null | true |
_private.Mathlib.Analysis.ConstantSpeed.0.unique_unit_speed_on_Icc_zero._simp_1_1 | Mathlib.Analysis.ConstantSpeed | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Icc a b) = (a ≤ x ∧ x ≤ b) | null | false |
AddGrpCat.Hom._mkInternal._flat_ctor | Mathlib.Algebra.Category.Grp.Basic | {A B : AddGrpCat} → (↑A →+ ↑B) → A.Hom B | null | false |
instIsLocalizationAlgebraMapSubmonoidPrimeComplLocalization | Mathlib.RingTheory.DedekindDomain.Instances | ∀ {R : Type u_1} (S : Type u_2) (T : Type u_3) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R S] {P : Ideal R} [inst_4 : P.IsPrime] [inst_5 : Algebra S T] [inst_6 : Algebra R T]
[IsScalarTower R S T],
IsLocalization (Algebra.algebraMapSubmonoid T (Algebra.algebraMapSubmonoid S... | null | true |
List.zipWithM'._sunfold | Init.Data.List.Monadic | {m : Type u → Type v} →
[Monad m] → {α : Type w} → {β : Type x} → {γ : Type u} → (α → β → m γ) → List α → List β → m (List γ) | null | false |
_private.Lean.Meta.Eqns.0.Lean.Meta.mkSimpleEqThm.match_1 | Lean.Meta.Eqns | (motive : Option Lean.ConstantInfo → Sort u_1) →
(x : Option Lean.ConstantInfo) →
((info : Lean.DefinitionVal) → motive (some (Lean.ConstantInfo.defnInfo info))) →
((x : Option Lean.ConstantInfo) → motive x) → motive x | null | false |
BesselPotentialSpace.instSMul._proof_3 | Mathlib.Analysis.FunctionalSpaces.BesselPotentialSpace | ∀ {F : Type u_1} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℂ F], ContinuousConstSMul ℂ F | null | false |
Function.smulCommClass | Mathlib.Algebra.Group.Action.Pi | ∀ {ι : Type u_1} {M : Type u_2} {N : Type u_3} {α : Type u_7} [inst : SMul M α] [inst_1 : SMul N α]
[SMulCommClass M N α], SMulCommClass M N (ι → α) | Non-dependent version of `Pi.smulCommClass`. Lean gets confused by the dependent instance if
this is not present. | true |
CategoryTheory.LiftableCone.validLift | Mathlib.CategoryTheory.Limits.Creates | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : Type w} →
[inst_2 : CategoryTheory.Category.{w', w} J] →
{K : CategoryTheory.Functor J C} →
{F : CategoryTheory.Functor C D} →
... | the isomorphism expressing that `liftedCone` lifts the given cone | true |
FiniteGaloisIntermediateField.finGaloisGroup._proof_2 | Mathlib.FieldTheory.Galois.Profinite | ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K], IsScalarTower k k K | null | false |
Mathlib.Tactic.LibrarySearch.observe | Mathlib.Tactic.Observe | Lean.ParserDescr | `observe hp : p` asserts the proposition `p` as a hypothesis named `hp`, and tries to prove it
using `exact?`.
If no proof is found, the tactic fails.
In other words, this tactic is equivalent to `have hp : p := by exact?`.
* `observe : p` uses the name `this` for the new hypothesis.
* `observe? hp : p` will emit a tr... | true |
List.flatten._sunfold | Init.Prelude | {α : Type u_1} → List (List α) → List α | null | false |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.D₃.congr_simp | Mathlib.CategoryTheory.Presentable.Directed | ∀ {J : Type w} [inst : CategoryTheory.SmallCategory J] {κ : Cardinal.{w}} [inst_1 : Fact κ.IsRegular]
(D D_1 : CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.DiagramWithUniqueTerminal J κ),
D = D_1 →
∀ (m₁ m₁_1 : J),
m₁ = m₁_1 →
CategoryTheory.IsCardinalFiltered.exists_cardinal_directe... | null | true |
CategoryTheory.Arrow.w_mk_assoc._to_dual_1 | Mathlib.CategoryTheory.Comma.Arrow | ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] {X Y X' Y' : T} {f : Y ⟶ X} {g : Y' ⟶ X'}
(sq : CategoryTheory.Arrow.mk g ⟶ CategoryTheory.Arrow.mk f) {Z : T} (h : Z ⟶ Y'),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp h g) (CategoryTheory.Arrow.Hom.right sq) =
CategoryTheory.C... | null | false |
continuousAt_codRestrict_iff | Mathlib.Topology.Constructions | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {t : Set Y}
(h1 : ∀ (x : X), f x ∈ t) {x : X}, ContinuousAt (Set.codRestrict f t h1) x ↔ ContinuousAt f x | null | true |
SetRel.IsSeparated.empty | Mathlib.Basic.Rel.Separated | ∀ {X : Type u_1} {R : SetRel X X}, R.IsSeparated ∅ | null | true |
Matrix.isRepresentation.toEnd._proof_8 | Mathlib.LinearAlgebra.Matrix.Charpoly.LinearMap | ∀ {ι : Type u_1} [inst : Fintype ι] (R : Type u_2) [inst_1 : CommRing R] [inst_2 : DecidableEq ι],
ZeroMemClass (Subalgebra R (Matrix ι ι R)) (Matrix ι ι R) | null | false |
Finset.Ioc_subset_Ioc_left | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} {a₁ a₂ b : α} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α],
a₁ ≤ a₂ → Finset.Ioc a₂ b ⊆ Finset.Ioc a₁ b | null | true |
MvPowerSeries.X_mem_nonZeroDivisors | Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] {i : σ}, MvPowerSeries.X i ∈ nonZeroDivisors (MvPowerSeries σ R) | null | true |
CategoryTheory.CoreSmallCategoryOfSet.homEquiv | Mathlib.CategoryTheory.SmallRepresentatives | {Ω : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(self : CategoryTheory.CoreSmallCategoryOfSet Ω C) →
{X Y : ↑self.obj} → ↑(self.hom X Y) ≃ (self.objEquiv X ⟶ self.objEquiv Y) | a bijection between the types of morphisms | true |
_private.Lean.Meta.Tactic.Subst.0.Lean.Meta.substVar.match_4 | Lean.Meta.Tactic.Subst | (motive : Option (Lean.FVarId × Bool) → Sort u_1) →
(__x : Option (Lean.FVarId × Bool)) →
((fvarId : Lean.FVarId) → (symm : Bool) → motive (some (fvarId, symm))) →
((x : Option (Lean.FVarId × Bool)) → motive x) → motive __x | null | false |
DistribMulActionHom.mk.congr_simp | Mathlib.Algebra.Algebra.Unitization | ∀ {M : Type u_1} [inst : Monoid M] {N : Type u_2} [inst_1 : Monoid N] {φ : M →* N} {A : Type u_10}
[inst_2 : AddMonoid A] [inst_3 : DistribMulAction M A] {B : Type u_11} [inst_4 : AddMonoid B]
[inst_5 : DistribMulAction N B] (toMulActionHom toMulActionHom_1 : A →ₑ[⇑φ] B)
(e_toMulActionHom : toMulActionHom = toMul... | null | true |
SubAddAction.closure | Mathlib.GroupTheory.GroupAction.SubMulAction.Closure | (R : Type u_1) → {M : Type u_2} → [inst : VAdd R M] → Set M → SubAddAction R M | The `SubAddAction` generated by a set `s`. | true |
CategoryTheory.Functor.IsStronglyCartesian.domainIsoOfBaseIso._proof_5 | Mathlib.CategoryTheory.FiberedCategory.Cartesian | ∀ {𝒮 : Type u_4} {𝒳 : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} 𝒮]
[inst_1 : CategoryTheory.Category.{u_1, u_2} 𝒳] (p : CategoryTheory.Functor 𝒳 𝒮) {R R' S : 𝒮} {a a' b : 𝒳} {f : R ⟶ S}
{f' : R' ⟶ S} {g : R' ≅ R} (h : f' = CategoryTheory.CategoryStruct.comp g.hom f) (φ : a ⟶ b) (φ' : a' ⟶ b)
[i... | null | false |
_private.Init.Data.String.Decode.0.Char.toNat_le | Init.Data.String.Decode | ∀ {c : Char}, c.toNat ≤ 1114111 | null | true |
CategoryTheory.MorphismProperty.DescendsAlong.recOn | Mathlib.CategoryTheory.MorphismProperty.Descent | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{P Q : CategoryTheory.MorphismProperty C} →
{motive : P.DescendsAlong Q → Sort u} →
(t : P.DescendsAlong Q) →
((of_isPullback :
∀ {A X Y Z : C} {fst : A ⟶ X} {snd : A ⟶ Y} {f : X ⟶ Z} {g : Y ⟶ Z},
... | null | false |
CategoryTheory.Functor.whiskerRight_comp | Mathlib.CategoryTheory.Whiskering | ∀ {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] {G H K : CategoryTheory.Functor C D} (α : G ⟶ H)
(β : H ⟶ K) (F : CategoryTheory.Functor D E),
CategoryTheory.Functor.whiskerRight (Ca... | null | true |
CategoryTheory.Grp.instMonObj._proof_3 | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {H : CategoryTheory.Grp C} [inst_3 : CategoryTheory.IsCommMonObj H.X],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whis... | null | false |
Derivative.serreDerivativeMF._auto_1 | Mathlib.NumberTheory.ModularForms.Derivative | Lean.Syntax | null | false |
Subgroup.instSMul | Mathlib.Algebra.Group.Subgroup.MulOppositeLemmas | {G : Type u_2} → [inst : Group G] → (H : Subgroup G) → SMul (↥H.op) G | We redeclare this instance to get keys
`SMul (@Subtype (MulOpposite _) (@Membership.mem (MulOpposite _)
(Subgroup (MulOpposite _) _) _ (@Subgroup.op _ _ _))) _`
compared to the keys for `Submonoid.smul`
`SMul (@Subtype _ (@Membership.mem _ (Submonoid _ _) _ _)) _` | true |
LaurentPolynomial.C_apply | Mathlib.Algebra.Polynomial.Laurent | ∀ {R : Type u_1} [inst : Semiring R] (t : R) (n : ℤ), (LaurentPolynomial.C t).coeff n = if n = 0 then t else 0 | null | true |
CategoryTheory.Functor.hom_ext_of_isLeftKanExtension | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_1} {H : Type u_3} {D : Type u_5} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_3, u_3} H] [inst_2 : CategoryTheory.Category.{v_5, u_5} D]
(F' : CategoryTheory.Functor D H) {L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H}
(α : F ⟶ L.comp F') [F'.I... | null | true |
Bundle.Trivialization.preimageSingletonHomeomorph_symm_apply | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
[inst_2 : TopologicalSpace Z] (e : Bundle.Trivialization F proj) {b : B} (hb : b ∈ e.baseSet) (p : F),
(e.preimageSingletonHomeomorph hb).symm p = ⟨↑e.symm (b, p), ⋯⟩ | null | true |
Std.ExtTreeSet.forM_eq_forM_toList | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} {m : Type w → Type w'} [inst : Std.TransCmp cmp]
[inst_1 : Monad m] [inst_2 : LawfulMonad m] {f : α → m PUnit.{w + 1}}, forM t f = t.toList.forM f | null | true |
Lean.Elab.ExpandDeclIdResult._sizeOf_inst | Lean.Elab.DeclModifiers | SizeOf Lean.Elab.ExpandDeclIdResult | null | false |
Nat.toInt32 | Init.Data.SInt.Basic | ℕ → Int32 | Converts a natural number to a 32-bit signed integer, wrapping around to negative numbers on
overflow.
Examples:
* `Nat.toInt32 127 = 127`
* `Nat.toInt32 32770 = 32770`
* `Nat.toInt32 2_147_483_647 = 2_147_483_647`
* `Nat.toInt32 2_147_483_648 = -2_147_483_648`
| true |
Std.Time.DateTime.ofPlainDateTime | Std.Time.DateTime | Std.Time.PlainDateTime → Std.Time.TimeZone.ZoneRules → Std.Time.DateTime | Creates a new `DateTime` out of a `PlainDateTime` and a `ZoneRules`. It assumes `PlainDateTime` is
the local time.
| true |
CommRingCat.Colimits.descMorphism._proof_4 | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CommRingCat)
(s : CategoryTheory.Limits.Cocone F), CommRingCat.Colimits.descFun F s 0 = CommRingCat.Colimits.descFun F s 0 | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.