name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
WithTop.eq_of_forall_le_coe_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : PartialOrder α] {x y : WithTop α} [NoTopOrder α], (∀ (a : α), x ≤ ↑a ↔ y ≤ ↑a) → x = y | null | true |
FirstOrder.Language.BoundedFormula.realize_bdEqual._simp_1 | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {l : ℕ} {v : α → M} {xs : Fin l → M}
(t₁ t₂ : L.Term (α ⊕ Fin l)),
(t₁.bdEqual t₂).Realize v xs =
(FirstOrder.Language.Term.realize (Sum.elim v xs) t₁ = FirstOrder.Language.Term.realize (Sum.elim v xs) t₂) | null | false |
Module.Dual.extendRCLikeₗ._proof_8 | Mathlib.Analysis.RCLike.Extend | ∀ {𝕜 : Type u_2} [inst : RCLike 𝕜] {F : Type u_1} [inst_1 : AddCommGroup F] [inst_2 : Module ℝ F] [inst_3 : Module 𝕜 F]
[IsScalarTower ℝ 𝕜 F], LinearMap.CompatibleSMul F 𝕜 ℝ 𝕜 | null | false |
Std.DTreeMap.Raw.Const.equiv_iff_toList_perm | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t₁ t₂ : Std.DTreeMap.Raw α (fun x => β) cmp},
t₁.Equiv t₂ ↔ (Std.DTreeMap.Raw.Const.toList t₁).Perm (Std.DTreeMap.Raw.Const.toList t₂) | null | true |
Std.Do.SPred.Tactic.HasFrame.mk._flat_ctor | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P : Std.Do.SPred σs} {P' : outParam (Std.Do.SPred σs)} {φ : outParam Prop},
(P ⊣⊢ₛ P' ∧ ⌜φ⌝) → Std.Do.SPred.Tactic.HasFrame P P' φ | null | false |
countableInfClosure_eq_self._simp_1 | Mathlib.Order.CountableSupClosed | ∀ {α : Type u_2} {s : Set α} [inst : Preorder α], (countableInfClosure s = s) = CountableInfClosed s | null | false |
Matroid.IsLoop.dep | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α} {e : α}, M.IsLoop e → M.Dep {e} | **Alias** of the reverse direction of `Matroid.singleton_dep`. | true |
Fintype.prod_mono | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_1} {M : Type u_4} [inst : Fintype ι] [inst_1 : CommMonoid M] [inst_2 : Preorder M] [MulLeftMono M],
Monotone fun f => ∏ i, f i | null | true |
Ordnode.nth | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → Ordnode α → ℕ → Option α | O(log n). Get the `i`th element of the set, by its index from left to right.
```
nth {a, b, c, d} 2 = some c
nth {a, b, c, d} 5 = none
``` | true |
_private.Std.WP.Triple.SpecLemmas.0.List.forIn'_cons.match_1.eq_2 | Std.WP.Triple.SpecLemmas | ∀ {β : Type u_1} (motive : ForInStep β → Sort u_2) (b : β) (h_1 : (b : β) → motive (ForInStep.done b))
(h_2 : (b : β) → motive (ForInStep.yield b)),
(match ForInStep.yield b with
| ForInStep.done b => h_1 b
| ForInStep.yield b => h_2 b) =
h_2 b | null | true |
GroupFilterBasis.mul' | Mathlib.Topology.Algebra.FilterBasis | ∀ {G : Type u} {inst : Group G} [self : GroupFilterBasis G] {U : Set G}, U ∈ self.sets → ∃ V ∈ self.sets, V * V ⊆ U | null | true |
AddOpposite.op_sub | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : SubNegMonoid α] (x y : α), AddOpposite.op (x - y) = -AddOpposite.op y + AddOpposite.op x | null | true |
CategoryTheory.Comma.mapRightId._proof_5 | Mathlib.CategoryTheory.Comma.Basic | ∀ {B : Type u_4} [inst : CategoryTheory.Category.{u_1, u_4} B] {A : Type u_5}
[inst_1 : CategoryTheory.Category.{u_2, u_5} A] {T : Type u_6} [inst_2 : CategoryTheory.Category.{u_3, u_6} T]
(R : CategoryTheory.Functor B T) (L : CategoryTheory.Functor A T) {X Y : CategoryTheory.Comma L R} (f : Y ⟶ X),
CategoryTheor... | null | false |
CategoryTheory.Limits.colim.coconeFlip_pt | Mathlib.CategoryTheory.Limits.ColimitLimit | ∀ {J : Type u₁} {K : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} J] [inst_1 : CategoryTheory.Category.{v₂, u₂} K]
{C : Type u} [inst_2 : CategoryTheory.Category.{v, u} C] [inst_3 : CategoryTheory.Limits.HasColimitsOfShape K C]
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C)),
(CategoryTheory.Limi... | null | true |
_private.Mathlib.Topology.Algebra.InfiniteSum.SummationFilter.0.SummationFilter.conditional_filter_eq_map_range._simp_1_3 | Mathlib.Topology.Algebra.InfiniteSum.SummationFilter | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {m : α → β} {t : Set β}, (t ∈ Filter.map m f) = (m ⁻¹' t ∈ f) | null | false |
MeasureTheory.projectiveFamilyContent_mono | Mathlib.MeasureTheory.Constructions.ProjectiveFamilyContent | ∀ {ι : Type u_1} {α : ι → Type u_2} {mα : (i : ι) → MeasurableSpace (α i)}
{P : (J : Finset ι) → MeasureTheory.Measure ((j : ↥J) → α ↑j)} {s t : Set ((i : ι) → α i)}
(hP : MeasureTheory.IsProjectiveMeasureFamily P),
s ∈ MeasureTheory.measurableCylinders α →
t ∈ MeasureTheory.measurableCylinders α →
s ⊆ ... | null | true |
Lake.ComparatorOp.ne | Lake.Util.Version | Lake.ComparatorOp | null | true |
CategoryTheory.Subobject.underlying_arrow | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {Y Z : CategoryTheory.Subobject X} (f : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Subobject.underlying.map f) Z.arrow = Y.arrow | null | true |
_private.Mathlib.CategoryTheory.FintypeCat.0.FintypeCat.uSwitchEquivalence._simp_5 | Mathlib.CategoryTheory.FintypeCat | ∀ {X Y : FintypeCat} (f : X ⟶ Y) (x : (FintypeCat.uSwitch.obj X).obj),
Y.uSwitchEquiv ((CategoryTheory.ConcreteCategory.hom (FintypeCat.uSwitch.map f)) x) =
(CategoryTheory.ConcreteCategory.hom f) (X.uSwitchEquiv x) | null | false |
Filter.EventuallyEq.fderivWithin_eq_of_nhds | Mathlib.Analysis.Calculus.FDeriv.Congr | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f f₁ : E → F} {x : E} {s : Set E},
f₁ =ᶠ[nhds x] f → fderivWithin 𝕜 f₁... | null | true |
_private.Init.Data.SInt.Bitwise.0.Int32.xor_not._simp_1_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int32}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
_private.Mathlib.Geometry.Manifold.ContMDiff.Defs.0.contMDiffWithinAt_insert_self._simp_1_1 | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : 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... | null | false |
PowerSeries.coeff_one_substInv | Mathlib.RingTheory.PowerSeries.Substitution | ∀ {R : Type u_2} [inst : CommRing R] (P : PowerSeries R) [inst_1 : Invertible ((PowerSeries.coeff 1) P)],
(PowerSeries.coeff 1) P.substInv = ⅟((PowerSeries.coeff 1) P) | null | true |
CategoryTheory.Adjunction.rightExtensionPostcompose₂._proof_2 | Mathlib.CategoryTheory.Functor.KanExtension.AdjunctionPreserves | ∀ {C : Type u_1} {D : Type u_5} {H₁ : Type u_3} {H₂ : Type u_8} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_6, u_5} D] [inst_2 : CategoryTheory.Category.{u_2, u_3} H₁]
[inst_3 : CategoryTheory.Category.{u_7, u_8} H₂] {G₁ : CategoryTheory.Functor H₁ H₂}
{G₂ : CategoryTheory.F... | null | false |
normal_iff | Mathlib.FieldTheory.Normal.Defs | ∀ {F : Type u_1} {K : Type u_2} [inst : Field F] [inst_1 : Field K] [inst_2 : Algebra F K],
Normal F K ↔ ∀ (x : K), IsIntegral F x ∧ (Polynomial.map (algebraMap F K) (minpoly F x)).Splits | null | true |
_private.Lean.Server.References.0.Lean.Server.combineIdents.match_1 | Lean.Server.References | (motive : Lean.Elab.Info → Sort u_1) →
(info : Lean.Elab.Info) →
((ai : Lean.Elab.FVarAliasInfo) → motive (Lean.Elab.Info.ofFVarAliasInfo ai)) →
((x : Lean.Elab.Info) → motive x) → motive info | null | false |
BoundedLatticeHom.subtypeVal._proof_1 | Mathlib.Order.Hom.BoundedLattice | ∀ {β : Type u_1} [inst : Lattice β] [inst_1 : BoundedOrder β] {P : β → Prop} (Pbot : P ⊥) (Ptop : P ⊤)
(Psup : ∀ ⦃x y : β⦄, P x → P y → P (x ⊔ y)) (Pinf : ∀ ⦃x y : β⦄, P x → P y → P (x ⊓ y)),
(LatticeHom.subtypeVal Psup Pinf).toFun ⊤ = ⊤ | null | false |
MeasureTheory.VectorMeasure.integral_finsetSum | Mathlib.MeasureTheory.VectorMeasure.Integral | ∀ {ι : Type u_1} {X : Type u_2} {E : Type u_4} {F : Type u_5} {G : Type u_6} {mX : MeasurableSpace X}
[inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F]
[inst_4 : NormedAddCommGroup G] [inst_5 : NormedSpace ℝ G] {μ : MeasureTheory.VectorMeasure X F}
... | null | true |
_private.Mathlib.Tactic.NormNum.Basic.0.Mathlib.Meta.NormNum.evalDiv.match_1 | Mathlib.Tactic.NormNum.Basic | {u : Lean.Level} →
{α : Q(Type u)} →
(a b : Q(«$α»)) →
(dsα : Q(DivisionSemiring «$α»)) →
(dα : Q(DivisionRing «$α»)) →
(motive : ℚ × (n : Q(ℤ)) × (d : Q(ℕ)) × Q(Mathlib.Meta.NormNum.IsRat («$a» * «$b»⁻¹) «$n» «$d») → Sort u_1) →
(x : ℚ × (n : Q(ℤ)) × (d : Q(ℕ)) × Q(Mathlib.Met... | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_665 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
RelSeries.fromListIsChain | Mathlib.Order.RelSeries | {α : Type u_1} → {r : SetRel α α} → (x : List α) → x ≠ [] → List.IsChain (fun x1 x2 => (x1, x2) ∈ r) x → RelSeries r | Every nonempty list satisfying the chain condition gives a relation series | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toArray_rco_add_succ_right_eq_push._simp_1_2 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {α : Type u_1} {as : List α} {bs : Array α}, (as.toArray = bs) = (as = bs.toList) | null | false |
Lean.Widget.WidgetInstance.noConfusion | Lean.Widget.Types | {P : Sort u} → {t t' : Lean.Widget.WidgetInstance} → t = t' → Lean.Widget.WidgetInstance.noConfusionType P t t' | null | false |
AddOpposite.instMulOneClass._proof_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : MulOneClass α], AddOpposite.unop 1 = 1 | null | false |
Algebra.Presentation.tensorModelOfHasCoeffsInv._proof_1 | Mathlib.RingTheory.Extension.Presentation.Core | ∀ {R : Type u_4} {S : Type u_5} {ι : Type u_2} {σ : Type u_3} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] (P : Algebra.Presentation R S ι σ) (R₀ : Type u_1) [inst_3 : CommRing R₀]
[inst_4 : Algebra R₀ R] [inst_5 : Algebra R₀ S] [inst_6 : IsScalarTower R₀ R S] [inst_7 : P.HasCoeffs R₀],
(Ideal... | null | false |
CategoryTheory.Limits.LimitBicone.noConfusion | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {P : Sort u} →
{J : Type w} →
{C : Type uC} →
{inst : CategoryTheory.Category.{uC', uC} C} →
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms C} →
{F : J → C} →
{t : CategoryTheory.Limits.LimitBicone F} →
{J' : Type w} →
{C' : Type uC} →
... | null | false |
linearMapOfMemClosureRangeCoe_apply | Mathlib.Topology.Algebra.Module.Basic | ∀ {M₁ : Type u_1} {M₂ : Type u_2} {R : Type u_4} {S : Type u_5} [inst : TopologicalSpace M₂] [inst_1 : T2Space M₂]
[inst_2 : Semiring R] [inst_3 : Semiring S] [inst_4 : AddCommMonoid M₁] [inst_5 : AddCommMonoid M₂]
[inst_6 : Module R M₁] [inst_7 : Module S M₂] [inst_8 : ContinuousConstSMul S M₂] [inst_9 : Continuou... | null | true |
RingQuot.wrapped._@.Mathlib.Algebra.RingQuot.1074400100._hygCtx._hyg.2 | Mathlib.Algebra.RingQuot | Subtype (Eq @RingQuot.definition✝) | null | false |
AddMonoid.End.instAddCommGroup._proof_9 | Mathlib.Algebra.Group.Hom.Instances | ∀ {M : Type u_1} [inst : AddCommGroup M],
autoParam (∀ (n : ℕ) (a : AddMonoid.End M), ↑n.succ • a = ↑n • a + a) SubNegMonoid.zsmul_succ'._autoParam | null | false |
_private.Mathlib.Topology.CWComplex.Classical.Basic.0.Topology.RelCWComplex.cellFrontier_subset_finite_openCell._simp_1_3 | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
Sat.Literal.pos.noConfusion | Mathlib.Tactic.Sat.FromLRAT | {P : Sort u} → {a a' : ℕ} → Sat.Literal.pos a = Sat.Literal.pos a' → (a = a' → P) → P | null | false |
Module.Basis.instFunLike._proof_1 | Mathlib.LinearAlgebra.Basis.Defs | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(f g : Module.Basis ι R M),
(fun b i => b.repr.symm fun₀ | i => 1) f = (fun b i => b.repr.symm fun₀ | i => 1) g → ↑f.repr.symm = ↑g.repr.symm | null | false |
instWeakEMetricSpaceEReal._proof_4 | Mathlib.Topology.EMetricSpace.Weak | ∀ (x y : EReal), edist x y = edist y x | null | false |
Units.toAut_inv | Mathlib.CategoryTheory.SingleObj | ∀ (M : Type u) [inst : Monoid M] (a : Mˣ),
((Units.toAut M) a).asIso.inv = (↑((Units.mapEquiv (CategoryTheory.SingleObj.toEnd M)) a)⁻¹).asHom | **Alias** of `Units.toAut_apply_asIso_inv`. | true |
CategoryTheory.SplitMono.map.eq_1 | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{X Y : C} {f : Y ⟶ X} (se : CategoryTheory.SplitMono f) (F : CategoryTheory.Functor C D),
se.map F = { retraction := F.map se.retraction, id := ⋯ } | null | true |
Std.WP.Spec.liftWith_ExceptT | Std.WP.Triple.SpecLemmas | ∀ {m : Type u → Type v} {Pred EPred : Type u} [inst : Monad m] [inst_1 : Std.WP.Assertion Pred]
[inst_2 : Std.WP.Assertion EPred] [inst_3 : Std.WP.WPMonad m Pred EPred] {ε α : Type u}
(f : ({β : Type u} → ExceptT ε m β → m (Except ε β)) → m α) (post : α → Pred) (epost : (ε → Pred) × EPred),
⦃ Std.WP.wp (f fun {β}... | null | true |
Sum.update_inr_apply_inl | Mathlib.Data.Sum.Basic | ∀ {α : Type u} {β : Type v} {γ : Type u_1} [inst : DecidableEq (α ⊕ β)] {f : α ⊕ β → γ} {i : α} {j : β} {x : γ},
Function.update f (Sum.inr j) x (Sum.inl i) = f (Sum.inl i) | null | true |
Set.image_const_sub_Ici | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α] (a b : α),
(fun x => a - x) '' Set.Ici b = Set.Iic (a - b) | null | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.PendingSolverPropagationsData.diseqs.inj | Lean.Meta.Tactic.Grind.Types | ∀ {solverId : ℕ} {ps : Lean.Meta.Grind.ParentSet} {rest : Lean.Meta.Grind.PendingSolverPropagationsData✝}
{solverId_1 : ℕ} {ps_1 : Lean.Meta.Grind.ParentSet} {rest_1 : Lean.Meta.Grind.PendingSolverPropagationsData✝},
Lean.Meta.Grind.PendingSolverPropagationsData.diseqs✝ solverId ps rest =
Lean.Meta.Grind.Pend... | null | true |
CategoryTheory.Functor.Elements.fst | Mathlib.CategoryTheory.Elements | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → {F : CategoryTheory.Functor C (Type w)} → F.Elements → C | **Alias** of `CategoryTheory.Functor.Elements.obj`.
---
the underlying object of an element of a functor to types | true |
_private.Init.Data.Fin.Package.0.Fin.instLinearOrderPackage._simp_8 | Init.Data.Fin.Package | ∀ {n : ℕ} {a b : Fin n}, (a = b) = (↑a = ↑b) | null | false |
AdjoinRoot.algEquivOfEq_symm | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (f g : Polynomial S)
(hfg : f = g), (AdjoinRoot.algEquivOfEq R f g hfg).symm = AdjoinRoot.algEquivOfEq R g f ⋯ | null | true |
_private.Mathlib.NumberTheory.Height.Basic.0.Height.hasFiniteMulSupport_iSup_nonarchAbsVal._proof_1_3 | Mathlib.NumberTheory.Height.Basic | ∀ {K : Type u_1} [inst : Field K] {ι : Type u_2} {x : ι → K} (i : { j // x j ≠ 0 }), ¬x ↑i = 0 | null | false |
Nat.leRec._proof_1 | Mathlib.Data.Nat.Init | 0 ≤ 0 | null | false |
Mathlib.Meta.NormNum.isInt_ratCast | Mathlib.Tactic.NormNum.Inv | ∀ {R : Type u_1} [inst : DivisionRing R] {q : ℚ} {n : ℤ},
Mathlib.Meta.NormNum.IsInt q n → Mathlib.Meta.NormNum.IsInt (↑q) n | null | true |
NonemptyInterval.pure_natCast | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : NatCast α] (n : ℕ), NonemptyInterval.pure ↑n = ↑n | null | true |
MvPolynomial.comp_aeval_apply | Mathlib.Algebra.MvPolynomial.Eval | ∀ {R : Type u} {S₁ : Type v} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁] [inst_2 : Algebra R S₁]
(f : σ → S₁) {B : Type u_2} [inst_3 : CommSemiring B] [inst_4 : Algebra R B] (φ : S₁ →ₐ[R] B) (p : MvPolynomial σ R),
φ ((MvPolynomial.aeval f) p) = (MvPolynomial.aeval fun i => φ (f i)) p | null | true |
_private.Mathlib.Algebra.Polynomial.HasseDeriv.0.Polynomial.factorial_smul_hasseDeriv._simp_1_2 | Mathlib.Algebra.Polynomial.HasseDeriv | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] (n : ℕ), ↑n + 1 = ↑n.succ | null | false |
RBTree.RBColor | Batteries.Recycling.RBTree.Basic | Type | In a red-black tree, every node has a color which is either "red" or "black"
(this particular choice of colors is conventional). A nil node is considered black.
| true |
subsingleton_setOfPred_mem_iff_pairwise_disjoint | Mathlib.Data.Set.Pairwise.Basic | ∀ {α : Type u_1} {ι : Type u_4} {f : ι → Set α},
(∀ (a : α), {i | a ∈ f i}.Subsingleton) ↔ Pairwise (Function.onFun Disjoint f) | null | true |
InfHom.instPartialOrder.eq_1 | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Min α] [inst_1 : SemilatticeInf β],
InfHom.instPartialOrder = PartialOrder.lift DFunLike.coe ⋯ | null | true |
Std.DTreeMap.Raw.getKey!_eq_of_contains | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] [inst : Inhabited α], t.WF → ∀ {k : α}, t.contains k = true → t.getKey! k = k | null | true |
CompletelyPositiveMap.noConfusion | Mathlib.Analysis.CStarAlgebra.CompletelyPositiveMap | {P : Sort u} →
{A₁ : Type u_1} →
{A₂ : Type u_2} →
{inst : NonUnitalCStarAlgebra A₁} →
{inst_1 : NonUnitalCStarAlgebra A₂} →
{inst_2 : PartialOrder A₁} →
{inst_3 : PartialOrder A₂} →
{inst_4 : StarOrderedRing A₁} →
{inst_5 : StarOrderedRing A₂} →
... | null | false |
_private.Mathlib.Algebra.Module.Submodule.Pointwise.0.Submodule.set_smul_eq_iSup._simp_1_2 | Mathlib.Algebra.Module.Submodule.Pointwise | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {f : ι → α} {a : α}, (iSup f ≤ a) = ∀ (i : ι), f i ≤ a | null | false |
_private.Mathlib.Topology.Algebra.ValuativeRel.Completion.0.Valuation.closure_image_coe_ofPred_map_lt._simp_1_3 | Mathlib.Topology.Algebra.ValuativeRel.Completion | ∀ {α : Type u_1} {a : α} [inst : PartialOrder α] [inst_1 : Zero α] [IsBotZeroClass α], (0 < a) = (a ≠ 0) | null | false |
_private.Mathlib.Data.Finmap.0.Finmap.any._simp_1 | Mathlib.Data.Finmap | ∀ (α : Sort u), (∀ (a : α), True) = True | null | false |
_private.Lean.Elab.PreDefinition.PartialFixpoint.Main.0.Lean.Elab.replaceRecApps._sparseCasesOn_1 | Lean.Elab.PreDefinition.PartialFixpoint.Main | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
PerfectClosure.mk_inv | Mathlib.FieldTheory.PerfectClosure | ∀ (K : Type u) [inst : Field K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p] (x : ℕ × K),
(PerfectClosure.mk K p x)⁻¹ = PerfectClosure.mk K p (x.1, x.2⁻¹) | null | true |
_private.Mathlib.Probability.Kernel.IonescuTulcea.Traj.0.ProbabilityTheory.Kernel.condExp_traj'._simp_1_1 | Mathlib.Probability.Kernel.IonescuTulcea.Traj | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Iic b) = (x ≤ b) | null | false |
LieSubmodule.subset_lieSpan | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] {s : Set M}, s ⊆ ↑(LieSubmodule.lieSpan R L s) | null | true |
CategoryTheory.Monad.ForgetCreatesLimits.liftedConeIsLimit._proof_4 | Mathlib.CategoryTheory.Monad.Limits | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {T : CategoryTheory.Monad C} {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] (D : CategoryTheory.Functor J T.Algebra)
(c : CategoryTheory.Limits.Cone (D.comp T.forget)) (t : CategoryTheory.Limits.IsLimit c)
(s : CategoryTheory.Limits.Co... | null | false |
RatFunc.toFractionRingRingEquiv._proof_8 | Mathlib.FieldTheory.RatFunc.Basic | ∀ (K : Type u_1) [inst : CommRing K] (toFractionRing toFractionRing_1 : FractionRing (Polynomial K)),
({ toFractionRing := toFractionRing } + { toFractionRing := toFractionRing_1 }).toFractionRing =
{ toFractionRing := toFractionRing }.toFractionRing + { toFractionRing := toFractionRing_1 }.toFractionRing | null | false |
Int.subNatNat_elim | Init.Data.Int.Lemmas | ∀ (m n : ℕ) (motive : ℕ → ℕ → ℤ → Prop),
(∀ (i n : ℕ), motive (n + i) n ↑i) →
(∀ (i m : ℕ), motive m (m + i + 1) (Int.negSucc i)) → motive m n (Int.subNatNat m n) | null | true |
ContinuousLinearMap.toSpanSingleton_inj | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Basic | ∀ {R₁ : Type u_1} [inst : Semiring R₁] {M₂ : Type u_6} [inst_1 : TopologicalSpace M₂] [inst_2 : AddCommMonoid M₂]
[inst_3 : Module R₁ M₂] [inst_4 : TopologicalSpace R₁] [inst_5 : ContinuousSMul R₁ M₂] {f f' : M₂},
ContinuousLinearMap.toSpanSingleton R₁ f = ContinuousLinearMap.toSpanSingleton R₁ f' ↔ f = f' | null | true |
ArithmeticFunction.LSeries_mul | Mathlib.NumberTheory.LSeries.Convolution | ∀ {f g : ArithmeticFunction ℂ} {s : ℂ},
(LSeries.abscissaOfAbsConv fun n => f n) < ↑s.re →
(LSeries.abscissaOfAbsConv fun n => g n) < ↑s.re →
LSeries (fun n => (f * g) n) s = LSeries (fun n => f n) s * LSeries (fun n => g n) s | The L-series of the (convolution) product of two `ℂ`-valued arithmetic functions `f` and `g`
equals the product of their L-series in their common half-plane of absolute convergence. | true |
PFunctor.mk._flat_ctor | Mathlib.Data.PFunctor.Univariate.Basic | (A : Type uA) → (A → Type uB) → PFunctor.{uA, uB} | null | false |
Std.Http.Header.ContentLength.mk._flat_ctor | Std.Http.Data.Headers.Basic | ℕ → Std.Http.Header.ContentLength | null | false |
Lean.HeadIndex.sort | Lean.HeadIndex | Lean.HeadIndex | null | true |
_private.Mathlib.Topology.Constructions.SumProd.0.isClosed_sum_iff._simp_1_1 | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsClosed s = IsOpen sᶜ | null | false |
mdifferentiableWithinAt_comp_projIcc_iff | Mathlib.Geometry.Manifold.Instances.Icc | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type u_2} [inst_2 : TopologicalSpace H]
{I : ModelWithCorners ℝ E H} {M : Type u_3} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M] {x y : ℝ}
[h : Fact (x < y)] {f : ↑(Set.Icc x y) → M} {w : ↑(Set.Icc x y)},
MDiffAt[Set.Icc x... | null | true |
QuadraticMap.polar_smul_left_of_tower | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {S : Type u_1} {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : Module R M] [inst_4 : Module R N] (Q : QuadraticMap R M N)
[inst_5 : CommSemiring S] [inst_6 : Algebra S R] [inst_7 : Module S M] [IsScalarTower S R M] [inst_9 : Module S N... | null | true |
NumberField.dedekindZeta_residue_pos | Mathlib.NumberTheory.NumberField.DedekindZeta | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K], 0 < NumberField.dedekindZeta_residue K | null | true |
Std.DHashMap.Const.isEmpty_of_isEmpty_insertManyIfNewUnit | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α fun x => Unit} {ρ : Type w} [inst : ForIn Id ρ α]
[EquivBEq α] [LawfulHashable α] {l : ρ},
(Std.DHashMap.Const.insertManyIfNewUnit m l).isEmpty = true → m.isEmpty = true | null | true |
EStateM.run_throw | Init.Control.Lawful.Instances | ∀ {ε σ : Type u_1} (e : ε) (s : σ), (throw e).run s = EStateM.Result.error e s | null | true |
ConvexBody.ext_iff | Mathlib.Analysis.Convex.Body | ∀ {V : Type u_1} [inst : TopologicalSpace V] [inst_1 : AddCommGroup V] [inst_2 : Module ℝ V] {K L : ConvexBody V},
K = L ↔ ↑K = ↑L | null | true |
Equiv.swapCore_self | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} [inst : DecidableEq α] (r a : α), Equiv.swapCore a a r = r | null | true |
_private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Relations.0.RootPairing.GeckConstruction.lie_e_f_ne._simp_1_1 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Relations | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b | null | false |
Lean.Elab.Tactic.instInhabitedState | Lean.Elab.Term.TermElabM | Inhabited Lean.Elab.Tactic.State | null | true |
_private.Mathlib.LinearAlgebra.Matrix.Determinant.Bird.Correctness.0.BirdDet.S_succ_eq_biUnion._simp_1_1 | Mathlib.LinearAlgebra.Matrix.Determinant.Bird.Correctness | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : α → Finset β} [inst : DecidableEq β] {b : β},
(b ∈ s.biUnion t) = ∃ a ∈ s, b ∈ t a | null | false |
instAddGroupObjOppositeOpensCarrierOfPresheafSmoothSheaf._aux_3 | Mathlib.Geometry.Manifold.Sheaf.Smooth | {𝕜 : Type u_2} →
[inst : NontriviallyNormedField 𝕜] →
{EM : Type u_3} →
[inst_1 : NormedAddCommGroup EM] →
[inst_2 : NormedSpace 𝕜 EM] →
{HM : Type u_4} →
[inst_3 : TopologicalSpace HM] →
(IM : ModelWithCorners 𝕜 EM HM) →
{E : Type u_5} →
... | null | false |
_private.Mathlib.Data.Finset.Card.0.Finset.card_insert_le._proof_1_1 | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α), (insert a s).card ≤ s.card + 1 | null | false |
Affine.Simplex.centroidWeightsWithCircumcenter.eq_2 | Mathlib.Geometry.Euclidean.Circumcenter | ∀ {n : ℕ} (fs : Finset (Fin (n + 1))),
Affine.Simplex.centroidWeightsWithCircumcenter fs Affine.Simplex.PointsWithCircumcenterIndex.circumcenterIndex = 0 | null | true |
IsPreconnected.eq_or_eq_neg_of_sq_eq | Mathlib.Topology.Algebra.Field | ∀ {α : Type u_2} {𝕜 : Type u_3} {f g : α → 𝕜} {S : Set α} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace 𝕜]
[T1Space 𝕜] [inst_3 : Field 𝕜] [ContinuousInv₀ 𝕜] [ContinuousMul 𝕜],
IsPreconnected S →
ContinuousOn f S →
ContinuousOn g S → Set.EqOn (f ^ 2) (g ^ 2) S → (∀ {x : α}, x ∈ S → g x ≠ 0)... | If `f, g` are functions `α → 𝕜`, both continuous on a preconnected set `S`, with
`f ^ 2 = g ^ 2` on `S`, and `g z ≠ 0` all `z ∈ S`, then either `f = g` or `f = -g` on
`S`. | true |
CategoryTheory.SimplicialObject.Augmented.whiskering._proof_3 | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] (D : Type u_4)
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {X Y : CategoryTheory.Functor C D} (η : X ⟶ Y)
⦃X_1 Y_1 : CategoryTheory.SimplicialObject.Augmented C⦄ (f : X_1 ⟶ Y_1),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.SimplicialObject... | null | false |
AbsoluteValue._sizeOf_1 | Mathlib.Algebra.Order.AbsoluteValue.Basic | {R : Type u_4} →
{S : Type u_5} →
{inst : Semiring R} →
{inst_1 : Semiring S} → {inst_2 : PartialOrder S} → [SizeOf R] → [SizeOf S] → AbsoluteValue R S → ℕ | null | false |
String.Pos.Raw.offsetBy_sliceRawEndPos_left | Init.Data.String.Defs | ∀ {p : String.Pos.Raw} {s : String.Slice}, s.rawEndPos.offsetBy p = p + s | null | true |
HasDerivWithinAt.lhopital_zero_nhdsWithin_convex | Mathlib.Analysis.Calculus.LHopital | ∀ {a : ℝ} {l : Filter ℝ} {f f' g g' : ℝ → ℝ} {s : Set ℝ},
Convex ℝ s →
(∀ᶠ (x : ℝ) in nhdsWithin a (s \ {a}), HasDerivWithinAt f (f' x) (s \ {a}) x) →
(∀ᶠ (x : ℝ) in nhdsWithin a (s \ {a}), HasDerivWithinAt g (g' x) (s \ {a}) x) →
(∀ᶠ (x : ℝ) in nhdsWithin a (s \ {a}), g' x ≠ 0) →
Filter.T... | L'Hôpital's rule for approaching a real from within a convex set, `HasDerivWithinAt` version.
This does not require anything about the situation at `a` | true |
_private.Mathlib.NumberTheory.ArithmeticFunction.Misc.0.ArithmeticFunction.sum_Ioc_mul_eq_sum_sum._simp_1_2 | Mathlib.NumberTheory.ArithmeticFunction.Misc | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a) | null | false |
CategoryTheory.instAdditiveObjFunctorAdditiveFunctor | Mathlib.CategoryTheory.Preadditive.AdditiveFunctor | ∀ (C : Type u_1) (D : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Preadditive C]
[inst_3 : CategoryTheory.Preadditive D] (F : C ⥤+ D), F.obj.Additive | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.StronglyRegular.0.SimpleGraph.IsSRGWith.param_eq._simp_1_8 | Mathlib.Combinatorics.SimpleGraph.StronglyRegular | ∀ {V : Type u_1} (G : SimpleGraph V) (v : V) [inst : Fintype ↑(G.neighborSet v)] (w : V),
(w ∈ G.neighborFinset v) = G.Adj v w | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.