name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Cat.opEquivalence_counitIso | Mathlib.CategoryTheory.Category.Cat.Op | CategoryTheory.Cat.opEquivalence.counitIso =
CategoryTheory.NatIso.ofComponents
(fun x =>
{ hom := (CategoryTheory.unopUnop ↑x).toCatHom, inv := (CategoryTheory.opOp ↑x).toCatHom, hom_inv_id := ⋯,
inv_hom_id := ⋯ })
@CategoryTheory.Cat.opEquivalence._proof_4 | null | true |
_private.Lean.Util.ParamMinimizer.0.Lean.Util.ParamMinimizer.Context.mk.noConfusion | Lean.Util.ParamMinimizer | {m : Type → Type} →
{P : Sort u} →
{initialMask : Array Bool} →
{test : Array Bool → m Bool} →
{maxCalls : ℕ} →
{initialMask' : Array Bool} →
{test' : Array Bool → m Bool} →
{maxCalls' : ℕ} →
{ initialMask := initialMask, test := test, maxCalls := ... | null | false |
Turing.ToPartrec.stepNormal | Mathlib.Computability.TuringMachine.Config | Turing.ToPartrec.Code → Turing.ToPartrec.Cont → List ℕ → Turing.ToPartrec.Cfg | Evaluating `c : Code` in a continuation `k : Cont` and input `v : List ℕ`. This goes by
recursion on `c`, building an augmented continuation and a value to pass to it.
* `zero' v = 0 :: v` evaluates immediately, so we return it to the parent continuation
* `succ v = [v.headI.succ]` evaluates immediately, so we return ... | true |
Int.even_add._simp_1 | Mathlib.Algebra.Group.Int.Even | ∀ {m n : ℤ}, Even (m + n) = (Even m ↔ Even n) | null | false |
tendsto_of_liminf_eq_limsup | Mathlib.Topology.Order.LiminfLimsup | ∀ {α : Type u_2} {β : Type u_3} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α]
[OrderTopology α] {f : Filter β} {u : β → α} {a : α},
Filter.liminf u f = a →
Filter.limsup u f = a →
autoParam (Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f u) tendsto_of_liminf_eq_limsup._auto_1 →... | If the liminf and the limsup of a function coincide, then the limit of the function
exists and has the same value. | true |
AddAction.vadd_zsmul_fixedBy_eq_of_addCommute | Mathlib.GroupTheory.GroupAction.FixedPoints | ∀ {α : Type u_1} {G : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] {g h : G},
AddCommute g h → ∀ (j : ℤ), j • h +ᵥ AddAction.fixedBy α g = AddAction.fixedBy α g | If `g` and `h` commute, then `g` fixes `(j • h) +ᵥ x` iff `g` fixes `x`. | true |
_private.Mathlib.NumberTheory.NumberField.Cyclotomic.Three.0.IsCyclotomicExtension.Rat.Three.eq_one_or_neg_one_of_unit_of_congruent._simp_1_1 | Mathlib.NumberTheory.NumberField.Cyclotomic.Three | ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b : α), -a + -b = -(a + b) | null | false |
UInt16.toUInt32_shiftRight | Init.Data.UInt.Bitwise | ∀ (a b : UInt16), (a >>> b).toUInt32 = a.toUInt32 >>> (b.toUInt32 % 16) | null | true |
_private.Lean.Meta.Tactic.Simp.Main.0.Lean.Meta.Simp.lambdaTelescopeDSimp.go._sparseCasesOn_1 | Lean.Meta.Tactic.Simp.Main | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
(Nat.hasNotBit 64 t.ctorIdx → motive t) → motive t | null | false |
Aesop.Index.recOn | Aesop.Index | {α : Type} →
{motive : Aesop.Index α → Sort u} →
(t : Aesop.Index α) →
((byTarget byHyp : Lean.Meta.DiscrTree (Aesop.Rule α)) →
(unindexed : Lean.PHashSet (Aesop.Rule α)) →
motive { byTarget := byTarget, byHyp := byHyp, unindexed := unindexed }) →
motive t | null | false |
Path.Homotopy.symm₂._proof_5 | Mathlib.Topology.Homotopy.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x₀ x₁ : X} {p q : Path x₀ x₁} (F : p.Homotopy q) (t x : ↑unitInterval),
x ∈ {0, 1} →
{ toFun := fun x => F ((t, x).1, unitInterval.symm (t, x).2), continuous_toFun := ⋯ } x = p.symm.toContinuousMap x | null | false |
Subfield.coe_copy | Mathlib.Algebra.Field.Subfield.Defs | ∀ {K : Type u} [inst : DivisionRing K] (S : Subfield K) (s : Set K) (hs : s = ↑S), ↑(S.copy s hs) = s | null | true |
CategoryTheory.Abelian.Ext.postcomp_smul_id_mono_iff | Mathlib.Algebra.Category.ModuleCat.Ext.Basic | ∀ {R : Type u} [inst : CommRing R] [inst_1 : Small.{v, u} R] {M N : ModuleCat R} (r : R) (i : ℕ),
CategoryTheory.Mono
(AddCommGrpCat.ofHom ((CategoryTheory.Abelian.Ext.mk₀ (r • CategoryTheory.CategoryStruct.id M)).postcomp N ⋯)) ↔
IsSMulRegular (CategoryTheory.Abelian.Ext N M i) r | `r • 𝟙 M` induces a monomorphism in `Ext M N n` if and only if scalar multiplication by `r`
is faithful on `Ext M N n`. | true |
OrderMonoidIso.Simps.symm_apply | Mathlib.Algebra.Order.Hom.Monoid | {α : Type u_2} →
{β : Type u_3} → [inst : Preorder α] → [inst_1 : Preorder β] → [inst_2 : Mul α] → [inst_3 : Mul β] → (α ≃*o β) → β → α | See Note [custom simps projection] | true |
Lean.Grind.CommRing.Poly.brecOn | Init.Grind.Ring.CommSolver | {motive : Lean.Grind.CommRing.Poly → Sort u} →
(t : Lean.Grind.CommRing.Poly) →
((t : Lean.Grind.CommRing.Poly) → Lean.Grind.CommRing.Poly.below t → motive t) → motive t | null | false |
CommBialgCat.of | Mathlib.Algebra.Category.CommBialgCat | (R : Type u) → [inst : CommRing R] → (X : Type v) → [inst_1 : CommRing X] → [Bialgebra R X] → CommBialgCat R | Turn an unbundled `R`-bialgebra into the corresponding object in the category of `R`-bialgebras.
This is the preferred way to construct a term of `CommBialgCat R`. | true |
Subalgebra.lTensorBot_symm_apply | Mathlib.LinearAlgebra.TensorProduct.Subalgebra | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S]
{A : Subalgebra R S} (a : ↥A), A.lTensorBot.symm a = 1 ⊗ₜ[R] a | null | true |
Eq.ndrec | Init.Prelude | {α : Sort u2} → {a : α} → {motive : α → Sort u1} → motive a → {b : α} → a = b → motive b | Non-dependent recursor for the equality type. | false |
CategoryTheory.Over.tensorHom_left_fst | Mathlib.CategoryTheory.Monoidal.Cartesian.Over | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C]
{X S U : C} {R T : CategoryTheory.Over X} (fS : S ⟶ X) (fU : U ⟶ X) (f : R ⟶ CategoryTheory.Over.mk fS)
(g : T ⟶ CategoryTheory.Over.mk fU),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Over.... | null | true |
_private.Mathlib.NumberTheory.SmoothNumbers.0.Nat.equivProdNatFactoredNumbers._proof_9 | Mathlib.NumberTheory.SmoothNumbers | ∀ {s : Finset ℕ} {p : ℕ},
p ∉ s →
∀ (m : ℕ),
(∀ p_1 ∈ m.primeFactorsList, p_1 ∈ insert p s) → ∀ x ∈ m.primeFactorsList, decide (x = p) = decide (x ∉ s) | null | false |
Nat.Internal.Linear.PolyCnstr.eq_false_of_isUnsat | Init.Data.Nat.Internal.Linear | ∀ (ctx : Nat.Internal.Linear.Context) {c : Nat.Internal.Linear.PolyCnstr},
c.isUnsat = true → Nat.Internal.Linear.PolyCnstr.denote ctx c = False | null | true |
_private.Mathlib.Analysis.Complex.Basic.0.Complex.subset_slitPlane_iff_of_subset_sphere._simp_1_1 | Mathlib.Analysis.Complex.Basic | ∀ {z : ℂ}, (z ∈ Complex.slitPlane) = ¬z ≤ 0 | null | false |
HasCompactMulSupport.one | Mathlib.Topology.Algebra.Support | ∀ {α : Type u_9} {β : Type u_10} [inst : TopologicalSpace α] [inst_1 : One β], HasCompactMulSupport 1 | null | true |
String.Slice.takeEndWhile_prop_eq_takeEndWhile_decide | Init.Data.String.Lemmas.Pattern.Pred | ∀ {p : Char → Prop} [inst : DecidablePred p] {s : String.Slice}, s.takeEndWhile p = s.takeEndWhile fun x => decide (p x) | null | true |
Filter.mulActionFilter._proof_2 | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} {β : Type u_1} [inst : Monoid α] [inst_1 : MulAction α β] (a b : α) (f : Filter β),
(a * b) • f = a • b • f | null | false |
CategoryTheory.Limits.pullbackLeftPullbackSndIso | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W X Y Z : C} →
(f : X ⟶ Z) →
(g : Y ⟶ Z) →
(g' : W ⟶ Y) →
[inst_1 : CategoryTheory.Limits.HasPullback f g] →
[inst_2 : CategoryTheory.Limits.HasPullback (CategoryTheory.Limits.pullback.snd f g) g'] →
... | The canonical isomorphism `(X ×[Z] Y) ×[Y] W ≅ X ×[Z] W` | true |
ModuleCat.instProjectiveObjFree | Mathlib.Algebra.Category.ModuleCat.LeftResolution | ∀ (R : Type u) [inst : Ring R] (X : Type u), CategoryTheory.Projective ((ModuleCat.free R).obj X) | null | true |
HasCardinalLT.of_injective | Mathlib.SetTheory.Cardinal.HasCardinalLT | ∀ {X : Type u} {κ : Cardinal.{v}},
HasCardinalLT X κ → ∀ {Y : Type u'} (f : Y → X), Function.Injective f → HasCardinalLT Y κ | null | true |
CategoryTheory.IsPushout.epi_inr_of_epi._auto_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Basic | Lean.Syntax | null | false |
Bool.Internal.and | Init.Prelude | Bool → Bool → Bool | Boolean “and”, also known as conjunction. `and x y` can be written `x && y`.
The corresponding propositional connective is `And : Prop → Prop → Prop`, written with the `∧`
operator.
The Boolean `and` is a `@[macro_inline]` function in order to give it short-circuiting evaluation:
if `x` is `false` then `y` is not eva... | true |
_private.Mathlib.CategoryTheory.MorphismProperty.Quotient.0.CategoryTheory.MorphismProperty.quotient_iff.match_1_1 | Mathlib.CategoryTheory.MorphismProperty.Quotient | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (W : CategoryTheory.MorphismProperty C)
(homRel : HomRel C) [inst_1 : CategoryTheory.HomRel.IsStableUnderPrecomp homRel]
[inst_2 : CategoryTheory.HomRel.IsStableUnderPostcomp homRel] [inst_3 : W.HasQuotient homRel] {X Y : C} (f : X ⟶ Y)
(motive : W.qu... | null | false |
Set.bijOn_comp_iff | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {s : Set α} {p : Set γ} {f : α → β} {g : β → γ},
Set.InjOn f s → (Set.BijOn (g ∘ f) s p ↔ Set.BijOn g (f '' s) p) | If `f : α → β` and `g : β → γ` and if `f` is injective on `s`, then `g ∘ f` is a bijection
on `s` iff `g` is a bijection on `f '' s`. | true |
Fintype.sum_eq_zero_iff_of_nonpos | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_8} {M : Type u_9} [inst : Fintype ι] [inst_1 : AddCommMonoid M] [inst_2 : PartialOrder M]
[IsOrderedAddMonoid M] {f : ι → M}, f ≤ 0 → (∑ i, f i = 0 ↔ f = 0) | null | true |
Antivary.dual_left | Mathlib.Order.Monotone.Monovary | ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {f : ι → α} {g : ι → β},
Antivary f g → Monovary (⇑OrderDual.toDual ∘ f) g | null | true |
USize.toUSize_toUInt32 | Init.Data.UInt.Lemmas | ∀ (n : USize), n.toUInt32.toUSize = n % 4294967296 | null | true |
CategoryTheory.LocallyDiscrete._sizeOf_inst | Mathlib.CategoryTheory.Bicategory.LocallyDiscrete | (C : Type u) → [SizeOf C] → SizeOf (CategoryTheory.LocallyDiscrete C) | null | false |
Std.Rcc.size | Init.Data.Range.Polymorphic.Iterators | {α : Type u} → [Std.Rxc.HasSize α] → Std.Rcc α → ℕ | Returns the number of elements contained in the given closed range.
| true |
_private.Lean.Environment.0.Lean.EnvExtension.getStateUnsafe.match_10 | Lean.Environment | (motive : Option Lean.AsyncConst✝ → Sort u_1) →
(parent? : Option Lean.AsyncConst✝) →
((c : Lean.AsyncConst✝) → motive (some c)) → (Unit → motive none) → motive parent? | null | false |
HahnSeries.instRing._proof_5 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : Ring R] (a : HahnSeries Γ R), -a + a = 0 | null | false |
cfcₙ_eq_cfcₙL | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [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 :... | null | true |
Batteries.Tactic.GeneralizeProofs.MAbs.findProof? | Batteries.Tactic.GeneralizeProofs | Lean.Expr → Batteries.Tactic.GeneralizeProofs.MAbs (Option Lean.Expr) | Finds a proof of `prop` by looking at `propToFVar` and `propToProof`.
| true |
_private.Mathlib.RingTheory.TwoSidedIdeal.Operations.0.TwoSidedIdeal.mem_span_iff_mem_addSubgroup_closure_absorbing._simp_1_2 | Mathlib.RingTheory.TwoSidedIdeal.Operations | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | null | false |
Turing.TM1to1.readAux._sunfold | Mathlib.Computability.TuringMachine.PostTuringMachine | {Γ : Type u_1} →
{Λ : Type u_2} →
{σ : Type u_3} →
(n : ℕ) →
(List.Vector Bool n → Turing.TM1.Stmt Bool (Turing.TM1to1.Λ' Γ Λ σ) σ) →
Turing.TM1.Stmt Bool (Turing.TM1to1.Λ' Γ Λ σ) σ | null | false |
HomogeneousIdeal.irrelevant_eq_span | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddCommMonoid ι]
[inst_3 : PartialOrder ι] [inst_4 : CanonicallyOrderedAdd ι] [inst_5 : SetLike σ A] [inst_6 : AddSubmonoidClass σ A]
(𝒜 : ι → σ) [inst_7 : GradedRing 𝒜], (HomogeneousIdeal.irrelevant 𝒜).toIdeal ... | null | true |
EsakiaHom.mk.injEq | Mathlib.Topology.Order.Hom.Esakia | ∀ {α : Type u_6} {β : Type u_7} [inst : TopologicalSpace α] [inst_1 : Preorder α] [inst_2 : TopologicalSpace β]
[inst_3 : Preorder β] (toContinuousOrderHom : α →Co β)
(exists_map_eq_of_map_le' :
∀ ⦃a : α⦄ ⦃b : β⦄, toContinuousOrderHom.toFun a ≤ b → ∃ c, a ≤ c ∧ toContinuousOrderHom.toFun c = b)
(toContinuousO... | null | true |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.getEntryGE?ₘ'.match_1.splitter | Std.Data.DTreeMap.Internal.Model | {α : Type u_2} →
{β : α → Type u_1} →
[inst : Ord α] →
(k : α) →
(motive : Option ((a : α) × β a) → Std.DTreeMap.Internal.Impl.ExplorationStep α β (compare k) → Sort u_3) →
(x : Option ((a : α) × β a)) →
(x_1 : Std.DTreeMap.Internal.Impl.ExplorationStep α β (compare k)) →
... | null | true |
CategoryTheory.StrictlyUnitaryLaxFunctor.comp_map₂ | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C] {D : Type u₃}
[inst_2 : CategoryTheory.Bicategory D] (F : CategoryTheory.StrictlyUnitaryLaxFunctor B C)
(G : CategoryTheory.StrictlyUnitaryLaxFunctor C D) {a b : B} {f g : a ⟶ b} (η : f ⟶ g),
(F.comp G).map₂ ... | null | true |
Std.Internal.UV.System.RUsage.ctorIdx | Std.Internal.UV.System | Std.Internal.UV.System.RUsage → ℕ | null | false |
_private.Mathlib.Topology.Connected.PathConnected.0.isPathConnected_iff.match_1_1 | Mathlib.Topology.Connected.PathConnected | ∀ {X : Type u_1} [inst : TopologicalSpace X] {F : Set X} (motive : IsPathConnected F → Prop) (h : IsPathConnected F),
(∀ (b : X) (b_in : b ∈ F) (_hb : ∀ ⦃y : X⦄, y ∈ F → JoinedIn F b y), motive ⋯) → motive h | null | false |
_private.Mathlib.Basic.Real.ConjExponents.0.ENNReal.HolderTriple.toNNReal_iff._simp_1_1 | Mathlib.Basic.Real.ConjExponents | ∀ {p q r : NNReal}, p.HolderTriple q r = (↑p).HolderTriple ↑q ↑r | null | false |
Std.Async.TCP.Socket.Server.tryAccept | Std.Async.TCP | Std.Async.TCP.Socket.Server → IO (Option Std.Async.TCP.Socket.Client) | Tries to accept an incoming connection.
| true |
Algebra.IsStandardEtale.mk | Mathlib.RingTheory.Etale.StandardEtale | ∀ {R : Type u_4} {S : Type u_5} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
Nonempty (StandardEtalePresentation R S) → Algebra.IsStandardEtale R S | null | true |
CategoryTheory.Limits.WidePushout.hom_ext_iff | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {B : C} {objs : J → C}
{arrows : (j : J) → B ⟶ objs j} [inst_1 : CategoryTheory.Limits.HasWidePushout B objs arrows] {X : C}
{g1 g2 : CategoryTheory.Limits.widePushout B objs arrows ⟶ X},
g1 = g2 ↔
(∀ (j : J),
CategoryTheory.Categor... | null | true |
_private.Std.Data.Iterators.Lemmas.Producers.Monadic.List.0.Std.Types.ListIterator.stepAsHetT_iterM.match_1.eq_2 | Std.Data.Iterators.Lemmas.Producers.Monadic.List | ∀ {β : Type u_1} (motive : List β → Sort u_2) (x : β) (xs : List β) (h_1 : Unit → motive [])
(h_2 : (x : β) → (xs : List β) → motive (x :: xs)),
(match x :: xs with
| [] => h_1 ()
| x :: xs => h_2 x xs) =
h_2 x xs | null | true |
Exists₂.imp | Mathlib.Basic.Logic.Basic | ∀ {α : Sort u_1} {β : α → Sort u_2} {p q : (a : α) → β a → Prop},
(∀ (a : α) (b : β a), p a b → q a b) → (∃ a b, p a b) → ∃ a b, q a b | null | true |
Multiset.Nodup.filterMap | Mathlib.Data.Multiset.Filter | ∀ {α : Type u_1} {β : Type v} {s : Multiset α} (f : α → Option β),
(∀ (a a' : α), ∀ b ∈ f a, b ∈ f a' → a = a') → s.Nodup → (Multiset.filterMap f s).Nodup | null | true |
EuclideanGeometry.hasFDerivAt_inversion | Mathlib.Geometry.Euclidean.Inversion.Calculus | ∀ {F : Type u_2} [inst : NormedAddCommGroup F] [inst_1 : InnerProductSpace ℝ F] {c x : F} {R : ℝ},
x ≠ c → HasFDerivAt (EuclideanGeometry.inversion c R) ((R / dist x c) ^ 2 • ↑↑(ℝ ∙ (x - c))ᗮ.reflection) x | Formula for the Fréchet derivative of `EuclideanGeometry.inversion c R`. | true |
CommRingCat.Colimits.Relation.mul_zero | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J CommRingCat}
(x : CommRingCat.Colimits.Prequotient F),
CommRingCat.Colimits.Relation F (x.mul CommRingCat.Colimits.Prequotient.zero) CommRingCat.Colimits.Prequotient.zero | null | true |
AlgEquiv.sumArrowEquivProdArrow | Mathlib.Algebra.Algebra.Pi | (α : Type u_1) →
(β : Type u_2) →
(R : Type u_3) →
[inst : CommSemiring R] →
(S : Type u_8) → [inst_1 : Semiring S] → [inst_2 : Algebra R S] → (α ⊕ β → S) ≃ₐ[R] (α → S) × (β → S) | `Equiv.sumArrowEquivProdArrow` as an algebra equivalence. | true |
EReal.div_nonpos_of_nonneg_of_nonpos | Mathlib.Data.EReal.Inv | ∀ {a b : EReal}, 0 ≤ a → b ≤ 0 → a / b ≤ 0 | null | true |
legendreSym_mersenne_three | Mathlib.NumberTheory.LucasLehmer | ∀ {p : ℕ} [inst : Fact (Nat.Prime (mersenne p))], 3 ≤ p → Odd p → legendreSym (mersenne p) 3 = -1 | If `2^p - 1` is prime then 3 is not a square mod `2^p - 1`. | true |
Finpartition.bind.congr_simp | Mathlib.Combinatorics.SimpleGraph.Regularity.Increment | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : OrderBot α] [inst_2 : IsModularLattice α] [inst_3 : DecidableEq α] {a : α}
(P : Finpartition a) (Q Q_1 : (i : α) → i ∈ P.parts → Finpartition i), Q = Q_1 → P.bind Q = P.bind Q_1 | null | true |
List.erase_eq_eraseP._f | Init.Data.List.Erase | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] (a : α) (x : List α) (f : List.below x),
x.erase a = List.eraseP (fun x => a == x) x | null | false |
LSeriesSummable_lt_re_of_abscissaOfAbsConv_lt_re | Mathlib.NumberTheory.LSeries.Convergence | ∀ {f : ℕ → ℂ} {s : ℂ}, LSeries.abscissaOfAbsConv f < ↑s.re → ∃ x < s.re, LSeriesSummable f ↑x | null | true |
Mathlib.Tactic.FieldSimp.NF.cons | Mathlib.Tactic.FieldSimp.Lemmas | {M : Type u_1} → ℤ × M → Mathlib.Tactic.FieldSimp.NF M → Mathlib.Tactic.FieldSimp.NF M | Augment a `FieldSimp.NF M` object `l`, i.e. a list of pairs in `ℤ × M`, by prepending another
pair `p : ℤ × M`. | true |
Std.Http.Protocol.H1.Error.other | Std.Http.Protocol.H1.Error | String → Std.Http.Protocol.H1.Error | Generic error with message.
| true |
mfderivWithin_eventually_congr_set' | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | If two sets coincide locally, except maybe at a point, then derivatives within these sets
coincide locally. | true |
_private.Mathlib.Analysis.SpecialFunctions.RegularizedHypergeometric.0.Complex.multiset_prod_eq_pow_mul_multiset_prod._simp_1_4 | Mathlib.Analysis.SpecialFunctions.RegularizedHypergeometric | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | null | false |
_private.Mathlib.MeasureTheory.Measure.Hausdorff.0.MeasureTheory.hausdorffMeasure_pi_real._simp_1_5 | Mathlib.MeasureTheory.Measure.Hausdorff | ∀ {p q : ℚ} {K : Type u_2} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K], (↑p ≤ ↑q) = (p ≤ q) | null | false |
Mathlib.Tactic._aux_Mathlib_Tactic_NormNum_Core___elabRules_Mathlib_Tactic_normNum1_1 | Mathlib.Tactic.NormNum.Core | Lean.Elab.Tactic.Tactic | `norm_num1` normalizes numerical expressions in the goal. It is a basic version of `norm_num`
that does not call `simp`.
By default, it supports the operations `+` `-` `*` `/` `⁻¹` `^` and `%` over types with (at least)
an `AddMonoidWithOne` instance, such as `ℕ`, `ℤ`, `ℚ`, `ℝ`, `ℂ`. If the goal has the form `A = B`,
... | false |
LieRinehartSubalgebra.mk.inj | Mathlib.Algebra.LieRinehartAlgebra.Subalgebra | ∀ {A : Type u_1} {L : Type u_2} {inst : CommRing A} {inst_1 : LieRing L} {inst_2 : Module A L}
{toSubmodule : Submodule A L}
{lie_mem' : ∀ {a b : L}, a ∈ toSubmodule.carrier → b ∈ toSubmodule.carrier → ⁅a, b⁆ ∈ toSubmodule.carrier}
{toSubmodule_1 : Submodule A L}
{lie_mem'_1 : ∀ {a b : L}, a ∈ toSubmodule_1.car... | null | true |
Mathlib.Tactic.«tacticRename_bvar_→__» | Mathlib.Tactic.RenameBVar | Lean.ParserDescr | * `rename_bvar old → new` renames all bound variables named `old` to `new` in the target.
* `rename_bvar old → new at h` does the same in hypothesis `h`.
```lean
example (P : ℕ → ℕ → Prop) (h : ∀ n, ∃ m, P n m) : ∀ l, ∃ m, P l m := by
rename_bvar n → q at h -- h is now ∀ (q : ℕ), ∃ (m : ℕ), P q m,
rename_bvar m → ... | true |
MeasureTheory.Measure.IsAddHaarMeasure.instHasTemperateGrowth | Mathlib.Analysis.Distribution.TemperateGrowth | ∀ {E : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : MeasurableSpace E] [inst_2 : NormedSpace ℝ E]
[FiniteDimensional ℝ E] [BorelSpace E] {μ : MeasureTheory.Measure E} [h : μ.IsAddHaarMeasure], μ.HasTemperateGrowth | null | true |
Nat.digitsAux_def | Mathlib.Data.Nat.Digits.Defs | ∀ (b : ℕ) (h : 2 ≤ b) (n : ℕ), 0 < n → b.digitsAux h n = n % b :: b.digitsAux h (n / b) | null | true |
IsClopen.eq_univ | Mathlib.Topology.Connected.Clopen | ∀ {α : Type u} [inst : TopologicalSpace α] [PreconnectedSpace α] {s : Set α}, IsClopen s → s.Nonempty → s = Set.univ | null | true |
Homeomorph.sumPiEquivProdPi._proof_3 | Mathlib.Topology.Homeomorph.Lemmas | ∀ (S : Type u_1) (T : Type u_2) (A : S ⊕ T → Type u_3) [inst : (st : S ⊕ T) → TopologicalSpace (A st)],
Continuous (Equiv.sumPiEquivProdPi A).invFun | null | false |
Rep.FiniteCyclicGroup.groupHomologyIsoEven._proof_5 | Mathlib.RepresentationTheory.Homological.GroupHomology.FiniteCyclic | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : CommGroup G] [inst_2 : Fintype G] (A : Rep.{u_1, u_1, u_1} k G) (g : G)
(hg : ∀ (x : G), x ∈ Subgroup.zpowers g) (i : ℕ),
(HomologicalComplex.sc (HomologicalComplex.coinvariantsTensorObj A (Rep.FiniteCyclicGroup.resolution k g⁻¹ ⋯).complex)
i).HasHomology | null | false |
tangentConeAt_mono | Mathlib.Analysis.Calculus.TangentCone.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : AddCommGroup E] [inst_1 : SMul 𝕜 E] [inst_2 : TopologicalSpace E] {s t : Set E}
{x : E}, s ⊆ t → tangentConeAt 𝕜 s x ⊆ tangentConeAt 𝕜 t x | null | true |
Lean.Elab.instInhabitedComputeKind.default | Lean.Elab.DeclModifiers | Lean.Elab.ComputeKind | null | true |
_private.Mathlib.Analysis.Calculus.FDeriv.Measurable.0.FDerivMeasurableAux.D_subset_differentiable_set._proof_1_5 | Mathlib.Analysis.Calculus.FDeriv.Measurable | ∀ {F : Type u_1} [inst_3 : NormedAddCommGroup F], IsUniformAddGroup F | null | false |
ContDiffAt.comp_contMDiffWithinAt | Mathlib.Geometry.Manifold.ContMDiff.NormedSpace | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {F : Type u_6} [inst_6 : NormedAddCommG... | null | true |
MeasureTheory.martingale_const | Mathlib.Probability.Martingale.Basic | ∀ {Ω : Type u_1} {E : Type u_2} {ι : Type u_3} [inst : Preorder ι] {m0 : MeasurableSpace Ω}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E] (ℱ : MeasureTheory.Filtration ι m0)
(μ : MeasureTheory.Measure Ω) [MeasureTheory.IsFiniteMeasure μ] (x : E),
MeasureTheory.Martingale (fun x_1 x_2 => x) ℱ μ | null | true |
Lean.Meta.LazyDiscrTree.PartialMatch.c | Lean.Meta.LazyDiscrTree | Lean.Meta.LazyDiscrTree.PartialMatch → Lean.Meta.LazyDiscrTree.TrieIndex | null | true |
_private.Lean.Expr.0.Lean.natAddFn | Lean.Expr | Lean.Expr | null | true |
Lean.Compiler.instHashableInlineAttributeKind | Lean.Compiler.InlineAttrs | Hashable Lean.Compiler.InlineAttributeKind | null | true |
Lean.Lsp.PrepareRenameParams.casesOn | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.PrepareRenameParams → Sort u} →
(t : Lean.Lsp.PrepareRenameParams) →
((toTextDocumentPositionParams : Lean.Lsp.TextDocumentPositionParams) →
motive { toTextDocumentPositionParams := toTextDocumentPositionParams }) →
motive t | null | false |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.expandAssert._regBuiltin.Lean.Elab.Term.expandAssert_1 | Lean.Elab.BuiltinNotation | IO Unit | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_498 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
Std.TreeMap.mem_insertMany_list._simp_1 | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : BEq α]
[Std.LawfulBEqCmp cmp] {l : List (α × β)} {k : α},
(k ∈ t.insertMany l) = (k ∈ t ∨ (List.map Prod.fst l).contains k = true) | null | false |
IsCoinitialFor.of_subset._simp_1 | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {s t : Set α}, s ⊆ t → IsCoinitialFor s t = True | null | false |
«_aux_Mathlib_Data_Rat_Init___macroRules_termℚ≥0_1» | Mathlib.Data.Rat.Init | Lean.Macro | null | false |
SemiNormedGrp₁.cokernelLift._proof_2 | Mathlib.Analysis.Normed.Group.SemiNormedGrp.Kernels | ∀ {X Y : SemiNormedGrp₁} (f : X ⟶ Y) (s : CategoryTheory.Limits.CokernelCofork f),
(NormedAddGroupHom.lift f.hom'.range (CategoryTheory.Limits.Cofork.π s).hom' ⋯).NormNoninc | null | false |
Std.Time.Weekday.sunday | Std.Time.Date.Unit.Weekday | Std.Time.Weekday | Sunday. | true |
selfAdjoint.val_qsmul._simp_1 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : Field R] [inst_1 : StarRing R] (q : ℚ) (x : ↥(selfAdjoint R)), q • ↑x = ↑(q • x) | null | false |
_private.Mathlib.Geometry.Manifold.PoincareConjecture.0.term𝕊__ | Mathlib.Geometry.Manifold.PoincareConjecture | Lean.ParserDescr | null | true |
ContinuousLinearMap.pi_apply | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.PiProd | ∀ {R : Type u_1} [inst : Semiring R] {M : Type u_2} [inst_1 : TopologicalSpace M] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M] {ι : Type u_4} {φ : ι → Type u_5} [inst_4 : (i : ι) → TopologicalSpace (φ i)]
[inst_5 : (i : ι) → AddCommMonoid (φ i)] [inst_6 : (i : ι) → Module R (φ i)] (f : (i : ι) → M →L[R] φ i) (c... | null | true |
AddEquiv.comapAddSubgroup._proof_5 | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : AddGroup G] {H : Type u_2} [inst_1 : AddGroup H], AddMonoidHomClass (H ≃+ G) H G | null | false |
Std.DTreeMap.Internal.Impl.Const.getD_filter! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [inst : Std.TransOrd α]
{f : α → β → Bool} {k : α} {fallback : β} (h : t.WF),
Std.DTreeMap.Internal.Impl.Const.getD (Std.DTreeMap.Internal.Impl.filter! f t) k fallback =
((Std.DTreeMap.Internal.Impl.Const.get? t k).pfilt... | null | true |
MvPowerSeries.substAlgHom._proof_1 | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {R : Type u_1} [inst : CommRing R], IsTopologicalSemiring R | null | false |
CategoryTheory.Functor.leftOpRightOpIso_inv_app | Mathlib.CategoryTheory.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C Dᵒᵖ) (X : C), F.leftOpRightOpIso.inv.app X = CategoryTheory.CategoryStruct.id (F.obj X) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.