name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Function.locallyFinsuppWithin.posPart_add | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [inst_1 : AddCommGroup Y]
[inst_2 : LinearOrder Y] [IsOrderedAddMonoid Y] (f₁ f₂ : Function.locallyFinsuppWithin U Y), (f₁ + f₂)⁺ ≤ f₁⁺ + f₂⁺ | The positive part of a sum is less than or equal to the sum of the positive parts.
| true |
Set.preimage_const_add_Icc | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α] (a b c : α),
(fun x => a + x) ⁻¹' Set.Icc b c = Set.Icc (b - a) (c - a) | null | true |
Std.ExtTreeSet.max?.congr_simp | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] (t t_1 : Std.ExtTreeSet α cmp),
t = t_1 → t.max? = t_1.max? | null | true |
Std.ExtTreeSet.filter_eq_self_iff | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {f : α → Bool},
Std.ExtTreeSet.filter f t = t ↔ ∀ (k : α) (h : k ∈ t), f (t.get k h) = true | null | true |
Lean.Grind.CommRing.Mon.revlexFuel._f | Init.Grind.Ring.CommSolver | (fuel : ℕ) →
Nat.below (motive := fun fuel => Lean.Grind.CommRing.Mon → Lean.Grind.CommRing.Mon → Ordering) fuel →
Lean.Grind.CommRing.Mon → Lean.Grind.CommRing.Mon → Ordering | null | false |
ENat.natCast_lt_top | Mathlib.Data.ENat.Basic | ∀ (n : ℕ), ↑n < ⊤ | null | true |
Std.DHashMap.Internal.Raw₀.getKey!_eq_of_equiv | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] (m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β)
[EquivBEq α] [LawfulHashable α] [inst_4 : Inhabited α],
(↑m₁).WF → (↑m₂).WF → (↑m₁).Equiv ↑m₂ → ∀ {k : α}, m₁.getKey! k = m₂.getKey! k | null | true |
RingHom.etale_algebraMap | Mathlib.RingTheory.RingHom.Etale | ∀ {R : Type u_3} {S : Type u_4} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
(algebraMap R S).Etale ↔ Algebra.Etale R S | null | true |
CategoryTheory.Functor.PreservesEffectiveEpiFamilies.rec | Mathlib.CategoryTheory.EffectiveEpi.Preserves | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{F : CategoryTheory.Functor C D} →
{motive : F.PreservesEffectiveEpiFamilies → Sort u_3} →
((preserves :
∀ {α : Type u} {B : C} ... | null | false |
AlgebraicGeometry.Scheme.Opens.topIso | Mathlib.AlgebraicGeometry.Restrict | {X : AlgebraicGeometry.Scheme} → (U : X.Opens) → (↑U).presheaf.obj (Opposite.op ⊤) ≅ X.presheaf.obj (Opposite.op U) | The global sections of the restriction is isomorphic to the sections on the open set. | true |
MvPowerSeries.eq_of_coeff_monomial_ne_zero | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] {m n : σ →₀ ℕ} {a : R},
(MvPowerSeries.coeff m) ((MvPowerSeries.monomial n) a) ≠ 0 → m = n | null | true |
CategoryTheory.GrothendieckTopology.PreservesSheafification.recOn | Mathlib.CategoryTheory.Sites.PreservesSheafification | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{A : Type u_1} →
{B : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} A] →
[inst_2 : CategoryTheory.Category.{v_2, u_2} B] →
{F : CategoryTheory.Funct... | null | false |
_private.Mathlib.CategoryTheory.Comma.Over.Basic.0.CategoryTheory.Functor.essImage_overPost.match_1_1 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {X : T} {F : CategoryTheory.Functor T D}
{Y : CategoryTheory.Over (F.obj X)} (Z : T) (e : F.obj Z ≅ Y.left)
(motive : (∃ a, F.map a = CategoryTheory.CategoryStruct.comp e.hom Y.hom) → Prop... | null | false |
CategoryTheory.compEvaluation | Mathlib.CategoryTheory.Products.Basic | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
{C : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
(F : CategoryTheory.Functor A (CategoryTheory.Functor B C)) →
(b : B) → F.... | `F` composed with evaluation is the same as evaluating `F.flip`. | true |
_private.Batteries.Data.Array.Lemmas.0.Array.toList_swapIfInBounds._proof_1_2 | Batteries.Data.Array.Lemmas | ∀ {α : Type u_1} {i j : ℕ} {a : Array α} (i_1 : ℕ),
i_1 + 1 ≤ (a.toList.swap i j).length → i_1 < (a.toList.swap i j).length | null | false |
Lean.Meta.SynthInstance.Context.mk.inj | Lean.Meta.SynthInstance | ∀ {maxResultSize maxHeartbeats maxResultSize_1 maxHeartbeats_1 : ℕ},
{ maxResultSize := maxResultSize, maxHeartbeats := maxHeartbeats } =
{ maxResultSize := maxResultSize_1, maxHeartbeats := maxHeartbeats_1 } →
maxResultSize = maxResultSize_1 ∧ maxHeartbeats = maxHeartbeats_1 | null | true |
Std.DTreeMap.Raw.Equiv.minKey!_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α], t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.minKey! = t₂.minKey! | null | true |
IsQuotientCoveringMap.fundamentalGroupToMulOpposite_eq_one_iff | Mathlib.Topology.Homotopy.Lifting | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {p : E → X} {G : Type u_4}
[inst_2 : Group G] [inst_3 : MulAction G E] (hp : IsQuotientCoveringMap p G) {x : X} {e : ↑(p ⁻¹' {x})}
{γ : FundamentalGroup X x}, (hp.fundamentalGroupToMulOpposite e) γ = 1 ↔ ⋯.monodromy γ.asHom e ... | null | true |
Std.DTreeMap.minKey?_le_minKey?_erase | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [inst : Std.TransCmp cmp]
{k km kme : α} (hkme : (t.erase k).minKey? = some kme), t.minKey?.get ⋯ = km → (cmp km kme).isLE = true | null | true |
SimplexCategory.len | Mathlib.AlgebraicTopology.SimplexCategory.Defs | SimplexCategory → ℕ | The length of an object in `SimplexCategory` | true |
_private.Mathlib.Analysis.Complex.Hadamard.0.Complex.HadamardThreeLines.norm_le_interpStrip_of_mem_verticalStrip_zero._simp_1_3 | Mathlib.Analysis.Complex.Hadamard | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
Int.toArray_roo_succ_right_eq_push | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ}, m < n → (m<...n + 1).toArray = (m<...n).toArray.push n | null | true |
CategoryTheory.isZero_of_hasProjectiveDimensionLT_zero | Mathlib.CategoryTheory.Abelian.Projective.Dimension | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] (X : C)
[CategoryTheory.HasProjectiveDimensionLT X 0], CategoryTheory.Limits.IsZero X | null | true |
CategoryTheory.Functor.mapPresheaf._proof_2 | Mathlib.Geometry.RingedSpace.PresheafedSpace | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_4, u_5} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} D] (F : CategoryTheory.Functor C D)
(X : AlgebraicGeometry.PresheafedSpace C),
{ base := (CategoryTheory.CategoryStruct.id X).base,
c := CategoryTheory.Functor.whiskerRight (CategoryThe... | null | false |
_private.Mathlib.Data.Set.Lattice.Bounded.0.Set.iInter₂_eq_empty_iff._simp_1_1 | Mathlib.Data.Set.Lattice.Bounded | ∀ {α : Type u} {s : Set α}, (s = ∅) = ∀ (x : α), x ∉ s | null | false |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.mkBelowAppOfIdx | Lean.Meta.IndPredBelow | ℕ → Lean.Meta.IndPredBelow.Context✝ → Lean.Expr | Returns `@XYZ.below params... motives...` | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Basic.0.CategoryTheory.WithInitial.opEquiv.match_15.eq_1 | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Basic | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C]
(motive : (x y : CategoryTheory.WithTerminal Cᵒᵖ) → (x ⟶ y) → Sort u_3) (x y : C)
(f : CategoryTheory.WithTerminal.of (Opposite.op x) ⟶ CategoryTheory.WithTerminal.of (Opposite.op y))
(h_1 :
(x y : C) →
(f : CategoryTheory.WithTerminal.of (O... | null | true |
Rat.instIsTopologicalAddGroup | Mathlib.Topology.Instances.Rat | IsTopologicalAddGroup ℚ | null | true |
USize.toUInt16_or | Init.Data.UInt.Bitwise | ∀ (a b : USize), (a ||| b).toUInt16 = a.toUInt16 ||| b.toUInt16 | null | true |
Lean.Meta.SynthInstance.MkTableKey.State.lmap | Lean.Meta.SynthInstance | Lean.Meta.SynthInstance.MkTableKey.State → Std.HashMap Lean.LMVarId Lean.Level | null | true |
MulActionHom.toFun | Mathlib.GroupTheory.GroupAction.Hom | {M : Type u_2} →
{N : Type u_3} →
{φ : M → N} → {X : Type u_5} → [inst : SMul M X] → {Y : Type u_6} → [inst_1 : SMul N Y] → (X →ₑ[φ] Y) → X → Y | The underlying function. | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Rup.0.Std.Tactic.BVDecide.LRAT.Internal.State.propagateHints_spec._simp_1_37 | Std.Tactic.BVDecide.LRAT.Internal.Rup | ∀ {ps : Std.Do.PostShape} (x : Std.Do.ExceptConds ps), x.entails x = True | null | false |
Lean.PrefixTreeNode.brecOn_2.go | Lean.Data.PrefixTree | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} →
{motive_1 : Lean.PrefixTreeNode α β cmp → Sort u_1} →
{motive_2 : Std.TreeMap.Raw α (Lean.PrefixTreeNode α β cmp) cmp → Sort u_1} →
{motive_3 : Std.DTreeMap.Raw α (fun x => Lean.PrefixTreeNode α β cmp) cmp → Sort u_1} →
{... | null | true |
_private.Init.Data.Vector.Lemmas.0.Vector.insertIdx_mk._proof_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Array α} {h : xs.size = n} {i : ℕ}, i ≤ n → ¬i ≤ xs.size → False | null | false |
congrArg | Init.Prelude | ∀ {α : Sort u} {β : Sort v} {a₁ a₂ : α} (f : α → β), a₁ = a₂ → f a₁ = f a₂ | Congruence in the function argument: if `a₁ = a₂` then `f a₁ = f a₂` for
any (nondependent) function `f`. This is more powerful than it might look at first, because
you can also use a lambda expression for `f` to prove that
`<something containing a₁> = <something containing a₂>`. This function is used
internally by tac... | true |
MulRingNormClass | Mathlib.Algebra.Order.Hom.RingNorm | (F : Type u_4) →
(α : outParam (Type u_5)) →
(β : outParam (Type u_6)) → [NonAssocRing α] → [Semiring β] → [PartialOrder β] → [FunLike F α β] → Prop | `MulRingNormClass F α` states that `F` is a type of `β`-valued multiplicative norms on the
ring `α`.
You should extend this class when you extend `MulRingNorm`. | true |
Finite.bddAbove_range | Mathlib.Data.Fintype.Order | ∀ {ι : Sort u_1} {α : Type u_2} [Finite ι] [Nonempty α] [inst : Preorder α] [IsDirectedOrder α] (f : ι → α),
BddAbove (Set.range f) | null | true |
ciInf_set_le | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLattice α] {f : β → α} {s : Set β},
BddBelow (f '' s) → ∀ {c : β}, c ∈ s → ⨅ i, f ↑i ≤ f c | null | true |
Sigma.preorder | Mathlib.Order.Sigma | {ι : Type u_1} → {α : ι → Type u_2} → [(i : ι) → Preorder (α i)] → Preorder ((i : ι) × α i) | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.ArctanDeriv.0.Real.tendsto_abs_tan_of_cos_eq_zero._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.ArctanDeriv | ∀ (r : ℝ), |r| = ‖r‖ | null | false |
_private.Mathlib.Topology.Neighborhoods.0.Filter.Eventually.eventually_nhds.match_1_1 | Mathlib.Topology.Neighborhoods | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x : X} {p : X → Prop}
(motive : (∃ t, (∀ y ∈ t, p y) ∧ IsOpen t ∧ x ∈ t) → Prop) (x_1 : ∃ t, (∀ y ∈ t, p y) ∧ IsOpen t ∧ x ∈ t),
(∀ (t : Set X) (htp : ∀ y ∈ t, p y) (hto : IsOpen t) (ha : x ∈ t), motive ⋯) → motive x_1 | null | false |
instDiscreteTopologyPEmpty | Mathlib.Topology.Order | DiscreteTopology PEmpty.{u_1 + 1} | null | true |
CochainComplex.mappingCone.liftCocycle.congr_simp | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{F G : CochainComplex C ℤ} (φ : F ⟶ G) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ] {K : CochainComplex C ℤ}
{n m : ℤ} (α α_1 : CochainComplex.HomComplex.Cocycle K F m) (e_α : α = α_1)
(β β_1 : CochainComple... | null | true |
_private.Mathlib.CategoryTheory.Preadditive.Biproducts.0.CategoryTheory.Limits.preservesBiproduct_of_preservesCoproduct.match_1_1 | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {J : Type u_1} (motive : Nonempty (Fintype J) → Prop) (x : Nonempty (Fintype J)),
(∀ (val : Fintype J), motive ⋯) → motive x | null | false |
ProbabilityTheory.condIndep_biSup_compl | Mathlib.Probability.Independence.ZeroOne | ∀ {Ω : Type u_2} {ι : Type u_3} {s : ι → MeasurableSpace Ω} {m m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω}
[inst : StandardBorelSpace Ω] (hm : m ≤ m0) [inst_1 : MeasureTheory.IsFiniteMeasure μ],
(∀ (n : ι), s n ≤ m0) →
ProbabilityTheory.iCondIndep m hm s μ →
∀ (t : Set ι), ProbabilityTheory.Cond... | null | true |
Monoid.lcm_orderOf_eq_exponent | Mathlib.GroupTheory.Exponent | ∀ {G : Type u} [inst : Monoid G] [inst_1 : Fintype G], Finset.univ.lcm orderOf = Monoid.exponent G | null | true |
Set.insert_Icc_right_eq_Icc_succ | Mathlib.Order.Interval.Set.SuccPred | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : SuccOrder α] {a b : α},
a ≤ Order.succ b → insert (Order.succ b) (Set.Icc a b) = Set.Icc a (Order.succ b) | null | true |
CochainComplex.mapBifunctorHomologicalComplexShift₂Iso_inv_f_f | Mathlib.Algebra.Homology.BifunctorShift | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {D : Type u_3} [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} D]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms C₁] [inst_4 : CategoryTheory.Preadditive C₂]
[inst_5 : CategoryTheory.Pr... | null | true |
Equiv.Perm.SameCycle.toList_isRotated | Mathlib.GroupTheory.Perm.Cycle.Concrete | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {f : Equiv.Perm α} {x y : α},
f.SameCycle x y → f.toList x ~r f.toList y | null | true |
CategoryTheory.Span.SpanBicat.compLiftApex_πᵣ._auto_1 | Mathlib.CategoryTheory.Bicategory.Span.Basic | Lean.Syntax | null | false |
CategoryTheory.SmallObject.SuccStruct.extendToSuccRestrictionLEIso | Mathlib.CategoryTheory.SmallObject.Iteration.ExtendToSucc | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{J : Type u} →
[inst_1 : LinearOrder J] →
[inst_2 : SuccOrder J] →
{j : J} →
(hj : ¬IsMax j) →
(F : CategoryTheory.Functor (↑(Set.Iic j)) C) →
{X : C} →
(τ : F.obj ⟨... | The isomorphism expressing that `extendToSucc hj F τ` extends `F`. | true |
MvPolynomial.support_one | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] [Nontrivial R], MvPolynomial.support 1 = {0} | null | true |
CategoryTheory.Limits.Fork.isoForkOfι | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {C : Type u} →
{X Y : C} →
[inst : CategoryTheory.Category.{v, u} C] →
{f g : X ⟶ Y} → (c : CategoryTheory.Limits.Fork f g) → c ≅ CategoryTheory.Limits.Fork.ofι c.ι ⋯ | Every fork is isomorphic to one of the form `Fork.of_ι _ _`. | true |
isClopen_range_inl | Mathlib.Topology.Clopen | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y], IsClopen (Set.range Sum.inl) | null | true |
_private.Mathlib.Topology.Algebra.Nonarchimedean.Basic.0.NonarchimedeanRing.mul_subset.match_1_1 | Mathlib.Topology.Algebra.Nonarchimedean.Basic | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : TopologicalSpace R] (U : OpenAddSubgroup R)
(motive : (∃ V, ↑V ×ˢ ↑V ⊆ (fun p => p.1 * p.2) ⁻¹' ↑U) → Prop) (x : ∃ V, ↑V ×ˢ ↑V ⊆ (fun p => p.1 * p.2) ⁻¹' ↑U),
(∀ (V : OpenAddSubgroup R) (H : ↑V ×ˢ ↑V ⊆ (fun p => p.1 * p.2) ⁻¹' ↑U), motive ⋯) → motive x | null | false |
_private.Batteries.Tactic.Lint.Basic.0.Batteries.Tactic.Lint.nolintAttr.match_1 | Batteries.Tactic.Lint.Basic | (motive : Option (Array (Lean.TSyntax `ident)) → Sort u_1) →
(x : Option (Array (Lean.TSyntax `ident))) →
((ids : Array (Lean.TSyntax `ident)) → motive (some ids)) → (Unit → motive none) → motive x | null | false |
_private.Mathlib.Topology.MetricSpace.Thickening.0.Metric.thickening_thickening_subset._simp_1_1 | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} (s : Set α), (∅ ⊆ s) = True | null | false |
TopCat.instCommRingHomObjTopCommRingCatForget₂SubtypeRingHomαContinuousCoeContinuousMapCarrier._proof_4 | Mathlib.Topology.Sheaves.CommRingCat | ∀ (X : TopCat) (R : TopCommRingCat) (x x_1 : X ⟶ (CategoryTheory.forget₂ TopCommRingCat TopCat).obj R),
CategoryTheory.ConcreteCategory.hom (x + x_1) = CategoryTheory.ConcreteCategory.hom (x + x_1) | null | false |
NonUnitalCommRing.toNonUnitalCommSemiring._proof_1 | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u_1} [s : NonUnitalCommRing α] (a b : α), a + b = b + a | null | false |
Lean.Compiler.LCNF.TrivialStructureInfo.rec | Lean.Compiler.LCNF.Irrelevant | {motive : Lean.Compiler.LCNF.TrivialStructureInfo → Sort u} →
((ctorName : Lean.Name) →
(numParams fieldIdx : ℕ) → motive { ctorName := ctorName, numParams := numParams, fieldIdx := fieldIdx }) →
(t : Lean.Compiler.LCNF.TrivialStructureInfo) → motive t | null | false |
_private.Mathlib.RingTheory.Polynomial.Eisenstein.IsIntegral.0._aux_Mathlib_RingTheory_Polynomial_Eisenstein_IsIntegral___unexpand_Submodule_span_1 | Mathlib.RingTheory.Polynomial.Eisenstein.IsIntegral | Lean.PrettyPrinter.Unexpander | null | false |
Std.DTreeMap.Raw.Const.getD_union | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {m₁ m₂ : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp],
m₁.WF →
m₂.WF →
∀ {k : α} {fallback : β},
Std.DTreeMap.Raw.Const.getD (m₁ ∪ m₂) k fallback =
Std.DTreeMap.Raw.Const.getD m₂ k (Std.DTreeMap.Raw.Const.getD m₁ k fallback) | null | true |
LibraryNote.lower_cancel_priority | Mathlib.Algebra.Group.Semigroup | Batteries.Util.LibraryNote | We lower the priority of inheriting from cancellative structures.
This attempts to avoid expensive checks involving bundling and unbundling with the `IsDomain` class.
since `IsDomain` already depends on `Semiring`, we can synthesize that one first.
Zulip discussion: https://leanprover.zulipchat.com/#narrow/stream/11348... | true |
Lean.Meta.getMatcherInfo? | Lean.Meta.Match.MatcherInfo | {m : Type → Type} → [Monad m] → [Lean.MonadEnv m] → Lean.Name → m (Option Lean.Meta.MatcherInfo) | null | true |
_private.Lean.Elab.Tactic.BuiltinTactic.0.Lean.Elab.Tactic.evalRight._regBuiltin.Lean.Elab.Tactic.evalRight.declRange_3 | Lean.Elab.Tactic.BuiltinTactic | IO Unit | null | false |
Nat.bertrand | Mathlib.NumberTheory.Bertrand | ∀ (n : ℕ), n ≠ 0 → ∃ p, Nat.Prime p ∧ n < p ∧ p ≤ 2 * n | **Alias** of `Nat.exists_prime_lt_and_le_two_mul`.
---
**Bertrand's Postulate**: For any positive natural number, there is a prime which is greater than
it, but no more than twice as large.
| true |
_private.Mathlib.MeasureTheory.Measure.WithDensity.0.MeasureTheory.ae_withDensity_iff'._simp_1_1 | Mathlib.MeasureTheory.Measure.WithDensity | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
_private.Mathlib.Algebra.BigOperators.Finsupp.Basic.0.Finsupp.support_sum.match_1_1 | Mathlib.Algebra.BigOperators.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_4} {M : Type u_2} {N : Type u_3} [inst : Zero M] [inst_1 : AddCommMonoid N] {f : α →₀ M}
{g : α → M → β →₀ N} (a₁ : β) (motive : (∃ a ∈ f.support, (fun a b => (g a b) a₁) a (f a) ≠ 0) → Prop)
(x : ∃ a ∈ f.support, (fun a b => (g a b) a₁) a (f a) ≠ 0),
(∀ (a : α) (ha : a ∈ f.support) (... | null | false |
Std.TreeSet.not_mem_emptyc | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {k : α}, k ∉ ∅ | null | true |
MulAction.fst_mem_orbit_of_mem_orbit | Mathlib.GroupTheory.GroupAction.Basic | ∀ {M : Type u} [inst : Monoid M] {α : Type v} [inst_1 : MulAction M α] {β : Type u_1} [inst_2 : MulAction M β]
{x y : α × β}, x ∈ MulAction.orbit M y → x.1 ∈ MulAction.orbit M y.1 | null | true |
List.pairwise_append_of_mem | Mathlib.Data.List.Pairwise | ∀ {α : Type u_1} {R : α → α → Prop} {l₁ l₂ : List α} {a b : α} [Std.Symm R] [IsTrans α R],
a ∈ l₁ → b ∈ l₂ → (List.Pairwise R (l₁ ++ l₂) ↔ R a b ∧ List.Pairwise R l₁ ∧ List.Pairwise R l₂) | null | true |
Module.Basis.sumCoords._proof_1 | Mathlib.LinearAlgebra.Basis.Defs | ∀ {R : Type u_1} [inst : Semiring R], SMulCommClass R ℕ R | null | false |
Std.DHashMap.Raw.mem_insert_self._simp_1 | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {k : α} {v : β k}, (k ∈ m.insert k v) = True | null | false |
IsWellFounded.recOn | Mathlib.Order.RelClasses | {α : Type u} →
{r : α → α → Prop} →
{motive : IsWellFounded α r → Sort u_1} → (t : IsWellFounded α r) → ((wf : WellFounded r) → motive ⋯) → motive t | null | false |
continuousSubmonoid.eq_1 | Mathlib.Topology.ContinuousMap.Algebra | ∀ (α : Type u_1) (β : Type u_2) [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : MulOneClass β]
[inst_3 : ContinuousMul β], continuousSubmonoid α β = { carrier := {f | Continuous f}, mul_mem' := ⋯, one_mem' := ⋯ } | null | true |
QuotientAddGroup.map.eq_1 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} {H : Type u_2} [inst : AddGroup G] [inst_1 : AddGroup H] (N : AddSubgroup G) [nN : N.Normal]
(M : AddSubgroup H) [inst_2 : M.Normal] (f : G →+ H) (h : N ≤ AddSubgroup.comap f M),
QuotientAddGroup.map N M f h = QuotientAddGroup.lift N ((QuotientAddGroup.mk' M).comp f) ⋯ | null | true |
Polynomial.monomial_mem_lifts | Mathlib.Algebra.Polynomial.Lifts | ∀ {R : Type u} [inst : Semiring R] {S : Type v} [inst_1 : Semiring S] {f : R →+* S} {s : S} (n : ℕ),
s ∈ Set.range ⇑f → (Polynomial.monomial n) s ∈ Polynomial.lifts f | If `(s : S)` is in the image of `f`, then `monomial n s` lifts. | true |
WithAbs.congr_trans | Mathlib.Analysis.Normed.Ring.WithAbs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring S] [inst_1 : PartialOrder S] [inst_2 : Semiring R]
(v : AbsoluteValue R S) {T : Type u_3} {U : Type u_4} [inst_3 : Semiring T] [inst_4 : Semiring U]
(w : AbsoluteValue T S) (u : AbsoluteValue U S) (f : R ≃+* T) (g : T ≃+* U),
WithAbs.congr v u (f.trans g) = (WithAb... | null | true |
Lean.Meta.Iterator.next | Lean.Meta.Iterator | {α : Type} → Lean.Meta.Iterator α → Lean.MetaM (Option (α × Lean.Meta.SavedState)) | Function for getting next value and state pair. | true |
Mathlib.Tactic.Ring.Common.ExBaseNat | Mathlib.Tactic.Ring.Common | Q(ℕ) → Type | `ExBaseNat e` stores the structure of a normalized expression `e : Q(ℕ)`, which appears
as the base of an exponent expression `e^n`. The `sum` constructor is only used when the exponent
`n` is not a constant.
Used to represent normalized natural number expressions in exponents.
`ExBaseNat q($e)` is equivalent to `ExB... | true |
Mathlib.Tactic.Linarith.SimplexAlgorithm.stateLP | Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.PositiveVector | {matType : ℕ → ℕ → Type} →
[Mathlib.Tactic.Linarith.SimplexAlgorithm.UsableInSimplexAlgorithm matType] →
{n m : ℕ} → matType n m → List ℕ → matType (n + 2) (m + 3) | Given matrix `A` and list `strictIndexes` of strict inequalities' indexes, we want to state the
Linear Programming problem which solution would give us a solution for the initial problem (see
`findPositiveVector`).
As an objective function (that we are trying to maximize) we use sum of coordinates from
`strictIndexes`... | true |
Lean.Lsp.FileSystemWatcher.ctorIdx | Lean.Data.Lsp.Workspace | Lean.Lsp.FileSystemWatcher → ℕ | null | false |
WithZero.lt_ofAdd_of_toAdd_unzero_lt | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : Preorder α] {a : WithZero (Multiplicative α)} {b : α} (ha : a ≠ 0),
Multiplicative.toAdd (WithZero.unzero ha) < b → a < ↑(Multiplicative.ofAdd b) | null | true |
_private.Mathlib.Order.Filter.Prod.0.Filter.compl_mem_coprod._simp_1_2 | Mathlib.Order.Filter.Prod | ∀ {α : Type u} {f g : Filter α} {s : Set α}, (s ∈ f ⊔ g) = (s ∈ f ∧ s ∈ g) | null | false |
ProbabilityTheory.HasArgminEstimator.mk | Mathlib.Probability.Decision.BayesEstimator | ∀ {Θ : Type u_1} {𝓧 : Type u_2} {mΘ : MeasurableSpace Θ} {m𝓧 : MeasurableSpace 𝓧} [inst : StandardBorelSpace Θ]
[inst_1 : Nonempty Θ] {𝓨 : Type u_4} [inst_2 : MeasurableSpace 𝓨] {ℓ : Θ → 𝓨 → ENNReal}
{P : ProbabilityTheory.Kernel Θ 𝓧} [inst_3 : ProbabilityTheory.IsFiniteKernel P] {π : MeasureTheory.Measure Θ... | null | true |
ContinuousAddEquiv._sizeOf_inst | Mathlib.Topology.Algebra.ContinuousMonoidHom | (G : Type u) →
{inst : TopologicalSpace G} →
(H : Type v) →
{inst_1 : TopologicalSpace H} → {inst_2 : Add G} → {inst_3 : Add H} → [SizeOf G] → [SizeOf H] → SizeOf (G ≃ₜ+ H) | null | false |
Std.Tactic.BVDecide.LRAT.Internal.PropagateResult.conflict.sizeOf_spec | Std.Tactic.BVDecide.LRAT.Internal.Rup | sizeOf Std.Tactic.BVDecide.LRAT.Internal.PropagateResult.conflict = 1 | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.of_forall_constGet?_eq._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.Raw₀.alterₘ.match_1.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u_3} {β : α → Type u_1} (a : α) (motive : Option (β a) → Sort u_2) (h_1 : Unit → motive none)
(h_2 : (b : β a) → motive (some b)),
(match none with
| none => h_1 ()
| some b => h_2 b) =
h_1 () | null | true |
PointedCone.toSubmodule._proof_3 | Mathlib.Geometry.Convex.Cone.Pointed | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : PartialOrder R] [IsOrderedRing R], PosMulMono R | null | false |
CategoryTheory.Functor.FullyFaithful.isMonHom_preimage | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D} [inst_4 : F.Monoidal] (hF : F.FullyFaithful) {X Y : C}
[inst_5 : Catego... | null | true |
Finite.of_injective | Mathlib.Data.Fintype.EquivFin | ∀ {α : Sort u_3} {β : Sort u_4} [Finite β] (f : α → β), Function.Injective f → Finite α | null | true |
_private.Lean.Parser.Syntax.0.Lean.Parser.Syntax.binary._regBuiltin.Lean.Parser.Syntax.binary.formatter_7 | Lean.Parser.Syntax | IO Unit | null | false |
CategoryTheory.PreGaloisCategory.PointedGaloisObject.incl_obj | Mathlib.CategoryTheory.Galois.Prorepresentability | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] [inst_1 : CategoryTheory.GaloisCategory C]
(F : CategoryTheory.Functor C FintypeCat) (A : CategoryTheory.PreGaloisCategory.PointedGaloisObject F),
(CategoryTheory.PreGaloisCategory.PointedGaloisObject.incl F).obj A = A.obj | null | true |
_private.Init.Data.Array.Sort.Lemmas.0.Array.mergeSort_of_pairwise._simp_1_1 | Init.Data.Array.Sort.Lemmas | ∀ {α : Type u_1} {as : List α} {bs : Array α}, (as.toArray = bs) = (as = bs.toList) | null | false |
CategoryTheory.MonoidalOpposite.tensorRightIso_inv_app_unmop | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X X_1 : Cᴹᵒᵖ),
(X.tensorRightIso.inv.app X_1).unmop =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorObj X.unmop X_1.unmop) | null | true |
_private.Lean.Elab.Tactic.Conv.Simp.0.Lean.Elab.Tactic.Conv.evalSimpMatch._regBuiltin.Lean.Elab.Tactic.Conv.evalSimpMatch_1 | Lean.Elab.Tactic.Conv.Simp | IO Unit | null | false |
Ideal.mem_span_singleton' | Mathlib.RingTheory.Ideal.Span | ∀ {α : Type u} [inst : Semiring α] {x y : α}, x ∈ Ideal.span {y} ↔ ∃ a, a * y = x | null | true |
_private.Lean.Elab.Declaration.0.Lean.Elab.Command.expandDeclNamespace?.match_1 | Lean.Elab.Declaration | (motive : Lean.Name → Sort u_1) →
(x : Lean.Name) →
((str : String) → motive (Lean.Name.anonymous.str str)) →
((pre : Lean.Name) → (shortName : String) → motive (pre.str shortName)) → ((x : Lean.Name) → motive x) → motive x | null | false |
SecondCountableTopology.rec | Mathlib.Topology.Bases | {α : Type u} →
[t : TopologicalSpace α] →
{motive : SecondCountableTopology α → Sort u_1} →
((is_open_generated_countable : ∃ b, b.Countable ∧ t = TopologicalSpace.generateFrom b) → motive ⋯) →
(t : SecondCountableTopology α) → motive t | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.