name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
IsLowerSet.isOpen | Mathlib.Topology.Order.Basic | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [WellFoundedLT α] {s : Set α},
IsLowerSet s → IsOpen s | null | true |
_private.Mathlib.Tactic.HigherOrder.0.Mathlib.Tactic.higherOrderGetParam._sparseCasesOn_4 | Mathlib.Tactic.HigherOrder | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
WeakBilin.instAddCommMonoid._proof_10 | Mathlib.Topology.Algebra.Module.Spaces.WeakBilin | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : CommSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : Module 𝕜 E]
[inst_3 : AddCommMonoid F] [inst_4 : Module 𝕜 F] (B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜) (a b : WeakBilin B), a + b = b + a | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Subgraph.0.SimpleGraph.Subgraph.subgraphOfAdj_eq_induce._simp_1_4 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {α : Type u_1} {a b : α}, (a ∈ {b}) = (a = b) | null | false |
ProbabilityTheory.Kernel.ae_comp_of_ae_ae | Mathlib.Probability.Kernel.Composition.Comp | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} {κ : ProbabilityTheory.Kernel α β} {η : ProbabilityTheory.Kernel β γ} {a : α} {p : γ → Prop},
MeasurableSet {z | p z} → (∀ᵐ (y : β) ∂κ a, ∀ᵐ (z : γ) ∂η y, p z) → ∀ᵐ (z : γ) ∂(η.comp κ) a, p z | null | true |
_private.Mathlib.MeasureTheory.Integral.Bochner.Basic.0.Mathlib.Meta.Positivity.evalIntegral.match_1 | Mathlib.MeasureTheory.Integral.Bochner.Basic | (motive :
(u : Lean.Level) →
{α : Q(Type u)} →
(zα : Q(Zero «$α»)) →
Option Q(PartialOrder «$α») →
(e : Q(«$α»)) →
(pα : Q(PartialOrder «$α»)) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness zα e (some pα)) →
Lean.MetaM (Mathlib.Me... | null | false |
Filter.mem_zero | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Zero α] {s : Set α}, s ∈ 0 ↔ 0 ∈ s | null | true |
Std.DTreeMap.Internal.Impl.Const.get?_union_of_contains_eq_false_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
(h₁ : m₁.WF) (h₂ : m₂.WF) {k : α},
Std.DTreeMap.Internal.Impl.contains k m₁ = false →
Std.DTreeMap.Internal.Impl.Const.get? (m₁.union m₂ ⋯ ⋯) k = Std.DTreeMap.Internal.Impl.Const.get? m₂ k | null | true |
CategoryTheory.AddMon.Hom.mk | Mathlib.CategoryTheory.Monoidal.Mon | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{M N : CategoryTheory.AddMon C} → (hom : M.X ⟶ N.X) → [isAddMonHom_hom : CategoryTheory.IsAddMonHom hom] → M.Hom N | null | true |
LieRinehartAlgebra.Hom.comp._proof_1 | Mathlib.Algebra.LieRinehartAlgebra.Defs | ∀ {R : Type u_3} {A₁ : Type u_7} {L₁ : Type u_2} {A₂ : Type u_5} {L₂ : Type u_4} {A₃ : Type u_6} {L₃ : Type u_1}
[inst : CommRing R] [inst_1 : CommRing A₁] [inst_2 : LieRing L₁] [inst_3 : Module A₁ L₁]
[inst_4 : LieRingModule L₁ A₁] [inst_5 : CommRing A₂] [inst_6 : LieRing L₂] [inst_7 : Module A₂ L₂]
[inst_8 : Li... | null | false |
CategoryTheory.GrothendieckTopology.sheafify.eq_1 | Mathlib.CategoryTheory.Sites.CompatibleSheafification | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type w}
[inst_1 : CategoryTheory.Category.{w', w} D]
[inst_2 :
∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)]
[inst_3 : ∀ (X : C), Categ... | null | true |
Inclusion.HypothesisM.Context.mk | Mathlib.Tactic.Inclusion.Core.Types | Inclusion.InclusionM.Context → Lean.ExprMap Inclusion.IVar → Array Inclusion.IVar → Inclusion.HypothesisM.Context | null | true |
multipliable_of_exists_eq_zero | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CommMonoidWithZero α] [inst_1 : TopologicalSpace α] {f : β → α}
{L : SummationFilter β}, (∃ b, f b = 0) → ∀ [L.LeAtTop], Multipliable f L | null | true |
_private.Init.Data.String.Lemmas.FindPos.0.String.Slice.posGE_le_iff._simp_1_3 | Init.Data.String.Lemmas.FindPos | ∀ {s : String.Slice} {l r : s.Pos}, (l ≤ r) = (l.offset ≤ r.offset) | null | false |
CharTwo.add_cancel_right | Mathlib.Algebra.CharP.Two | ∀ {R : Type u_1} [inst : NonAssocSemiring R] [CharP R 2] (a b : R), a + b + b = a | null | true |
Mathlib.Tactic.Contrapose.contrapose.negate_iff | Mathlib.Tactic.Contrapose | Lean.Option Bool | An option to turn off the feature that `contrapose` negates both sides of `↔` goals.
This may be useful for teaching. | true |
_private.Mathlib.GroupTheory.Coxeter.Basic.0.CoxeterSystem.getElem_alternatingWord._proof_1_5 | Mathlib.GroupTheory.Coxeter.Basic | ∀ {B : Type u_1} (i j : B) (n k : ℕ), k ≤ n → ¬k = 0 → k - 1 < (CoxeterSystem.alternatingWord i j n).length | null | false |
_private.Mathlib.Algebra.QuadraticAlgebra.AlgHom.0.QuadraticAlgebra.norm_algHom_omega._simp_1_1 | Mathlib.Algebra.QuadraticAlgebra.AlgHom | ∀ {R : Type u} {A : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (r : R),
r • 1 = (algebraMap R A) r | null | false |
convex_halfSpace_le | Mathlib.Analysis.Convex.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_4} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E] [inst_4 : AddCommMonoid β] [inst_5 : PartialOrder β] [IsOrderedAddMonoid β]
[inst_7 : Module 𝕜 β] [PosSMulMono 𝕜 β] {f : E → β}, IsLinearMap 𝕜 f → ∀ (r : β), Convex 𝕜... | null | true |
Sym2.sortEquiv_apply_coe | Mathlib.Order.Sym2 | ∀ {α : Type u_1} [inst : LinearOrder α] (s : Sym2 α), ↑(Sym2.sortEquiv s) = (s.inf, s.sup) | null | true |
CategoryTheory.Limits.ProductsFromFiniteCofiltered.finiteSubproductsCone._proof_1 | Mathlib.CategoryTheory.Limits.Constructions.Filtered | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {α : Type u_1}
[CategoryTheory.Limits.HasFiniteProducts C] (f : α → C) (S : (Finset (CategoryTheory.Discrete α))ᵒᵖ),
CategoryTheory.Limits.HasLimit (CategoryTheory.Discrete.functor fun x => (CategoryTheory.Discrete.functor f).obj ↑x) | null | false |
Antisymmetrization.induction_on | Mathlib.Order.Antisymmetrization | ∀ {α : Type u_1} (r : α → α → Prop) [inst : IsPreorder α r] {p : Antisymmetrization α r → Prop}
(a : Antisymmetrization α r), (∀ (a : α), p (toAntisymmetrization r a)) → p a | null | true |
Std.Tactic.BVDecide.BVUnOp.ctorElimType | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {motive : Std.Tactic.BVDecide.BVUnOp → Sort u} → ℕ → Sort (max 1 u) | null | false |
_private.Mathlib.CategoryTheory.Sites.Coherent.Comparison.0.CategoryTheory.extensive_regular_generate_coherent.match_1_4 | Mathlib.CategoryTheory.Sites.Coherent.Comparison | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.FinitaryPreExtensive C] (Y : C)
(T : CategoryTheory.Presieve Y) (motive : T ∈ (CategoryTheory.extensiveCoverage C).coverings Y → Prop)
(x : T ∈ (CategoryTheory.extensiveCoverage C).coverings Y),
(∀ (α : Type) (x : Finite α) (X... | null | false |
_private.Mathlib.Testing.Plausible.Functions.0.Plausible.TotalFunction.zeroDefault.match_1.splitter | Mathlib.Testing.Plausible.Functions | {α : Type u_1} →
{β : Type u_2} →
(motive : Plausible.TotalFunction α β → Sort u_3) →
(x : Plausible.TotalFunction α β) →
((A : List ((_ : α) × β)) → (a : β) → motive (Plausible.TotalFunction.withDefault A a)) → motive x | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.0.Nat.reduceBEq._regBuiltin.Nat.reduceBEq.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.30194753._hygCtx._hyg.29 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | IO Unit | null | false |
Std.DTreeMap.Const.mergeWith._proof_1 | Std.Data.DTreeMap.Basic | ∀ {α : Type u_1} {cmp : α → α → Ordering} {β : Type u_2} (mergeFn : α → β → β → β)
(t₁ t₂ : Std.DTreeMap α (fun x => β) cmp),
(Std.DTreeMap.Internal.Impl.Const.mergeWith mergeFn t₁.inner t₂.inner ⋯).impl.WF | null | false |
NormedSpace.exp_op | Mathlib.Analysis.Normed.Algebra.Exponential | ∀ {𝔸 : Type u_2} [inst : Ring 𝔸] [inst_1 : TopologicalSpace 𝔸] [inst_2 : IsTopologicalRing 𝔸] [T2Space 𝔸] (x : 𝔸),
NormedSpace.exp (MulOpposite.op x) = MulOpposite.op (NormedSpace.exp x) | null | true |
Module.Basis.linearMap | Mathlib.LinearAlgebra.Matrix.ToLin | {R : Type u_1} →
{M₁ : Type u_3} →
{M₂ : Type u_4} →
{ι₁ : Type u_6} →
{ι₂ : Type u_7} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M₁] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : Module R M₁] →
[inst_4 : Module R M₂] →
... | The standard basis of the space linear maps between two modules
induced by a basis of the domain and codomain.
If `M₁` and `M₂` are modules with basis `b₁` and `b₂` respectively indexed
by finite types `ι₁` and `ι₂`,
then `Basis.linearMap b₁ b₂` is the basis of `M₁ →ₗ[R] M₂` indexed by `ι₂ × ι₁`
where `(i, j)` indexes... | true |
Topology.IsLower.tendsto_nhds_iff_not_le | Mathlib.Topology.Order.LowerUpperTopology | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : TopologicalSpace α] [Topology.IsLower α] {β : Type u_3} {f : β → α}
{l : Filter β} {x : α}, Filter.Tendsto f l (nhds x) ↔ ∀ (y : α), ¬y ≤ x → ∀ᶠ (z : β) in l, ¬y ≤ f z | null | true |
_private.Mathlib.Algebra.Order.Round.0.round_eq_div._simp_1_3 | Mathlib.Algebra.Order.Round | ∀ {α : Type u} [inst : NonAssocSemiring α] (n : α), n + n = 2 * n | null | false |
ContinuousAlternatingMap.instContinuousEval | Mathlib.Analysis.Normed.Module.Alternating.Basic | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : Type u_3} {F : Type u_4} [inst : NormedField 𝕜] [Finite ι]
[inst_2 : SeminormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] [inst_4 : TopologicalSpace F] [inst_5 : AddCommGroup F]
[inst_6 : IsTopologicalAddGroup F] [inst_7 : Module 𝕜 F], ContinuousEval (E [⋀^ι]→L[𝕜] F) (ι → E... | Applying a continuous alternating map to a vector is continuous
in the pair (map, vector).
Continuity in the vector holds by definition
and continuity in the map holds if both the domain and the codomain are topological vector spaces.
However, continuity in the pair (map, vector) needs the domain to be a locally bound... | true |
_private.Mathlib.GroupTheory.Nilpotent.0.Group.nilpotencyClass_pi._simp_1_2 | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : Group G] [hG : Group.IsNilpotent G] {n : ℕ},
(Group.nilpotencyClass G ≤ n) = (⊤.lowerCentralSeries n = ⊥) | null | false |
MeasureTheory.setIntegral_abs_condExp_le | Mathlib.MeasureTheory.Function.ConditionalExpectation.Real | ∀ {α : Type u_1} {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {E : Type u_2} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [CompleteSpace E] [inst_3 : Lattice E] [HasSolidNorm E] [IsOrderedAddMonoid E]
[IsOrderedModule ℝ E] {s : Set α},
MeasurableSet s → ∀ (f : α → E), ∫ (x : α) in s, |μ[f ... | null | true |
Lean.Elab.Do.map1TermElabM | Lean.Elab.Do.Basic | {β : Sort u_1} →
({α : Type} → (β → Lean.Elab.TermElabM α) → Lean.Elab.TermElabM α) →
{α : Type} → (β → Lean.Elab.Do.DoElabM α) → Lean.Elab.Do.DoElabM α | null | true |
CompactT2.Projective | Mathlib.Topology.ExtremallyDisconnected | (X : Type u) → [TopologicalSpace X] → Prop | The assertion `CompactT2.Projective` states that given continuous maps
`f : X → Z` and `g : Y → Z` with `g` surjective between `t_2`, compact topological spaces,
there exists a continuous lift `h : X → Y`, such that `f = g ∘ h`. | true |
Pi.zero_mono | Mathlib.Algebra.Group.Pi.Lemmas | ∀ {α : Type u_5} {β : Type u_6} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Zero β], Monotone 0 | null | true |
Lean.IR.LitVal.str.elim | Lean.Compiler.IR.Basic | {motive : Lean.IR.LitVal → Sort u} →
(t : Lean.IR.LitVal) → t.ctorIdx = 1 → ((v : String) → motive (Lean.IR.LitVal.str v)) → motive t | null | false |
LinearMap.tensorEqLocus_coe | Mathlib.RingTheory.Flat.Equalizer | ∀ {R : Type u_1} (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (M : Type u_3)
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M] {N : Type u_4}
{P : Type u_5} [inst_7 : AddCommGroup N] [inst_8 : AddCommGroup P] [inst_9 : Module R N]... | null | true |
CategoryTheory.Factorisation.casesOn | Mathlib.CategoryTheory.Category.Factorisation | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f : X ⟶ Y} →
{motive : CategoryTheory.Factorisation f → Sort u_1} →
(t : CategoryTheory.Factorisation f) →
((mid : C) →
(ι : X ⟶ mid) →
(π : mid ⟶ Y) →
... | null | false |
Subgroup.inv_mem | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) {x : G}, x ∈ H → x⁻¹ ∈ H | A subgroup is closed under inverse. | true |
RingQuot.mkRingHom_def | Mathlib.Algebra.RingQuot | ∀ {R : Type u_1} [inst : Semiring R] (r : R → R → Prop),
RingQuot.mkRingHom r =
{ toFun := fun x => { toQuot := Quot.mk (RingQuot.Rel r) x }, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
map_add' := ⋯ } | null | true |
Std.IterM.step_intermediateDropWhile._proof_4 | Std.Data.Iterators.Lemmas.Combinators.Monadic.DropWhile | ∀ {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Monad m] {P : β → Bool} (out : β),
P out = false → ((pure ∘ ULift.up ∘ P) out).Property { down := false } | null | false |
Multiplicative.ofAdd.eq_1 | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {α : Type u}, Multiplicative.ofAdd = { toFun := fun x => x, invFun := fun x => x, left_inv := ⋯, right_inv := ⋯ } | null | true |
Lean.Grind.Nat.lo_lo | Init.Grind.Offset | ∀ (u w v k₁ k₂ : ℕ), u + k₁ ≤ w → w + k₂ ≤ v → u + (k₁ + k₂) ≤ v | null | true |
Int.instLocallyFiniteOrder._proof_6 | Mathlib.Data.Int.Interval | ∀ (a b x : ℤ),
x ∈ Finset.map (Nat.castEmbedding.trans (addLeftEmbedding a)) (Finset.range (b + 1 - a).toNat) ↔ a ≤ x ∧ x ≤ b | null | false |
_private.Std.Http.Protocol.H1.Reader.0.Std.Http.Protocol.H1.Reader.instReprState.repr.match_1 | Std.Http.Protocol.H1.Reader | {dir : Std.Http.Protocol.H1.Direction} →
(motive : Std.Http.Protocol.H1.Reader.State dir → Sort u_1) →
(x : Std.Http.Protocol.H1.Reader.State dir) →
(Unit → motive Std.Http.Protocol.H1.Reader.State.needStartLine) →
((a : ℕ) → motive (Std.Http.Protocol.H1.Reader.State.needHeader a)) →
((a :... | null | false |
_private.Init.Data.String.Decode.0.String.toBitVec_getElem_utf8EncodeChar_zero_of_utf8Size_eq_two | Init.Data.String.Decode | ∀ {c : Char} (h : c.utf8Size = 2), (String.utf8EncodeChar c)[0].toBitVec = 6#3 ++ BitVec.extractLsb' 6 5 c.val.toBitVec | null | true |
List.Shortlex.of_length_lt | Mathlib.Data.List.Shortlex | ∀ {α : Type u_1} {r : α → α → Prop} {s t : List α}, s.length < t.length → List.Shortlex r s t | If a list `s` is shorter than a list `t`, then `s` is smaller than `t` under any shortlex
order. | true |
LinearEquiv.cast | Mathlib.Algebra.Module.Equiv.Defs | {R : Type u_1} →
[inst : Semiring R] →
{ι : Type u_14} →
{M : ι → Type u_15} →
[inst_1 : (i : ι) → AddCommMonoid (M i)] →
[inst_2 : (i : ι) → Module R (M i)] → {i j : ι} → i = j → M i ≃ₗ[R] M j | `Equiv.cast (congrArg _ h)` as a linear equiv.
Note that unlike `Equiv.cast`, this takes an equality of indices rather than an equality of types,
to avoid having to deal with an equality of the algebraic structure itself. | true |
_private.Lean.Structure.0.Lean.findParentProjStruct?.go._unsafe_rec | Lean.Structure | Lean.Environment → Lean.Name → Lean.Name → StateM Lean.NameSet (Option Lean.Name) | null | false |
Filter.map_mapsTo_Iic_iff_tendsto | Mathlib.Order.Filter.Tendsto | ∀ {α : Type u_1} {β : Type u_2} {F : Filter α} {G : Filter β} {m : α → β},
Set.MapsTo (Filter.map m) (Set.Iic F) (Set.Iic G) ↔ Filter.Tendsto m F G | null | true |
Lean.Lsp.ResolvableCompletionItemData.mk._flat_ctor | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.DocumentUri →
Lean.Lsp.Position → Option ℕ → Option Lean.Lsp.CompletionIdentifier → Lean.Lsp.ResolvableCompletionItemData | null | false |
_private.Mathlib.AlgebraicGeometry.Morphisms.ClosedImmersion.0.AlgebraicGeometry.isDominant_of_of_appTop_injective._simp_1_1 | Mathlib.AlgebraicGeometry.Morphisms.ClosedImmersion | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Ring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
[rc : RingHomClass F R S] (f : F), (RingHom.ker f = ⊥) = Function.Injective ⇑f | null | false |
smoothSheafCommGroup.eq_1 | Mathlib.Geometry.Manifold.Sheaf.Smooth | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {EM : Type u_2} [inst_1 : NormedAddCommGroup EM]
[inst_2 : NormedSpace 𝕜 EM] {HM : Type u_3} [inst_3 : TopologicalSpace HM] (IM : ModelWithCorners 𝕜 EM HM)
{E : Type u_4} [inst_4 : NormedAddCommGroup E] [inst_5 : NormedSpace 𝕜 E] {H : Type u_5} [inst_6 : Topo... | null | true |
_private.Mathlib.RingTheory.Radical.NatInt.0.Nat.one_lt_radical_iff.match_1_1 | Mathlib.RingTheory.Radical.NatInt | ∀ {n : ℕ} (motive : (∃ x ∈ n.primeFactors, 1 < x) → Prop) (x : ∃ x ∈ n.primeFactors, 1 < x),
(∀ (p : ℕ) (h : p ∈ n.primeFactors ∧ 1 < p), motive ⋯) → motive x | null | false |
AddMonoidHom.ofLeftInverse_symm_apply | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_4} [inst_1 : AddGroup N] {f : G →+ N} {g : N →+ G}
(h : Function.LeftInverse ⇑g ⇑f) (x : ↥f.range), (AddMonoidHom.ofLeftInverse h).symm x = g ↑x | null | true |
Positive.addSemigroup | Mathlib.Algebra.Order.Positive.Ring | {M : Type u_1} → [inst : AddMonoid M] → [inst_1 : Preorder M] → [AddLeftStrictMono M] → AddSemigroup { x // 0 < x } | null | true |
CategoryTheory.Functor.PreservesEffectiveEpiFamilies.casesOn | 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} →
(t : F.PreservesEffectiveEpiFamilies) →
(... | null | false |
AddMonoidAlgebra.mapDomainBialgHom.eq_1 | Mathlib.RingTheory.Bialgebra.MonoidAlgebra | ∀ (R : Type u_1) {M : Type u_8} {N : Type u_9} [inst : CommSemiring R] [inst_1 : AddMonoid M] [inst_2 : AddMonoid N]
(f : M →+ N), AddMonoidAlgebra.mapDomainBialgHom R f = BialgHom.ofAlgHom (AddMonoidAlgebra.mapDomainAlgHom R R f) ⋯ ⋯ | null | true |
EuclideanGeometry.oangle_eq_zero_iff_oangle_rev_eq_zero | Mathlib.Geometry.Euclidean.Angle.Oriented.Affine | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
{p₁ p₂ p₃ : P}, EuclideanGeometry.oangle p₁ p₂ p₃ = 0 ↔ EuclideanGeometry.oangle p₃ p₂ p... | An oriented angle is zero if and only if the angle with the order of the points reversed is
zero. | true |
CategoryTheory.Sieve.overEquiv_functorPullback_map | Mathlib.CategoryTheory.Sites.Over | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) (U : CategoryTheory.Over X)
(S : CategoryTheory.Sieve ((CategoryTheory.Over.map f).obj U)),
(CategoryTheory.Sieve.overEquiv U) (CategoryTheory.Sieve.functorPullback (CategoryTheory.Over.map f) S) =
(CategoryTheory.Sieve.overEquiv ((C... | null | true |
Cardinal.powerlt_le | Mathlib.SetTheory.Cardinal.Basic | ∀ {a b c : Cardinal.{u}}, a ^< b ≤ c ↔ ∀ x < b, a ^ x ≤ c | null | true |
NonUnitalSubring.neg_mem | Mathlib.RingTheory.NonUnitalSubring.Defs | ∀ {R : Type u} [inst : NonUnitalNonAssocRing R] (s : NonUnitalSubring R) {x : R}, x ∈ s → -x ∈ s | A non-unital subring is closed under negation. | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.getElem?_toList_ric._simp_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m < n.succ) = (m ≤ n) | null | false |
Lean.Grind.AC.SubsetResult.rec | Lean.Meta.Tactic.Grind.AC.Seq | {motive : Lean.Grind.AC.SubsetResult → Sort u} →
motive Lean.Grind.AC.SubsetResult.false →
motive Lean.Grind.AC.SubsetResult.exact →
((s : Lean.Grind.AC.Seq) → motive (Lean.Grind.AC.SubsetResult.strict s)) →
(t : Lean.Grind.AC.SubsetResult) → motive t | null | false |
_private.Mathlib.RingTheory.Etale.QuasiFinite.0.Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq_aux._proof_1_3 | Mathlib.RingTheory.Etale.QuasiFinite | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R)
[inst_3 : p.IsPrime] (q : Ideal S) [inst_4 : q.IsPrime] [inst_5 : q.LiesOver p] (R' : Type u_1) (w : CommRing R')
(w_1 : Algebra R R') (P : Ideal R') (w_2 : P.IsPrime) (w_3 : P.LiesOver p)
(hP : Function... | null | false |
_private.Lean.Linter.UnusedVariables.0.Lean.Linter.UnusedVariables.visitAssignments.visitExpr | Lean.Linter.UnusedVariables | IO.Ref (Std.HashSet USize) → IO.Ref (Std.HashSet Lean.FVarId) → Lean.Expr → Lean.MonadCacheT Lean.Expr Unit IO Unit | Visit an `Expr`, collecting all fvars in it into `fvarUses` | true |
Lean.Elab.Term.withSynthesize | Lean.Elab.SyntheticMVars | {m : Type → Type u_1} →
{α : Type} →
[MonadFunctorT Lean.Elab.TermElabM m] →
m α → optParam Lean.Elab.Term.PostponeBehavior Lean.Elab.Term.PostponeBehavior.no → m α | Execute `k`, and synthesize pending synthetic metavariables created while executing `k` are solved.
If `mayPostpone == false`, then all of them must be synthesized.
Remark: even if `mayPostpone == true`, the method still uses `synthesizeUsingDefault` | true |
Lean.PersistentArrayNode.node.elim | Lean.Data.PersistentArray | {α : Type u} →
{motive_1 : Lean.PersistentArrayNode α → Sort u_1} →
(t : Lean.PersistentArrayNode α) →
t.ctorIdx = 0 →
((cs : Array (Lean.PersistentArrayNode α)) → motive_1 (Lean.PersistentArrayNode.node cs)) → motive_1 t | null | false |
ContinuousWithinAt.eval_const | Mathlib.Topology.Hom.ContinuousEvalConst | ∀ {F : Type u_1} {α : Type u_2} {X : Type u_3} {Z : Type u_4} [inst : FunLike F α X] [inst_1 : TopologicalSpace F]
[inst_2 : TopologicalSpace X] [ContinuousEvalConst F α X] [inst_4 : TopologicalSpace Z] {f : Z → F} {s : Set Z}
{z : Z}, ContinuousWithinAt f s z → ∀ (x : α), ContinuousWithinAt (fun x_1 => (f x_1) x) ... | null | true |
Setoid.eq_iff_rel_eq | Mathlib.Order.Setoid.Basic | ∀ {α : Type u_1} {r₁ r₂ : Setoid α}, r₁ = r₂ ↔ ⇑r₁ = ⇑r₂ | Two equivalence relations are equal iff their underlying binary operations are equal. | true |
FreeGroup.Red.Step.lift | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L₁ L₂ : List (α × Bool)} {β : Type v} [inst : Group β] {f : α → β},
FreeGroup.Red.Step L₁ L₂ → FreeGroup.Lift.aux f L₁ = FreeGroup.Lift.aux f L₂ | null | true |
enorm_algebraMap | Mathlib.Analysis.Normed.Module.Basic | ∀ {𝕜 : Type u_1} (𝕜' : Type u_2) [inst : NormedField 𝕜] [inst_1 : SeminormedRing 𝕜'] [inst_2 : NormedAlgebra 𝕜 𝕜']
(x : 𝕜), ‖(algebraMap 𝕜 𝕜') x‖ₑ = ‖x‖ₑ * ‖1‖ₑ | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0.UInt16.reduceOfNatLT._regBuiltin.UInt16.reduceOfNatLT.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.3273093604._hygCtx._hyg.348 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | null | false |
Function.Injective.mem_range_iff_existsUnique | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Function.Injective f → ∀ {b : β}, b ∈ Set.range f ↔ ∃! a, f a = b | null | true |
pow_le_pow | Mathlib.Algebra.Order.Monoid.Unbundled.Pow | ∀ {M : Type u_3} [inst : Monoid M] [inst_1 : Preorder M] [MulLeftMono M] [MulRightMono M] {a b : M},
a ≤ b → 1 ≤ b → ∀ {m n : ℕ}, m ≤ n → a ^ m ≤ b ^ n | null | true |
Std.TreeSet.isSome_max?_eq_not_isEmpty | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp], t.max?.isSome = !t.isEmpty | null | true |
CategoryTheory.LocalizerMorphism.LeftResolution.comp_f_assoc | Mathlib.CategoryTheory.Localization.Resolution | ∀ {C₁ : Type u_1} {C₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} {Φ : CategoryTheory.LocalizerMorphism W₁ W₂} {X₂ : C₂}
{L L' L'' : Φ.LeftResolution X₂} (φ : L ⟶ L')... | null | true |
Function.locallyFinsuppWithin.restrictMonoidHom._proof_2 | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [inst_1 : AddCommGroup Y] {V : Set X}
(h : V ⊆ U), Function.locallyFinsuppWithin.restrict 0 h = 0 | null | false |
LinearEquiv.algEquivOfRing._proof_1 | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Algebra R A] (e : R ≃ₗ[R] A)
(x : R), e.symm (e 1 * (algebraMap R A) x) = e.symm (x • e 1) | null | false |
mdifferentiableAt_prod_module_iff | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : 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_17} [inst_6 : NormedAddCom... | null | true |
Associates.mk_surjective | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : Monoid M], Function.Surjective Associates.mk | null | true |
List.sbtw_iff_triplewise_and_ne_pair | Mathlib.Analysis.Convex.BetweenList | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] [IsOrderedRing R] {l : List P},
List.Sbtw R l ↔ List.Triplewise (Sbtw R) l ∧ ∀ (a : P), l ≠ [a, a] | null | true |
AddActionHom.End.instAddMonoidId._proof_5 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_1} {X : Type u_2} [inst : VAdd M X] (x : X →ₑ[id] X), 0 + x = 0 + x | null | false |
MeasureTheory.JordanDecomposition.exists_compl_positive_negative | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | ∀ {α : Type u_1} [inst : MeasurableSpace α] (j : MeasureTheory.JordanDecomposition α),
∃ S,
MeasurableSet S ∧
MeasureTheory.VectorMeasure.restrict j.toSignedMeasure S ≤ MeasureTheory.VectorMeasure.restrict 0 S ∧
MeasureTheory.VectorMeasure.restrict 0 Sᶜ ≤ MeasureTheory.VectorMeasure.restrict j.toSig... | A Jordan decomposition provides a Hahn decomposition. | true |
alexDiscEquivPreord_inverse_map | Mathlib.Topology.Order.Category.AlexDisc | ∀ {X Y : Preord} (f : X ⟶ Y),
alexDiscEquivPreord.inverse.map f =
CategoryTheory.ConcreteCategory.ofHom (Topology.WithUpperSet.map (Preord.Hom.hom f)) | null | true |
TopologicalSpace.isSeparable_iUnion._simp_1 | Mathlib.Topology.Bases | ∀ {α : Type u} [t : TopologicalSpace α] {ι : Sort u_2} [Countable ι] {s : ι → Set α},
TopologicalSpace.IsSeparable (⋃ i, s i) = ∀ (i : ι), TopologicalSpace.IsSeparable (s i) | null | false |
CategoryTheory.Over.postAdjunctionLeft_counit_app_left | Mathlib.CategoryTheory.Comma.Over.Pullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.Limits.HasPullbacks C] {X : C} {F : CategoryTheory.Functor C D}
{G : CategoryTheory.Functor D C} (a : F ⊣ G)
(X_1 : CategoryTheory.Over ((CategoryTheory.Functor.id D).obj (... | null | true |
List.Pairwise.destutter_eq_dedup | Mathlib.Data.List.Destutter | ∀ {α : Type u_1} [inst : DecidableEq α] {r : α → α → Prop} [Std.Antisymm r] {l : List α},
List.Pairwise r l → List.destutter (fun x1 x2 => x1 ≠ x2) l = l.dedup | If the elements of a list `l` are related pairwise by an antisymmetric relation `r`, then
destuttering `l` by disequality produces the same result as deduplicating `l`.
This is most useful when `r` is a strict or weak ordering.
| true |
LinearIsometryEquiv.norm_iteratedFDeriv_comp_left | Mathlib.Analysis.Calculus.ContDiff.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] (g : F ≃ₗᵢ[𝕜] G) (f : E → F) (x : E)... | Composition with a linear isometry equiv on the left preserves the norm of the iterated
derivative. | true |
CategoryTheory.Abelian.Ext.comp_zero | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y : C} {n : ℕ} (α : CategoryTheory.Abelian.Ext X Y n) (Z : C) (m p : ℕ)
(h : n + m = p), α.comp 0 h = 0 | null | true |
ProbabilityTheory.measurePreserving_restrict₂_multivariateGaussian | Mathlib.Probability.Distributions.Gaussian.Multivariate | ∀ {ι : Type u_2} [inst : DecidableEq ι] {I J : Finset ι} {μ : EuclideanSpace ℝ ↥I} {S : Matrix ↥I ↥I ℝ},
S.PosSemidef →
∀ (hJI : J ⊆ I),
MeasureTheory.MeasurePreserving (⇑(EuclideanSpace.restrict₂ hJI)) (ProbabilityTheory.multivariateGaussian μ S)
(ProbabilityTheory.multivariateGaussian ((EuclideanS... | If one restricts a multivariate Gaussian measure indexed by a finite set `I` to
coordinates indexed by `J ⊆ I`, one obtains the multivariate Gaussian measure whose
covariance matrix is given by the corresponding submatrix. | true |
Order.IsPredPrelimit.eq_1 | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} [inst : LT α] (a : α), Order.IsPredPrelimit a = ∀ (b : α), ¬a ⋖ b | null | true |
NormedSpace.invertibleExpOfMemBall | Mathlib.Analysis.Normed.Algebra.Exponential | {𝕂 : Type u_1} →
{𝔸 : Type u_2} →
[inst : NontriviallyNormedField 𝕂] →
[inst_1 : NormedRing 𝔸] →
[inst_2 : NormedAlgebra 𝕂 𝔸] →
[CompleteSpace 𝔸] →
[CharZero 𝕂] →
{x : 𝔸} → x ∈ Metric.eball 0 (NormedSpace.expSeries 𝕂 𝔸).radius → Invertible (NormedSpace.... | `NormedSpace.exp x` has explicit two-sided inverse `NormedSpace.exp (-x)`. | true |
HurwitzZeta.evenKernel._proof_1 | Mathlib.NumberTheory.LSeries.HurwitzZetaEven | ∀ (x : ℝ),
Function.Periodic
(fun ξ => Real.exp (-Real.pi * ξ ^ 2 * x) * (jacobiTheta₂ (↑ξ * Complex.I * ↑x) (Complex.I * ↑x)).re) 1 | null | false |
CategoryTheory.MorphismProperty.RightFraction.ofHom_f | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (W : CategoryTheory.MorphismProperty C) {X Y : C}
(f : X ⟶ Y) [inst_1 : W.ContainsIdentities], (CategoryTheory.MorphismProperty.RightFraction.ofHom W f).f = f | null | true |
AlgebraicGeometry.ext_of_isDominant | Mathlib.AlgebraicGeometry.Morphisms.Separated | ∀ {W X Y : AlgebraicGeometry.Scheme} [AlgebraicGeometry.IsReduced X] {f g : X ⟶ Y} [Y.IsSeparated] (ι : W ⟶ X)
[AlgebraicGeometry.IsDominant ι],
CategoryTheory.CategoryStruct.comp ι f = CategoryTheory.CategoryStruct.comp ι g → f = g | Suppose `f g : X ⟶ Y` where `X` is a reduced scheme and `Y` is a separated scheme.
Then `f = g` if `ι ≫ f = ι ≫ g` for some dominant `ι`.
Also see `ext_of_isDominant_of_isSeparated` for the general version over arbitrary bases.
| true |
_private.Mathlib.Analysis.CStarAlgebra.Extreme.0.isStarProjection_iff_mem_extremePoints_setOfPred_nonneg_inter_unitClosedBall._simp_1_4 | Mathlib.Analysis.CStarAlgebra.Extreme | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
_private.Init.Data.String.Lemmas.Pattern.Find.Pred.0.String.Pos.find?_bool_eq_none_iff._simp_1_3 | Init.Data.String.Lemmas.Pattern.Find.Pred | ∀ {s : String} {p q : s.Pos}, (p.toSlice ≤ q.toSlice) = (p ≤ q) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.