name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Metric.Snowflaking.mk.inj | Mathlib.Topology.MetricSpace.Snowflaking | ∀ {X : Type u_1} {α : ℝ} {hα₀ : 0 < α} {hα₁ : α ≤ 1} {val val_1 : X}, { val := val } = { val := val_1 } → val = val_1 | null | true |
Matroid.eRk_dual_add_eRank._auto_1 | Mathlib.Combinatorics.Matroid.Rank.ENat | Lean.Syntax | null | false |
Std.DTreeMap.Internal.Impl.Const.getD_inter!_of_contains_right | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α],
m₁.WF →
m₂.WF →
∀ {k : α} {fallback : β},
Std.DTreeMap.Internal.Impl.contains k m₂ = true →
Std.DTreeMap.Internal.Impl.Const.getD (m₁.inter! m₂) k fallback =
Std.DT... | null | true |
ContinuousMap.coe_sum | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : AddCommMonoid β]
[inst_3 : ContinuousAdd β] {ι : Type u_3} (s : Finset ι) (f : ι → C(α, β)), ⇑(∑ i ∈ s, f i) = ∑ i ∈ s, ⇑(f i) | null | true |
CategoryTheory.MorphismProperty.Under.pushout._proof_4 | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] (P Q : CategoryTheory.MorphismProperty T) {X Y : T}
(f : X ⟶ Y) [inst_1 : P.HasPushoutsAlong f] [P.IsStableUnderCobaseChangeAlong f] (A : P.Under Q X),
P (CategoryTheory.Limits.pushout.inr A.hom f) | null | false |
Std.DTreeMap.Internal.Impl.WF.below.constModify | Std.Data.DTreeMap.Internal.WF.Defs | ∀ {α : Type u} [inst : Ord α] {motive : {β : α → Type v} → (a : Std.DTreeMap.Internal.Impl α β) → a.WF → Prop}
{x : Type v} {t : Std.DTreeMap.Internal.Impl α fun x_1 => x} {k : α} {f : x → x} (a : t.WF),
Std.DTreeMap.Internal.Impl.WF.below a → motive t a → Std.DTreeMap.Internal.Impl.WF.below ⋯ | null | true |
Additive.instUniqueSumsOfUniqueProds | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {M : Type u_1} [inst : Mul M] [UniqueProds M], UniqueSums (Additive M) | null | true |
ContDiffOn.neg | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : WithTop ℕ∞}
{s : Set E} {f : E → F}, ContDiffOn 𝕜 n f s → ContDiffOn 𝕜 n (fun x => -f x) s | The negative of a `C^n` function on a domain is `C^n`. | true |
String.Slice.Pos.sliceTo | Init.Data.String.Basic | {s : String.Slice} → (p₀ pos : s.Pos) → pos ≤ p₀ → (s.sliceTo p₀).Pos | Given a position in `s` that is at most `p₀`, obtain the corresponding position in `s.sliceTo p₀`. | true |
FreeGroup.instDecidableEq | Mathlib.GroupTheory.FreeGroup.Reduce | {α : Type u_1} → [DecidableEq α] → DecidableEq (FreeGroup α) | null | true |
HurwitzZeta.sinZeta_eq | Mathlib.NumberTheory.LSeries.HurwitzZeta | ∀ (a : UnitAddCircle) (s : ℂ),
HurwitzZeta.sinZeta a s = (HurwitzZeta.expZeta a s - HurwitzZeta.expZeta (-a) s) / (2 * Complex.I) | null | true |
Std.Internal.UV.System.instReprCPUTimes.repr | Std.Internal.UV.System | Std.Internal.UV.System.CPUTimes → ℕ → Std.Format | null | true |
Lean.Compiler.LCNF.LetValue.oproj.inj | Lean.Compiler.LCNF.Basic | ∀ {pu : Lean.Compiler.LCNF.Purity} {i : ℕ} {var : Lean.FVarId}
{h : autoParam (pu = Lean.Compiler.LCNF.Purity.impure) Lean.Compiler.LCNF.LetValue._auto_7} {i_1 : ℕ}
{var_1 : Lean.FVarId} {h_1 : autoParam (pu = Lean.Compiler.LCNF.Purity.impure) Lean.Compiler.LCNF.LetValue._auto_7},
Lean.Compiler.LCNF.LetValue.opro... | null | true |
contDiffWithinAt_piLp_apply | Mathlib.Analysis.Calculus.ContDiff.WithLp | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : ι → Type u_3} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → NormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)] [inst_3 : Fintype ι]
(p : ENNReal) [inst_4 : Fact (1 ≤ p)] {n : WithTop ℕ∞} {i : ι} {t : Set (PiLp p E)} {y : PiLp p E},
ContDiffWithinAt ... | null | true |
Submonoid.mem_comap | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] {S : Submonoid N} {f : F} {x : M}, x ∈ Submonoid.comap f S ↔ f x ∈ S | null | true |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation.0.Real.rpowIntegrand₀₁_eqOn_mul_rpowIntegrand₀₁_one._simp_1_5 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation | ∀ {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.RingTheory.Multiplicity.0.FiniteMultiplicity.ne_zero.match_1_1 | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} [inst : MonoidWithZero α] {a b : α} (motive : FiniteMultiplicity a b → Prop)
(h : FiniteMultiplicity a b), (∀ (n : ℕ) (hn : ¬a ^ (n + 1) ∣ b), motive ⋯) → motive h | null | false |
SpecialLinearGroup.toLinearEquiv_symm_to_linearMap | Mathlib.LinearAlgebra.SpecialLinearGroup | ∀ {R : Type u_1} {V : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
(A : SpecialLinearGroup R V), ↑(SpecialLinearGroup.toLinearEquiv A).symm = ↑↑A⁻¹ | null | true |
MeasureTheory.OuterMeasure.mono | Mathlib.MeasureTheory.OuterMeasure.Defs | ∀ {α : Type u_2} (self : MeasureTheory.OuterMeasure α) {s₁ s₂ : Set α}, s₁ ⊆ s₂ → self.measureOf s₁ ≤ self.measureOf s₂ | null | true |
LocallyConstant.zero_apply | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : Zero Y] (x : X), 0 x = 0 | null | true |
Lean.Doc.Inline.ctorElim | Lean.DocString.Types | {i : Type u} →
{motive_1 : Lean.Doc.Inline i → Sort u_1} →
(ctorIdx : ℕ) → (t : Lean.Doc.Inline i) → ctorIdx = t.ctorIdx → Lean.Doc.Inline.ctorElimType ctorIdx → motive_1 t | null | false |
CategoryTheory.SimplicialObject.δ_comp_δ_assoc | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject C) {n : ℕ}
{i j : Fin (n + 2)},
i ≤ j →
∀ {Z : C} (h : X.obj (Opposite.op { len := n }) ⟶ Z),
CategoryTheory.CategoryStruct.comp (X.δ j.succ) (CategoryTheory.CategoryStruct.comp (X.δ i) h) =
CategoryTheor... | The generic case of the first simplicial identity | true |
MeasureTheory.SimpleFunc.instPreorder | Mathlib.MeasureTheory.Function.SimpleFunc | {α : Type u_1} → {β : Type u_2} → [inst : MeasurableSpace α] → [Preorder β] → Preorder (MeasureTheory.SimpleFunc α β) | null | true |
_private.Mathlib.Tactic.FBinop.0.FBinopElab.AnalyzeResult.rec | Mathlib.Tactic.FBinop | {motive : FBinopElab.AnalyzeResult✝ → Sort u} →
((maxS? : Option FBinopElab.SRec) →
(hasUncomparable : Bool) → motive { maxS? := maxS?, hasUncomparable := hasUncomparable }) →
(t : FBinopElab.AnalyzeResult✝) → motive t | null | false |
NumberField.mixedEmbedding.disjoint_span_commMap_ker | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K],
Disjoint (Submodule.span ℝ (Set.range ⇑(NumberField.canonicalEmbedding.latticeBasis K)))
(NumberField.mixedEmbedding.commMap K).ker | This is a technical result to ensure that the image of the `ℂ`-basis of `ℂ^n` defined in
`canonicalEmbedding.latticeBasis` is a `ℝ`-basis of the mixed space `ℝ^r₁ × ℂ^r₂`,
see `mixedEmbedding.latticeBasis`. | true |
SetSemiring.down | Mathlib.Data.Set.Semiring | {α : Type u_1} → SetSemiring α ≃ Set α | The identity function `SetSemiring α → Set α`. | true |
Function.Injective.of_eq_imp_le | Mathlib.Order.Monotone.Defs | ∀ {α : Type u} {β : Type v} [inst : PartialOrder α] {f : α → β}, (∀ {x y : α}, f x = f y → x ≤ y) → Function.Injective f | null | true |
_private.Mathlib.RingTheory.Multiplicity.0.emultiplicity_le_emultiplicity_iff._simp_1_1 | Mathlib.RingTheory.Multiplicity | ∀ {n m : ℕ}, (↑n ≤ ↑m) = (n ≤ m) | null | false |
nhdsWithin_inter' | Mathlib.Topology.NhdsWithin | ∀ {α : Type u_1} [inst : TopologicalSpace α] (a : α) (s t : Set α),
nhdsWithin a (s ∩ t) = nhdsWithin a s ⊓ Filter.principal t | null | true |
UpperHalfPlane.smulFDeriv_J_mul | Mathlib.Analysis.Complex.UpperHalfPlane.Manifold | ∀ (g : GL (Fin 2) ℝ) (z : ℂ),
UpperHalfPlane.smulFDeriv (UpperHalfPlane.J * g) z = -↑Complex.conjCLE ∘SL UpperHalfPlane.smulFDeriv g z | null | true |
Std.Internal.UV.TCP.Socket.recv? | Std.Internal.UV.TCP | Std.Internal.UV.TCP.Socket → UInt64 → IO (IO.Promise (Except IO.Error (Option ByteArray))) | Receives data from a TCP socket with a maximum size of size bytes. The promise resolves when data is
available or an error occurs. If data is received, it’s wrapped in .some. If EOF is reached, the
result is .none, indicating no more data is available. Receiving data in parallel on the same
socket is not supported. Ins... | true |
_private.Mathlib.Data.EReal.Inv.0.EReal.inv_strictAntiOn.match_1_1 | Mathlib.Data.EReal.Inv | ∀ (a : ℝ) (motive : (b : EReal) → 0 < b → ↑a < b → Prop) (b : EReal) (b_0 : 0 < b) (a_b : ↑a < b),
(∀ (b_0 : 0 < ⊤) (a_b : ↑a < ⊤), motive (some none) b_0 a_b) →
(∀ (b_0 : 0 < ⊥) (a_b : ↑a < ⊥), motive none b_0 a_b) →
(∀ (b : ℝ) (b_0 : 0 < ↑b) (a_b : ↑a < ↑b), motive (some (some b)) b_0 a_b) → motive b b_0 ... | null | false |
SymmetricAlgebra.ι._proof_2 | Mathlib.LinearAlgebra.SymmetricAlgebra.Basic | ∀ (R : Type u_1) (M : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
LinearMapClass (TensorAlgebra R M →ₐ[R] SymmetricAlgebra R M) R (TensorAlgebra R M) (SymmetricAlgebra R M) | null | false |
ContinuousLinearMapWOT.tendsto_iff_forall_dual_apply_tendsto | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] {σ : 𝕜₁ →+* 𝕜₂} {E : Type u_3}
{F : Type u_4} [inst_2 : AddCommGroup E] [inst_3 : TopologicalSpace E] [inst_4 : Module 𝕜₁ E]
[inst_5 : AddCommGroup F] [inst_6 : TopologicalSpace F] [inst_7 : Module 𝕜₂ F] [inst_8 : IsTopologi... | The defining property of the weak operator topology: a function `f` tends to
`A : E →WOT[𝕜] F` along filter `l` iff `y (f a x)` tends to `y (A x)` along the same filter. | true |
ContIntertwiningMap.instFunLike | Mathlib.RepresentationTheory.Continuous.Basic | {R : Type u_1} →
{G : Type u_2} →
{V : Type u_3} →
{W : Type u_4} →
[inst : Monoid G] →
[inst_1 : Ring R] →
[inst_2 : AddCommGroup V] →
[inst_3 : TopologicalSpace V] →
[inst_4 : IsTopologicalAddGroup V] →
[inst_5 : Module R V] →
... | null | true |
String.Pos.set._proof_1 | Init.Data.String.Modify | ∀ {s : String} (p : s.Pos) (c : Char) (hp : p ≠ s.endPos),
c.utf8Size = 1 ∧ (p.byte hp).utf8ByteSize ⋯ = 1 → (s.toByteArray.set p.offset.byteIdx c.toUInt8 ⋯).IsValidUTF8 | null | false |
instContinuousMulElemIcoOfNat | Mathlib.Topology.Algebra.Algebra | ∀ (A : Type u) [inst : Semiring A] [inst_1 : TopologicalSpace A] [inst_2 : PartialOrder A] [inst_3 : IsOrderedRing A]
[ContinuousMul A], ContinuousMul ↑(Set.Ico 0 1) | null | true |
ProbabilityTheory.analyticAt_mgf | Mathlib.Probability.Moments.MGFAnalytic | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω} {t : ℝ},
t ∈ interior (ProbabilityTheory.integrableExpSet X μ) → AnalyticAt ℝ (ProbabilityTheory.mgf X μ) t | The moment-generating function is analytic at every `t ∈ interior (integrableExpSet X μ)`. | true |
Int.padicValuation_eq_zero_iff | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] {x : ℤ}, (Int.padicValuation p) x = 0 ↔ x = 0 | null | true |
MinTropical | Mathlib.Algebra.Tropical.Basic | Type u → Type u | The min-tropicalization of a type `R`. | true |
Associates.isUnit_mk | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoid M] {a : M}, IsUnit (Associates.mk a) ↔ IsUnit a | null | true |
Std.HashMap.Raw.map_fst_toList_eq_keys | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → List.map Prod.fst m.toList = m.keys | null | true |
_private.Mathlib.Tactic.Simproc.Divisors.0.Nat.properDivisors_ofNat.unsafe_1 | Mathlib.Tactic.Simproc.Divisors | ℕ → List ℕ | null | true |
Std.HashMap.getKeyD_eq_fallback_of_contains_eq_false | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{a fallback : α}, m.contains a = false → m.getKeyD a fallback = fallback | null | true |
_private.Init.Data.Array.Basic.0.Array.popWhile._proof_1 | Init.Data.Array.Basic | ∀ {α : Type u_1} (as : Array α), as.size > 0 → as.size - 1 < as.size | null | false |
CategoryTheory.IsSifted.of_final_functor_from_sifted | Mathlib.CategoryTheory.Limits.Sifted | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} D]
[h₁ : CategoryTheory.IsSifted C] (F : CategoryTheory.Functor C D) [F.Final], CategoryTheory.IsSifted D | A functor admitting a final functor from a sifted category is sifted. | true |
_private.Mathlib.Analysis.Distribution.SchwartzSpace.Deriv.0.SchwartzMap.tsupport_derivCLM_subset._simp_1_1 | Mathlib.Analysis.Distribution.SchwartzSpace.Deriv | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜}, deriv f x = (fderiv 𝕜 f x) 1 | null | false |
CommApplicative.mk._flat_ctor | Mathlib.Control.Basic | ∀ {m : Type u → Type v} [inst : Applicative m],
(∀ {α β : Type u}, Functor.mapConst = Functor.map ∘ Function.const β) →
(∀ {α : Type u} (x : m α), id <$> x = x) →
(∀ {α β γ : Type u} (g : α → β) (h : β → γ) (x : m α), (h ∘ g) <$> x = h <$> g <$> x) →
(∀ {α β : Type u} (x : m α) (y : m β), x <* y = F... | null | false |
DerivedCategory.left_fac | Mathlib.Algebra.Homology.DerivedCategory.Fractions | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : HasDerivedCategory C] {X Y : CochainComplex C ℤ} (f : DerivedCategory.Q.obj X ⟶ DerivedCategory.Q.obj Y),
∃ Y' g s,
∃ (x : CategoryTheory.IsIso (DerivedCategory.Q.map s)),
f = CategoryTheory.CategoryStru... | Any morphism `f : Q.obj X ⟶ Q.obj Y` in the derived category can be written
as `f = Q.map g ≫ inv (Q.map s)` with `g : X ⟶ Y'` and `s : Y ⟶ Y'` a quasi-isomorphism. | true |
Finset.mk_cons | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {a : α} {s : Multiset α} (h : (a ::ₘ s).Nodup),
{ val := a ::ₘ s, nodup := h } = Finset.cons a { val := s, nodup := ⋯ } ⋯ | null | true |
Std.Packages.LinearOrderOfLEArgs.max_eq | Init.Data.Order.PackageFactories | ∀ {α : Type u} (self : Std.Packages.LinearOrderOfLEArgs α),
let this := self.le;
let this_1 := self.decidableLE;
let this_2 := self.max;
∀ (a b : α), a ⊔ b = if b ≤ a then a else b | null | true |
ContinuousMapZero.instT0Space | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ {X : Type u_1} {R : Type u_3} [inst : Zero X] [inst_1 : Zero R] [inst_2 : TopologicalSpace X]
[inst_3 : TopologicalSpace R] [T0Space R], T0Space (ContinuousMapZero X R) | null | true |
Module.Ray.ind | Mathlib.LinearAlgebra.Ray | ∀ (R : Type u_1) [inst : CommSemiring R] [inst_1 : PartialOrder R] [inst_2 : IsStrictOrderedRing R] {M : Type u_2}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] {C : Module.Ray R M → Prop},
(∀ (v : M) (hv : v ≠ 0), C (rayOfNeZero R v hv)) → ∀ (x : Module.Ray R M), C x | An induction principle for `Module.Ray`, used as `induction x using Module.Ray.ind`. | true |
CliffordAlgebra.contractLeft_one | Mathlib.LinearAlgebra.CliffordAlgebra.Contraction | ∀ {R : Type u1} [inst : CommRing R] {M : Type u2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M) (d : Module.Dual R M), (CliffordAlgebra.contractLeft d) 1 = 0 | null | true |
Order.pred_le_of_wcovBy | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] {a b : α}, b ⩿ a → Order.pred a ≤ b | See also `Order.pred_eq_of_covBy`. | true |
MonoidAlgebra.distribMulActionHom_ext'_iff | Mathlib.Algebra.MonoidAlgebra.Module | ∀ {R : Type u_1} {S : Type u_2} {M : Type u_3} [inst : Semiring S] {N : Type u_7} [inst_1 : Monoid R]
[inst_2 : AddMonoid N] [inst_3 : DistribMulAction R N] [inst_4 : DistribMulAction R S]
{f g : MonoidAlgebra S M →+[R] N},
f = g ↔
∀ (a : M), f.comp (MonoidAlgebra.singleDistribMulActionHom a) = g.comp (Monoid... | null | true |
CStarMatrix.instInhabited | Mathlib.Analysis.CStarAlgebra.CStarMatrix | {m : Type u_1} → {n : Type u_2} → {A : Type u_5} → [Inhabited A] → Inhabited (CStarMatrix m n A) | null | true |
Std.ExtTreeSet.mem_iff_isSome_get? | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {a : α},
a ∈ t ↔ (t.get? a).isSome = true | null | true |
_private.Std.Time.Format.Basic.0.Std.Time.exactly.go._unsafe_rec | Std.Time.Format.Basic | {α : Type} → Std.Internal.Parsec.String.Parser α → ℕ → Array α → ℕ → Std.Internal.Parsec.String.Parser (Array α) | null | false |
RootPairing.coroot'In | Mathlib.LinearAlgebra.RootSystem.IsValuedIn | {ι : Type u_1} →
{R : Type u_2} →
{M : Type u_4} →
{N : Type u_5} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R N] →
(P : RootPairing ι R M N) →
... | The `S`-linear map on the span of roots given by evaluating at a coroot. | true |
Aesop.Options.traceScript._default | Aesop.Options.Public | Bool | null | false |
_private.Init.Data.Range.Polymorphic.SInt.0.HasModel.succMany?_eq | Init.Data.Range.Polymorphic.SInt | ∀ {n : ℕ} {α : Type u} [Std.PRange.UpwardEnumerable α] [inst : LE α] [inst_1 : LT α] [m : HasModel✝ α (BitVec n)]
{x : α} {k : ℕ},
Std.PRange.succMany? k x =
if (HasModel.encode✝ x).toInt + ↑k ≤ (BitVec.Signed.intMaxSealed✝ n).toInt then
some (HasModel.decode✝ (BitVec.ofInt n ((HasModel.encode✝ x).toInt +... | null | true |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.Raw₀.expand.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : Hashable α] (data_2 : Array (Std.DHashMap.Internal.AssocList α β))
(hd : 0 < data_2.size),
Std.DHashMap.Internal.Raw₀.expand ⟨data_2, hd⟩ =
Std.DHashMap.Internal.Raw₀.expand.go✝ 0 data_2
⟨data_2.propagateMark (Array.replicate (data_2.size * 2) Std.DHashMap.Internal.... | null | true |
Finset.exists_lt_card_fiber_of_nsmul_lt_card_of_maps_to | Mathlib.Combinatorics.Pigeonhole | ∀ {α : Type u} {β : Type v} {M : Type w} [inst : DecidableEq β] {s : Finset α} {t : Finset β} {f : α → β} {b : M}
[inst_1 : CommSemiring M] [inst_2 : LinearOrder M] [IsStrictOrderedRing M],
(∀ a ∈ s, f a ∈ t) → t.card • b < ↑s.card → ∃ y ∈ t, b < ↑{x ∈ s | f x = y}.card | The pigeonhole principle for finitely many pigeons counted by heads: there is a pigeonhole with
at least as many pigeons as the ceiling of the average number of pigeons across all pigeonholes. | true |
ValuationRing.instInhabitedValueGroup | Mathlib.RingTheory.Valuation.ValuationRing | (A : Type u) →
[inst : CommRing A] →
(K : Type v) → [inst_1 : Field K] → [inst_2 : Algebra A K] → Inhabited (ValuationRing.ValueGroup A K) | null | true |
AddCommSemigroup.mk._flat_ctor | Mathlib.Algebra.Group.Semigroup | {G : Type u_2} →
(add : G → G → G) → (∀ (a b c : G), a + b + c = a + (b + c)) → (∀ (a b : G), a + b = b + a) → AddCommSemigroup G | null | false |
AlgebraicGeometry.Proj.toBasicOpenOfGlobalSections.congr_simp | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Basic | ∀ {σ : Type u_1} {A : Type u} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubgroupClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜] {X : AlgebraicGeometry.Scheme} (f f_1 : A →+* ↑(X.presheaf.obj (Opposite.op ⊤)))
(e_f : f = f_1) {x : ↑(X.presheaf.obj (Opposite.op ⊤))} {t : A} {d d_1 : ℕ} (e_d : d = d_1) ... | null | true |
_private.Lean.Expr.0.Lean.mkAndN._sparseCasesOn_1 | Lean.Expr | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
instIsEquivalenceUliftFunctorOfUnivLE | Mathlib.CategoryTheory.UnivLE | ∀ [UnivLE.{max u v, v}], CategoryTheory.uliftFunctor.{u, v}.IsEquivalence | null | true |
AddSubgroup.inertia_top | Mathlib.Algebra.Group.Subgroup.Basic | ∀ (M : Type u_5) [inst : AddGroup M] (G : Type u_6) [inst_1 : Group G] [inst_2 : MulAction G M], ⊤.inertia G = ⊤ | null | true |
instTopologicalSpaceCircle._aux_1 | Mathlib.Analysis.Complex.Circle | Set Circle → Prop | null | false |
CategoryTheory.MorphismProperty.IsStableUnderBaseChange.op | Mathlib.CategoryTheory.MorphismProperty.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C}
[P.IsStableUnderBaseChange], P.op.IsStableUnderCobaseChange | null | true |
Lean.Meta.Grind.Arith.Linear.DiseqCnstrProof.core.injEq | Lean.Meta.Tactic.Grind.Arith.Linear.Types | ∀ (a b : Lean.Expr) (lhs rhs : Lean.Meta.Grind.Arith.Linear.LinExpr) (a_1 b_1 : Lean.Expr)
(lhs_1 rhs_1 : Lean.Meta.Grind.Arith.Linear.LinExpr),
(Lean.Meta.Grind.Arith.Linear.DiseqCnstrProof.core a b lhs rhs =
Lean.Meta.Grind.Arith.Linear.DiseqCnstrProof.core a_1 b_1 lhs_1 rhs_1) =
(a = a_1 ∧ b = b_1 ∧ lh... | null | true |
AddGrpCat.instFullUliftFunctor | Mathlib.Algebra.Category.Grp.Ulift | AddGrpCat.uliftFunctor.Full | The universe lift functor for additive groups is full. | true |
_private.Mathlib.SetTheory.Cardinal.Cofinality.Club.0.IsClub.sInter._proof_1_6 | Mathlib.SetTheory.Cardinal.Cofinality.Club | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : WellFoundedLT α] (h : Nonempty α), sSup ∅ = ⊥ | null | false |
CategoryTheory.Functor.IsCoverDense.sheafCoyonedaHom_app | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | ∀ {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] {K : CategoryTheory.GrothendieckTopology D} {A : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, u_3} A] {G : CategoryTheory.Functor C D} [inst_3 : G.IsCoverDense K]
[inst_4 : G.IsLocall... | null | true |
Lean.Order.pushOption.eq_2 | Std.WP.Monad.Conjunctive | ∀ {α : Type u} {Pred : Type w} (post : α → Pred) (epost : Unit → Pred), Lean.Order.pushOption post epost none = epost () | null | true |
BoundedAdd.casesOn | Mathlib.Topology.Bornology.BoundedOperation | {R : Type u_1} →
[inst : Bornology R] →
[inst_1 : Add R] →
{motive : BoundedAdd R → Sort u} →
(t : BoundedAdd R) →
((isBounded_add :
∀ {s t : Set R}, Bornology.IsBounded s → Bornology.IsBounded t → Bornology.IsBounded (s + t)) →
motive ⋯) →
motive ... | null | false |
Finset.image₂_subset_iff_left | Mathlib.Data.Finset.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s : Finset α} {t : Finset β}
{u : Finset γ}, Finset.image₂ f s t ⊆ u ↔ ∀ a ∈ s, Finset.image (fun b => f a b) t ⊆ u | null | true |
LinearMap.IsReflective.isOrthogonal_reflection | Mathlib.LinearAlgebra.RootSystem.OfBilinear | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(B : M →ₗ[R] M →ₗ[R] R) {x : M} (hx : B.IsReflective x), B.IsSymm → B.IsOrthogonal ⇑(Module.reflection ⋯) | null | true |
Mathlib.Notation.«term∃!_,_» | Mathlib.Basic.ExistsUnique | Lean.ParserDescr | `∃! x : α, p x` means that there exists a unique `x` in `α` such that `p x`.
This is notation for `ExistsUnique (fun (x : α) ↦ p x)`.
This notation does not allow multiple binders like `∃! (x : α) (y : β), p x y`
as a shorthand for `∃! (x : α), ∃! (y : β), p x y` since it is liable to be misunderstood.
Often, the inte... | true |
Prod.instOmegaCompletePartialOrder | Mathlib.Order.OmegaCompletePartialOrder | {α : Type u_2} →
{β : Type u_3} → [OmegaCompletePartialOrder α] → [OmegaCompletePartialOrder β] → OmegaCompletePartialOrder (α × β) | null | true |
SeminormedAddCommGroup.dist._default | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_4} → (E → ℝ) → (E → E → E) → (E → E) → E → E → ℝ | null | false |
Lean.Json.ctorElim | Lean.Data.Json.Basic | {motive_1 : Lean.Json → Sort u} →
(ctorIdx : ℕ) → (t : Lean.Json) → ctorIdx = t.ctorIdx → Lean.Json.ctorElimType ctorIdx → motive_1 t | null | false |
Function.HasFiniteMulSupport | Mathlib.Algebra.FiniteSupport.Defs | {α : Type u_1} → {M : Type u_2} → [One M] → (α → M) → Prop | The function `f` has finite multiplicative support. | true |
MulActionHom.mk | 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] → (toFun : X → Y) → (∀ (m : M) (x : X), toFun (m • x) = φ m • toFun x) → X →ₑ[φ] Y | null | true |
MeasureTheory.Measure.support_add | Mathlib.MeasureTheory.Measure.Support | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : MeasurableSpace X] (μ ν : MeasureTheory.Measure X),
(μ + ν).support = μ.support ∪ ν.support | The support of the sum of two measures is the union of the supports. | true |
Batteries.DList.singleton_eq_ofThunk | Batteries.Data.DList.Lemmas | ∀ {α : Type u_1} {a : α}, Batteries.DList.singleton a = Batteries.DList.ofThunk { fn := fun x => [a] } | null | true |
OrthonormalBasis.sum_sq_norm_inner_left | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] (b : OrthonormalBasis ι 𝕜 E) (x : E),
∑ i, ‖inner 𝕜 x (b i)‖ ^ 2 = ‖x‖ ^ 2 | null | true |
_private.Mathlib.Data.Set.Prod.0.Set.union_pi_inter._proof_1_1 | Mathlib.Data.Set.Prod | ∀ {ι : Type u_1} {α : ι → Type u_2} {s₁ s₂ : Set ι} {t₁ t₂ : (i : ι) → Set (α i)},
(∀ i ∉ s₁, t₁ i = Set.univ) → (∀ i ∉ s₂, t₂ i = Set.univ) → ((s₁ ∪ s₂).pi fun i => t₁ i ∩ t₂ i) = s₁.pi t₁ ∩ s₂.pi t₂ | null | false |
Module.Basis.ext_elem_iff | Mathlib.LinearAlgebra.Basis.Defs | ∀ {ι : Type u_7} {R : Type u_8} {M : Type u_9} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(b : Module.Basis ι R M) {x y : M}, x = y ↔ ∀ (i : ι), (b.repr x) i = (b.repr y) i | Two elements are equal iff their coordinates are equal. | true |
Tactic.ComputeAsymptotics.BasisExtension.getBasis._sunfold | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basis | {basis : Tactic.ComputeAsymptotics.Basis} →
Tactic.ComputeAsymptotics.BasisExtension basis → Tactic.ComputeAsymptotics.Basis | null | false |
Filter.frequently_and_distrib_left._simp_1 | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {f : Filter α} {p : Prop} {q : α → Prop}, (∃ᶠ (x : α) in f, p ∧ q x) = (p ∧ ∃ᶠ (x : α) in f, q x) | null | false |
Mathlib.Tactic.Order.findContradictionWithNle | Mathlib.Tactic.Order | Mathlib.Tactic.Order.Graph → Array Mathlib.Tactic.Order.AtomicFact → Mathlib.Tactic.AtomM (Option Lean.Expr) | Using the `≤`-graph `g`, find a contradiction with some `≰`-fact. | true |
Stream'.Seq.length_take_of_le_length | Mathlib.Data.Seq.Basic | ∀ {α : Type u} {s : Stream'.Seq α} {n : ℕ}, (∀ (h : s.Terminates), n ≤ s.length h) → (Stream'.Seq.take n s).length = n | null | true |
_private.Mathlib.Topology.ContinuousMap.Bounded.Normed.0.BoundedContinuousFunction.norm_add_eq_max._simp_1_2 | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [NoZeroDivisors M₀] {a b : M₀}, (a * b = 0) = (a = 0 ∨ b = 0) | null | false |
Trans.trans | Init.Prelude | {α : Sort u_1} →
{β : Sort u_2} →
{γ : Sort u_3} →
{r : α → β → Sort u} →
{s : β → γ → Sort v} →
{t : outParam (α → γ → Sort w)} → [self : Trans r s t] → {a : α} → {b : β} → {c : γ} → r a b → s b c → t a c | Compose two proofs by transitivity, generalized over the relations involved. | true |
SkewMonoidAlgebra.instDistribMulAction._proof_1 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} {S : Type u_3} [inst : Monoid S] [inst_1 : AddMonoid k] [inst_2 : DistribMulAction S k]
(a : S) (b : SkewMonoidAlgebra k G), (a • b).coeff = a • b.coeff | null | false |
ONote.NFBelow.brecOn | Mathlib.SetTheory.Ordinal.Notation | ∀ {motive : (a : ONote) → (a_1 : Ordinal.{0}) → a.NFBelow a_1 → Prop} {a : ONote} {a_1 : Ordinal.{0}}
(t : a.NFBelow a_1),
(∀ (a : ONote) (a_2 : Ordinal.{0}) (t : a.NFBelow a_2), ONote.NFBelow.below t → motive a a_2 t) → motive a a_1 t | null | true |
HasFDerivWithinAt.add_const | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{f' : E →L[𝕜] F} {x : E} {s : Set E} (c : F), HasFDerivWithinAt f f' s x → HasFDerivWithinAt (fun x... | **Alias** of the reverse direction of `hasFDerivWithinAt_add_const_iff`. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.