name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
HasFPowerSeriesAt.has_fpower_series_iterate_dslope_fslope | Mathlib.Analysis.Analytic.IsolatedZeros | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {p : FormalMultilinearSeries 𝕜 𝕜 E} {f : 𝕜 → E} {z₀ : 𝕜} (n : ℕ),
HasFPowerSeriesAt f p z₀ →
HasFPowerSeriesAt ((Function.swap dslope z₀)^[n] f) (FormalMultilinearSeries.fslope^[n... | null | true |
ContinuousAlternatingMap.alternatizeUncurryFinCLM._proof_1 | Mathlib.Analysis.Normed.Module.Alternating.Uncurry.Fin | ∀ (𝕜 : Type u_3) (E : Type u_2) (F : Type u_1) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : ℕ}
(f : E →L[𝕜] E [⋀^Fin n]→L[𝕜] F) (v : Fin (n + 1) → E),
‖(ContinuousAlternatingMap.alternatizeUncurr... | null | false |
Equiv.Perm.OnCycleFactors.odd_of_centralizer_le_alternatingGroup | Mathlib.GroupTheory.SpecificGroups.Alternating.Centralizer | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {g : Equiv.Perm α},
Subgroup.centralizer {g} ≤ alternatingGroup α → ∀ i ∈ g.cycleType, Odd i | null | true |
Matroid.exists_isBasis_union_inter_isBasis._auto_3 | Mathlib.Combinatorics.Matroid.Basic | Lean.Syntax | null | false |
_private.Mathlib.Logic.Equiv.Fin.Rotate.0.Fin.snoc_eq_cons_rotate._simp_1_1 | Mathlib.Logic.Equiv.Fin.Rotate | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | null | false |
Matrix.PosDef.fromBlocks₂₂ | Mathlib.LinearAlgebra.Matrix.PosDef | ∀ {m : Type u_1} {n : Type u_2} {R' : Type u_4} [inst : CommRing R'] [inst_1 : PartialOrder R'] [inst_2 : StarRing R']
[inst_3 : Fintype n] [StarOrderedRing R'] [Finite m] [inst_6 : DecidableEq n] (A : Matrix m m R') (B : Matrix m n R')
{D : Matrix n n R'},
D.PosDef →
∀ [Invertible D], (Matrix.fromBlocks A B ... | null | true |
Real.arcosh_lt_arcosh | Mathlib.Analysis.SpecialFunctions.Arcosh | ∀ {x y : ℝ}, 0 < x → 0 < y → (Real.arcosh x < Real.arcosh y ↔ x < y) | This holds for `0 < x, y ≤ 1` due to junk values. | true |
CategoryTheory.ComposableArrows.IsComplex.mk | Mathlib.Algebra.Homology.ExactSequence | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{n : ℕ} {S : CategoryTheory.ComposableArrows C n},
(∀ (i : ℕ) (hi : autoParam (i + 2 ≤ n) CategoryTheory.ComposableArrows.IsComplex._auto_1),
CategoryTheory.CategoryStruct.comp (S.map' i (i + 1) ... | null | true |
ContDiffAt.csin | Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : E → ℂ} {x : E} {n : WithTop ℕ∞},
ContDiffAt ℂ n f x → ContDiffAt ℂ n (fun x => Complex.sin (f x)) x | null | true |
Std.TreeMap.getElem?_eq_some_iff_exists_compare_eq_eq_and_mem_toList | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α} {v : β},
t[k]? = some v ↔ ∃ k', cmp k k' = Ordering.eq ∧ (k', v) ∈ t.toList | null | true |
enorm_add_le | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_7} [inst : TopologicalSpace E] [inst_1 : ESeminormedAddMonoid E] (a b : E), ‖a + b‖ₑ ≤ ‖a‖ₑ + ‖b‖ₑ | null | true |
Array.isEmpty_toList | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α}, xs.toList.isEmpty = xs.isEmpty | null | true |
Profinite.NobelingProof.spanCone_isLimit | Mathlib.Topology.Category.Profinite.Nobeling.Basic | {I : Type u} →
{C : Set (I → Bool)} →
[inst : (s : Finset I) → (i : I) → Decidable (i ∈ s)] →
(hC : IsCompact C) → CategoryTheory.Limits.IsLimit (Profinite.NobelingProof.spanCone hC) | `spanCone` is a limit cone. | true |
USize.toBitVec32_add | Init.Data.UInt.IntToBitVec | ∀ {a b : USize} (h : System.Platform.numBits = 32), (a + b).toBitVec32 h = a.toBitVec32 h + b.toBitVec32 h | null | true |
_private.Lean.Meta.DiscrTree.Basic.0.Lean.Meta.DiscrTree.keysAsPattern.mkApp | Lean.Meta.DiscrTree.Basic | Lean.MessageData → Array Lean.MessageData → Bool → Lean.CoreM Lean.MessageData | null | true |
LieAlgebra.SemiDirectSum.smul_eq_mk | Mathlib.Algebra.Lie.SemiDirect | ∀ {R : Type u_1} [inst : CommRing R] {K : Type u_2} [inst_1 : LieRing K] [inst_2 : LieAlgebra R K] {L : Type u_3}
[inst_3 : LieRing L] [inst_4 : LieAlgebra R L] (ψ : L →ₗ⁅R⁆ LieDerivation R K K) (t : R) (x : K ⋊⁅ψ⁆ L),
t • x = { left := t • x.left, right := t • x.right } | null | true |
AddUnits.instCoeHead | Mathlib.Algebra.Group.Units.Defs | {α : Type u} → [inst : AddMonoid α] → CoeHead (AddUnits α) α | An additive unit can be interpreted as a term in the base `AddMonoid`. | true |
_private.Init.Data.Nat.Lemmas.0.Nat.mul_add_mod.match_1_1 | Init.Data.Nat.Lemmas | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (_ : Unit), motive 0) → (∀ (x : ℕ), motive x.succ) → motive x | null | false |
CategoryTheory.Limits.ChosenPullback₃.p₁₂_p_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X₁ X₂ X₃ S : C} {f₁ : X₁ ⟶ S} {f₂ : X₂ ⟶ S} {f₃ : X₃ ⟶ S}
{h₁₂ : CategoryTheory.Limits.ChosenPullback f₁ f₂} {h₂₃ : CategoryTheory.Limits.ChosenPullback f₂ f₃}
{h₁₃ : CategoryTheory.Limits.ChosenPullback f₁ f₃} (h : CategoryTheory.Limits.ChosenPullback₃ h₁₂ ... | null | true |
ClassGroup.extendedHom_comp_apply | Mathlib.RingTheory.ClassGroup.ExtendedHom | ∀ (A : Type u_1) (B : Type u_2) [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B]
[inst_3 : Module.IsTorsionFree A B] [inst_4 : IsDedekindDomain A] (C : Type u_3) [inst_5 : CommRing C]
[inst_6 : Algebra B C] [inst_7 : Algebra A C] [IsScalarTower A B C] [inst_9 : Module.IsTorsionFree B C]
[inst_10 :... | null | true |
NumberField.Units.dirichletUnitTheorem.map_logEmbedding_sup_torsion | Mathlib.NumberTheory.NumberField.Units.DirichletTheorem | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (s : AddSubgroup (Additive (NumberField.RingOfIntegers K)ˣ)),
AddSubgroup.map (NumberField.Units.logEmbedding K) (s ⊔ Subgroup.toAddSubgroup (NumberField.Units.torsion K)) =
AddSubgroup.map (NumberField.Units.logEmbedding K) s | null | true |
FintypeCat.homMk_eq_comp_iff | Mathlib.CategoryTheory.FintypeCat | ∀ {X Y Z : FintypeCat} (f : X.obj → Y.obj) (g : Y.obj → Z.obj) (h : X.obj → Z.obj),
FintypeCat.homMk h = CategoryTheory.CategoryStruct.comp (FintypeCat.homMk f) (FintypeCat.homMk g) ↔ h = g ∘ f | null | true |
_private.Mathlib.Order.WithBot.0.WithBot.ofDual_le_iff._simp_1_1 | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LE α] {a : αᵒᵈ} {b : α}, (OrderDual.toDual b ≤ a) = (OrderDual.ofDual a ≤ b) | null | false |
PFunctor.Approx.CofixA.recOn | Mathlib.Data.PFunctor.Univariate.M | {F : PFunctor.{uA, uB}} →
{motive : (a : ℕ) → PFunctor.Approx.CofixA F a → Sort u} →
{a : ℕ} →
(t : PFunctor.Approx.CofixA F a) →
motive 0 PFunctor.Approx.CofixA.continue →
({n : ℕ} →
(a : F.A) →
(a_1 : F.B a → PFunctor.Approx.CofixA F n) →
(... | null | false |
Std.DTreeMap.Internal.Impl.SizedBalancedTree.toBalancedTree | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
{lb ub : ℕ} → Std.DTreeMap.Internal.Impl.SizedBalancedTree α β lb ub → Std.DTreeMap.Internal.Impl.BalancedTree α β | Transforms an element of `SizedBalancedTree` into a `BalancedTree`. | true |
IntermediateField.sup_toSubalgebra_of_isAlgebraic_left | Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra | ∀ {K : Type u_3} {L : Type u_4} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
(E1 E2 : IntermediateField K L) [Algebra.IsAlgebraic K ↥E1],
(E1 ⊔ E2).toSubalgebra = E1.toSubalgebra ⊔ E2.toSubalgebra | null | true |
Rat.commRing._proof_4 | Mathlib.Algebra.Ring.Rat | ∀ (n : ℕ), ↑(Int.negSucc n) = -↑(n + 1) | null | false |
derivWithin_pow | Mathlib.Analysis.Calculus.Deriv.Pow | ∀ {𝕜 : Type u_1} {𝔸 : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedCommRing 𝔸]
[inst_2 : NormedAlgebra 𝕜 𝔸] {f : 𝕜 → 𝔸} {x : 𝕜} {s : Set 𝕜},
DifferentiableWithinAt 𝕜 f s x → ∀ (n : ℕ), derivWithin (f ^ n) s x = ↑n * f x ^ (n - 1) * derivWithin f s x | null | true |
_private.Std.Data.String.ToNat.0.noRepetition_cons_append_append_iff.match_1_10 | Std.Data.String.ToNat | ∀ {α : Type u_1} {a : α} {l : List α} (motive : ¬l = [] ∧ ¬[a, a] <:+: l ∧ ¬[a] <+: l ∧ ¬[a] <:+ l → Prop)
(x : ¬l = [] ∧ ¬[a, a] <:+: l ∧ ¬[a] <+: l ∧ ¬[a] <:+ l),
(∀ (h₁ : ¬l = []) (h₂ : ¬[a, a] <:+: l) (h₃ : ¬[a] <+: l) (h₄ : ¬[a] <:+ l), motive ⋯) → motive x | null | false |
Std.Time.ExtendedDayPeriod.morning | Std.Time.Format.Modifier | Std.Time.ExtendedDayPeriod | 06:00–12:00
| true |
MeasureTheory.Lp.coeFn_fun_finsetSum | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {E : Type u_4} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] {ι : Type u_6} (s : Finset ι) (f : ι → ↥(MeasureTheory.Lp E p μ)),
↑↑(∑ i ∈ s, f i) =ᵐ[μ] fun x => ∑ i ∈ s, ↑↑(f i) x | null | true |
ProofWidgets.mkRefreshComponent | ProofWidgets.Component.RefreshComponent | optParam ProofWidgets.Html (ProofWidgets.Html.text "") → BaseIO (ProofWidgets.Html × ProofWidgets.RefreshToken) | Create a `RefreshComponent` instance together with a token to manage it. | true |
Char.card_pow_card | Mathlib.NumberTheory.GaussSum | ∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] {F' : Type u_2} [inst_2 : Field F'] [inst_3 : Fintype F']
{χ : MulChar F F'},
χ ≠ 1 →
χ.IsQuadratic →
ringChar F' ≠ ringChar F →
ringChar F' ≠ 2 → (χ (-1) * ↑(Fintype.card F)) ^ (Fintype.card F' / 2) = χ ↑(Fintype.card F') | When `F` and `F'` are finite fields and `χ : F → F'` is a nontrivial quadratic character,
then `(χ(-1) * #F)^(#F'/2) = χ #F'`. | true |
TopRep.Hom.casesOn | Mathlib.RepresentationTheory.Continuous.TopRep | {k : Type u} →
{G : Type v} →
[inst : TopologicalSpace k] →
[inst_1 : Ring k] →
[inst_2 : Monoid G] →
{A : TopRep k G} →
{B : TopRep k G} →
{motive : A.Hom B → Sort u_3} →
(t : A.Hom B) → ((hom' : ContIntertwiningMap A.ρ B.ρ) → motive { hom' := hom... | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity.0.continuousOn_cfc_setProd_nhdsSet.match_1_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | ∀ {𝕜 : Type u_1} {A : Type u_2} {p : A → Prop} [inst : RCLike 𝕜] [inst_1 : NormedRing A] [inst_2 : NormedAlgebra 𝕜 A]
{s : Set 𝕜}
(motive :
(x : UniformOnFun 𝕜 𝕜 {t | IsCompact t ∧ t ⊆ s} × A) →
x ∈
{f | ContinuousOn ((UniformOnFun.toFun {t | IsCompact t ∧ t ⊆ s}) f) s} ×ˢ
{a |... | null | false |
BitVec.getElem_neg | Init.Data.BitVec.Bitblast | ∀ {w i : ℕ} {x : BitVec w} (h : i < w), (-x)[i] = (x[i] ^^ decide (∃ j < i, x.getLsbD j = true)) | null | true |
Lean.Elab.addPreDefInfo | Lean.Elab.PreDefinition.Basic | Lean.Elab.PreDefinition → Lean.Elab.TermElabM Unit | Adds constant info to the definition name. This should occur after executing post-compilation
attributes, in case they have an effect on hovers.
| true |
HahnSeries.map.congr_simp | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_3} {S : Type u_4} [inst : PartialOrder Γ] [inst_1 : Zero R] [inst_2 : Zero S]
(x x_1 : HahnSeries Γ R),
x = x_1 →
∀ {F : Type u_5} [inst_3 : FunLike F R S] [inst_4 : ZeroHomClass F R S] (f f_1 : F), f = f_1 → x.map f = x_1.map f_1 | null | true |
_private.Mathlib.Probability.Independence.Integration.0.ProbabilityTheory.lintegral_mul_indicator_eq_lintegral_mul_lintegral_indicator._simp_1_2 | Mathlib.Probability.Independence.Integration | ∀ {α : Type u_1} {m : MeasurableSpace α}, MeasurableSet Set.univ = True | null | false |
_private.Mathlib.CategoryTheory.Monoidal.Cartesian.Basic.0.CategoryTheory.CartesianMonoidalCategory.associator_hom_snd_fst._simp_1_1 | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C) {Z : C}
(h : CategoryTheory.MonoidalCategoryStruct.tensorObj X Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator X Y (CategoryTheory.MonoidalCategoryStruct... | null | false |
Int32.ofNat_add | Init.Data.SInt.Lemmas | ∀ (a b : ℕ), Int32.ofNat (a + b) = Int32.ofNat a + Int32.ofNat b | null | true |
Sat.Literal.noConfusion | Mathlib.Tactic.Sat.FromLRAT | {P : Sort u} → {t t' : Sat.Literal} → t = t' → Sat.Literal.noConfusionType P t t' | null | false |
MonoidWithZeroHom.instGroupWithZeroSubtypeMemSubmonoidMrange | Mathlib.Algebra.GroupWithZero.Submonoid.Instances | {G : Type u_1} →
{H : Type u_2} →
[inst : GroupWithZero G] → [inst_1 : GroupWithZero H] → (f : G →*₀ H) → GroupWithZero ↥(MonoidHom.mrange f) | null | true |
_private.Mathlib.Algebra.Group.Subgroup.Ker.0.MonoidHom.domRestrict_range._simp_1_4 | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
AddEquiv.withTopCongr._proof_1 | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u_1} {β : Type u_2} [inst : Add α] [inst_1 : Add β] (e : α ≃+ β) (x y : WithTop α),
e.toAddHom.withBotMap.toFun (x + y) = e.toAddHom.withBotMap.toFun x + e.toAddHom.withBotMap.toFun y | null | false |
Semigrp.Hom._mkInternal._flat_ctor | Mathlib.Algebra.Category.Semigrp.Basic | {A B : Semigrp} → (↑A →ₙ* ↑B) → A.Hom B | null | false |
Lean.TagDeclarationExtension | Lean.EnvExtension | Type | Environment extension for tagging declarations.
Declarations must only be tagged in the module where they were declared. | true |
openSegment_subset_segment | Mathlib.Analysis.Convex.Segment | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : SMul 𝕜 E] (x y : E), openSegment 𝕜 x y ⊆ segment 𝕜 x y | null | true |
Lean.Compiler.LCNF.Phase.toNat | Lean.Compiler.LCNF.PassManager | Lean.Compiler.LCNF.Phase → ℕ | null | true |
Units.isOpenEmbedding_val | Mathlib.Analysis.Normed.Ring.Units | ∀ {R : Type u_1} [inst : NormedRing R] [HasSummableGeomSeries R], Topology.IsOpenEmbedding Units.val | In a normed ring with summable geometric series, the coercion from `Rˣ` (equipped with the
induced topology from the embedding in `R × R`) to `R` is an open embedding. | true |
Equiv.starRing | Mathlib.Algebra.Star.TransferInstance | {R : Type u_1} → {S : Type u_2} → (e : R ≃ S) → [inst : NonUnitalNonAssocSemiring S] → [StarRing S] → StarRing R | Transfer `StarRing` across an `Equiv`. See note [reducible non-instances]. | true |
AlgebraicGeometry.Scheme.instIsOverMapStalkSpecializesCommRingCatPresheaf | Mathlib.AlgebraicGeometry.Stalk | ∀ {X : AlgebraicGeometry.Scheme} {x y : ↥X} (h : x ⤳ y),
AlgebraicGeometry.Scheme.Hom.IsOver (AlgebraicGeometry.Spec.map (X.presheaf.stalkSpecializes h)) X | null | true |
Algebra.Extension.infinitesimal.eq_1 | Mathlib.RingTheory.Smooth.Kaehler | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(P : Algebra.Extension R S),
P.infinitesimal =
{ Ring := P.Ring ⧸ P.ker ^ 2, commRing := Ideal.Quotient.commRing (P.ker ^ 2),
algebra₁ := Ideal.instAlgebraQuotient R (P.ker ^ 2), algebra₂ := Ideal.Algebra.kerSquar... | null | true |
HSpaces._aux_Mathlib_Topology_Homotopy_HSpaces___unexpand_HSpace_hmul_1 | Mathlib.Topology.Homotopy.HSpaces | Lean.PrettyPrinter.Unexpander | null | false |
List.getRest._sunfold | Batteries.Data.List.Basic | {α : Type u_1} → [DecidableEq α] → List α → List α → Option (List α) | null | false |
PredOrder.pred | Mathlib.Order.SuccPred.Basic | {α : Type u_3} → {inst : Preorder α} → [self : PredOrder α] → α → α | Predecessor function | true |
Stream'.Seq.mem_cons_of_mem | Mathlib.Data.Seq.Defs | ∀ {α : Type u} (y : α) {a : α} {s : Stream'.Seq α}, a ∈ s → a ∈ Stream'.Seq.cons y s | null | true |
_private.Mathlib.Analysis.FunctionalSpaces.SobolevInequality.0.«_aux_Mathlib_Analysis_FunctionalSpaces_SobolevInequality___macroRules__private_Mathlib_Analysis_FunctionalSpaces_SobolevInequality_0_term#__1» | Mathlib.Analysis.FunctionalSpaces.SobolevInequality | Lean.Macro | null | false |
_private.Mathlib.Probability.ProductMeasure.0.MeasureTheory.Measure.infinitePi_pi_of_countable._simp_1_5 | Mathlib.Probability.ProductMeasure | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [MeasureTheory.IsZeroOrProbabilityMeasure μ]
{s : Set α}, (μ s ≤ 1) = True | null | false |
_private.Mathlib.LinearAlgebra.PiTensorProduct.Basis.0.Basis.piTensorProduct_apply._simp_1_1 | Mathlib.LinearAlgebra.PiTensorProduct.Basis | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) = (f = g) | null | false |
Filter.Germ.liftPred_const | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} {p : β → Prop} {x : β}, p x → Filter.Germ.LiftPred p ↑x | null | true |
SummationFilter.NeBot.ne_bot | Mathlib.Topology.Algebra.InfiniteSum.SummationFilter | ∀ {β : Type u_2} {L : SummationFilter β} [self : L.NeBot], L.filter.NeBot | null | true |
Mathlib.Tactic.TFAE.Parser.impFrom.formatter | Mathlib.Tactic.TFAE | Lean.PrettyPrinter.Formatter | null | true |
Set.Nonempty.right | Mathlib.Data.Set.Basic | ∀ {α : Type u} {s t : Set α}, (s ∩ t).Nonempty → t.Nonempty | null | true |
exteriorPower.wedge_apply_of_disjoint | Mathlib.LinearAlgebra.ExteriorPower.WedgePairing | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {k l : ℕ}
{ι : Type u_3} [inst_3 : LinearOrder ι] (b : Module.Basis ι R M) [inst_4 : Fintype ι],
k + l = Fintype.card ι →
∀ {I : ↑(Set.powersetCard ι k)} {J : ↑(Set.powersetCard ι l)},
Disjoint ↑I ↑J →
... | null | true |
CategoryTheory.Retract.projective | Mathlib.CategoryTheory.Preadditive.Projective.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (h : CategoryTheory.Retract X Y)
[p : CategoryTheory.Projective Y], CategoryTheory.Projective X | null | true |
Filter.map₂_inf_subset_left | Mathlib.Order.Filter.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f₁ f₂ : Filter α} {g : Filter β},
Filter.map₂ m (f₁ ⊓ f₂) g ≤ Filter.map₂ m f₁ g ⊓ Filter.map₂ m f₂ g | null | true |
StandardEtalePair.lift.eq_1 | Mathlib.RingTheory.Etale.StandardEtale | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(P : StandardEtalePair R) (x : S) (h : P.HasMap x),
P.lift x h =
Ideal.Quotient.liftₐ (Ideal.span {Polynomial.C P.f, Polynomial.X * Polynomial.C P.g - 1})
(Polynomial.aevalAeval x ↑⋯.unit⁻¹) ⋯ | null | true |
RatFunc.CompletionAtInfty | Mathlib.FieldTheory.RatFunc.Valuation | (F : Type u_1) → [inst : Field F] → [DecidableEq (RatFunc F)] → Type u_1 | The completion `F((t⁻¹))` of `F(t)` with respect to the valuation at infinity. | true |
MeasureTheory.Filtration.piFinset | Mathlib.Probability.Process.Filtration | {ι : Type u_4} →
{X : ι → Type u_5} → [inst : (i : ι) → MeasurableSpace (X i)] → MeasureTheory.Filtration (Finset ι) MeasurableSpace.pi | The filtration of events which only depends on finitely many coordinates
on the product space `Π i, X i`, `piFinset s` consists of measurable sets depending only on
coordinates in `s`, where `s : Finset ι`. | true |
CpltSepUniformSpace.coe_of | Mathlib.Topology.Category.UniformSpace | ∀ (X : Type u) [inst : UniformSpace X] [inst_1 : CompleteSpace X] [inst_2 : T0Space X], (↧X).α = X | null | true |
_private.Mathlib.Algebra.Exact.Sequence.0.Module.sum_neg_one_pow_finrank_eq_zero_of_exact_six._simp_1_1 | Mathlib.Algebra.Exact.Sequence | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_4} {P : Type u_6} {P' : Type u_7} [inst : Semiring R]
[inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : AddCommMonoid P']
[inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R P] [inst_8 : Module R P'] {f : M →ₗ[R] N}
{g... | null | false |
Std.HashSet.Raw.get!_diff | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.HashSet.Raw α} [EquivBEq α] [LawfulHashable α]
[inst_4 : Inhabited α], m₁.WF → m₂.WF → ∀ {k : α}, (m₁ \ m₂).get! k = if k ∈ m₂ then default else m₁.get! k | null | true |
_private.Mathlib.RingTheory.LocalProperties.InjectiveDimension.0.ModuleCat.localizedModule_hasInjectiveDimensionLE._simp_1_1 | Mathlib.RingTheory.LocalProperties.InjectiveDimension | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X : C},
CategoryTheory.HasInjectiveDimensionLT X 1 = CategoryTheory.Injective X | null | false |
Std.DTreeMap.Internal.Impl.empty | Std.Data.DTreeMap.Internal.Operations | {α : Type u} → {β : α → Type v} → Std.DTreeMap.Internal.Impl α β | An empty tree. | true |
ContinuousMapZero.nonUnitalStarAlgHom_precomp | Mathlib.Topology.ContinuousMap.ContinuousMapZero | {X : Type u_1} →
{Y : Type u_2} →
(R : Type u_4) →
[inst : Zero X] →
[inst_1 : Zero Y] →
[inst_2 : TopologicalSpace X] →
[inst_3 : TopologicalSpace Y] →
[inst_4 : TopologicalSpace R] →
[inst_5 : CommSemiring R] →
[inst_6 : StarRin... | The functor `C(·, R)₀` from topological spaces with zero (and `ContinuousMapZero` maps) to
non-unital star algebras. | true |
_private.Mathlib.SetTheory.Cardinal.NatCount.0.Nat.count_le_setENCard._simp_1_1 | Mathlib.SetTheory.Cardinal.NatCount | ∀ {c : Cardinal.{u}} {n : ℕ}, (↑n ≤ Cardinal.toENat c) = (↑n ≤ c) | null | false |
CategoryTheory.ObjectProperty.limitsClosure.below.of_mem | Mathlib.CategoryTheory.ObjectProperty.LimitsClosure | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.ObjectProperty C} {α : Type t}
{J : α → Type u'} [inst_1 : (a : α) → CategoryTheory.Category.{v', u'} (J a)]
{motive : (a : C) → P.limitsClosure J a → Prop} (X : C) (hX : P X),
CategoryTheory.ObjectProperty.limitsClosure.below ⋯ | null | true |
Set.Icc_top | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : OrderTop α] {a : α}, Set.Icc a ⊤ = Set.Ici a | null | true |
List.swapAt_def | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {i : ℕ} {v : α}, xs.swapAt i v = (xs[i]?.getD v, xs.set i v) | null | true |
RatFunc._sizeOf_inst | Mathlib.FieldTheory.RatFunc.Defs | (K : Type u) → {inst : CommRing K} → [SizeOf K] → SizeOf (RatFunc K) | null | false |
CategoryTheory.ObjectProperty.instNonemptyUnopOfOpposite | Mathlib.CategoryTheory.ObjectProperty.Opposite | ∀ {C : Type u} [inst : CategoryTheory.CategoryStruct.{v, u} C] (P : CategoryTheory.ObjectProperty Cᵒᵖ) [P.Nonempty],
P.unop.Nonempty | null | true |
RingCat.instConcreteCategoryRingHomCarrier._proof_4 | Mathlib.Algebra.Category.Ring.Basic | ∀ {X Y Z : RingCat} (f : X ⟶ Y) (g : Y ⟶ Z) (x : ↑X),
(CategoryTheory.CategoryStruct.comp f g).hom' x = g.hom' (f.hom' x) | null | false |
Finset.iSup_singleton | Mathlib.Order.CompleteLattice.Finset | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice β] (a : α) (s : α → β), ⨆ x ∈ {a}, s x = s a | null | true |
Std.ExtTreeMap.minKeyD_insertIfNew_of_isEmpty | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β}, t.isEmpty = true → ∀ {fallback : α}, (t.insertIfNew k v).minKeyD fallback = k | null | true |
minpoly.dvd_iff | Mathlib.FieldTheory.Minpoly.Field | ∀ {A : Type u_1} {B : Type u_2} [inst : Field A] [inst_1 : Ring B] [inst_2 : Algebra A B] {x : B} {p : Polynomial A},
minpoly A x ∣ p ↔ (Polynomial.aeval x) p = 0 | null | true |
_private.Mathlib.Order.Types.Defs.0.OrderType.lift._proof_1 | Mathlib.Order.Types.Defs | ∀ (_α : Type u_1) (x : LinearOrder _α) (_β : Type u_1) (x_1 : LinearOrder _β),
OrderType.type _α = OrderType.type _β → OrderType.type (ULift.{u_2, u_1} _α) = OrderType.type (ULift.{u_2, u_1} _β) | null | false |
CategoryTheory.GradedObject.ι_mapBifunctorComp₂₃MapObjIso_hom_assoc | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {C₂₃ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_4} C₄]
[inst_4 : CategoryTheory.Category.{v_... | null | true |
commHopfAlgCatEquivCogrpCommAlgCat._proof_9 | Mathlib.Algebra.Category.CommHopfAlgCat | ∀ (R : Type u_1) [inst : CommRing R],
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id (CategoryTheory.Functor.id (CommHopfAlgCat R)))
(CategoryTheory.CategoryStruct.id
({ obj := fun A => Opposite.op { X := Opposite.op ↧↑A, grp := CommAlgCat.grpObjOpOf },
map := fun {A ... | null | false |
_private.Init.Data.List.TakeDrop.0.List.dropWhile_beq_eq_self_of_head?_ne._simp_1_1 | Init.Data.List.TakeDrop | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α}, ((a == b) = true) = (a = b) | null | false |
ProbabilityTheory.uncenteredCovarianceBilinDual._proof_8 | Mathlib.Probability.Moments.CovarianceBilinDual | SMulCommClass ℝ ℝ ℝ | null | false |
Derivation.mk'._proof_2 | Mathlib.RingTheory.Derivation.Basic | ∀ {R : Type u_3} [inst : CommSemiring R] {A : Type u_2} [inst_1 : CommSemiring A] [inst_2 : Algebra R A] {M : Type u_1}
[inst_3 : AddCancelCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M] (D : A →ₗ[R] M),
(∀ (a b : A), D (a * b) = a • D b + b • D a) → D 1 = 0 | null | false |
Set.biUnion_diff_biUnion_subset | Mathlib.Data.Set.Lattice.Bounded | ∀ {α : Type u_1} {β : Type u_2} (t : α → Set β) (s₁ s₂ : Set α), (⋃ x ∈ s₁, t x) \ ⋃ x ∈ s₂, t x ⊆ ⋃ x ∈ s₁ \ s₂, t x | **Alias** of `Set.biUnion_sdiff_biUnion_subset`. | true |
SemiRingCat.limitSemiring._proof_10 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J SemiRingCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget SemiRingCat)).sections],
autoParam
(∀ (x : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget SemiRingCat))).pt), ... | null | false |
ContinuousLinearMap.module._proof_1 | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Basic | ∀ {R : Type u_1} {R₃ : Type u_2} {S₃ : Type u_5} [inst : Semiring R] [inst_1 : Semiring R₃] [inst_2 : Semiring S₃]
{M : Type u_3} [inst_3 : TopologicalSpace M] [inst_4 : AddCommMonoid M] [inst_5 : Module R M] {M₃ : Type u_4}
[inst_6 : TopologicalSpace M₃] [inst_7 : AddCommMonoid M₃] [inst_8 : Module R₃ M₃] [inst_9 ... | null | false |
CategoryTheory.Limits.coconeOpEquiv_counitIso | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C},
CategoryTheory.Limits.coconeOpEquiv.counitIso =
CategoryTheory.Iso.refl
({ obj := fun c => Opposite.op c.unop, map := fun {Y X} f => Opposite.op { hom :... | null | true |
Function.Periodic.map_vadd_multiples | Mathlib.Algebra.Ring.Periodic | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c : α} [inst : AddCommMonoid α],
Function.Periodic f c → ∀ (a : ↥(AddSubmonoid.multiples c)) (x : α), f (a +ᵥ x) = f x | null | true |
integral_log_sin_zero_pi | Mathlib.Analysis.SpecialFunctions.Integrals.Log | ∫ (x : ℝ) in 0..Real.pi, Real.log (Real.sin x) = -Real.log 2 * Real.pi | The integral of `log ∘ sin` on `0 … π` equals `-log 2 * π`.
| true |
AddMonoidHom.coprod_inl_inr | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_6} {N : Type u_7} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N],
(AddMonoidHom.inl M N).coprod (AddMonoidHom.inr M N) = AddMonoidHom.id (M × N) | null | true |
ArithmeticFunction.sigma_one | Mathlib.NumberTheory.ArithmeticFunction.Misc | ∀ (k : ℕ), (ArithmeticFunction.sigma k) 1 = 1 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.