name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
DividedPowers.ext | Mathlib.RingTheory.DividedPowers.Basic | ∀ {A : Type u_1} [inst : CommSemiring A] {I : Ideal A} (hI hI' : DividedPowers I),
(∀ (n : ℕ) {x : A}, x ∈ I → hI.dpow n x = hI'.dpow n x) → hI = hI' | null | true |
_private.Mathlib.Tactic.LinearCombination.0.Mathlib.Tactic.LinearCombination.expandLinearCombo.match_1 | Mathlib.Tactic.LinearCombination | (motive : Option (Mathlib.Ineq × Lean.Expr × Lean.Expr × Lean.Expr) → Sort u_1) →
(__do_lift : Option (Mathlib.Ineq × Lean.Expr × Lean.Expr × Lean.Expr)) →
((rel : Mathlib.Ineq) → (snd : Lean.Expr × Lean.Expr × Lean.Expr) → motive (some (rel, snd))) →
(Unit → motive none) → motive __do_lift | null | false |
IsScalarTower.toAlgHom | Mathlib.Algebra.Algebra.Hom | (R : Type u_1) →
(S : Type u_2) →
(A : Type u_3) →
[inst : CommSemiring R] →
[inst_1 : CommSemiring S] →
[inst_2 : Semiring A] →
[inst_3 : Algebra R S] → [inst_4 : Algebra S A] → [inst_5 : Algebra R A] → [IsScalarTower R S A] → S →ₐ[R] A | In a tower, the canonical map from the middle element to the top element is an
algebra homomorphism over the bottom element. | true |
Std.DHashMap.Const.beq_iff_equiv | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.DHashMap α fun x => β} [inst : BEq β]
[LawfulBEq α] [LawfulBEq β], Std.DHashMap.Const.beq m₁ m₂ = true ↔ m₁.Equiv m₂ | null | true |
Finsupp.degree_apply | Mathlib.Data.Finsupp.Weight | ∀ {σ : Type u_1} {R : Type u_4} [inst : AddCommMonoid R] (d : σ →₀ R), Finsupp.degree d = ∑ i ∈ d.support, d i | null | true |
_private.Mathlib.Data.Finset.Max.0.Finset.max_of_mem.match_1_1 | Mathlib.Data.Finset.Max | ∀ {α : Type u_1} [inst : LinearOrder α] {s : Finset α} {a : α} (motive : (∃ b, s.sup WithBot.some = ↑b ∧ a ≤ b) → Prop)
(x : ∃ b, s.sup WithBot.some = ↑b ∧ a ≤ b),
(∀ (b : α) (h : s.sup WithBot.some = ↑b) (right : a ≤ b), motive ⋯) → motive x | null | false |
instPredOrderShrink | Mathlib.Order.Shrink | {α : Type u_1} → [inst : Small.{u, u_1} α] → [inst_1 : Preorder α] → [PredOrder α] → PredOrder (Shrink.{u, u_1} α) | null | true |
_private.Lean.Meta.Sym.Simp.Have.0.Lean.Meta.Sym.Simp.SimpHaveResult.mk.inj | Lean.Meta.Sym.Simp.Have | ∀ {result : Lean.Meta.Sym.Simp.Result} {α : Lean.Expr} {u : Lean.Level} {result_1 : Lean.Meta.Sym.Simp.Result}
{α_1 : Lean.Expr} {u_1 : Lean.Level},
{ result := result, α := α, u := u } = { result := result_1, α := α_1, u := u_1 } →
result = result_1 ∧ α = α_1 ∧ u = u_1 | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0._regBuiltin.BitVec.reduceShiftLeft.declare_163._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.1981601135._hygCtx._hyg.14 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit | null | false |
exists_rat_of_not_irrational | Mathlib.NumberTheory.Real.Irrational | ∀ {x : ℝ}, ¬Irrational x → ∃ q, x = ↑q | null | true |
AlgebraicGeometry.pullbackRestrictIsoRestrict_hom_ι_assoc | Mathlib.AlgebraicGeometry.Restrict | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (U : Y.Opens) {Z : AlgebraicGeometry.Scheme} (h : X ⟶ Z),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.pullbackRestrictIsoRestrict f U).hom
(CategoryTheory.CategoryStruct.comp ((TopologicalSpace.Opens.map f.base).obj U).ι h) =
CategoryTheory.CategorySt... | null | true |
Lean.Meta.Grind.Arith.CommRing.Ring.intCastFn?._default | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Option Lean.Expr | null | false |
continuous_norm' | Mathlib.Analysis.Normed.Group.Continuity | ∀ {E : Type u_4} [inst : SeminormedGroup E], Continuous fun a => ‖a‖ | null | true |
MonoidHom.map_mul | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : MulOne M] [inst_1 : MulOne N] (f : M →* N) (a b : M), f (a * b) = f a * f b | If `f` is a monoid homomorphism then `f (a * b) = f a * f b`. | true |
Set.powersetCard.faithfulSMul | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ {G : Type u_1} [inst : Group G] {α : Type u_2} [inst_1 : MulAction G α] {n : ℕ} [inst_2 : DecidableEq α],
1 ≤ n → ↑n < ENat.card α → ∀ [FaithfulSMul G α], FaithfulSMul G ↑(Set.powersetCard α n) | If a group `G` acts faithfully on `α`, then
it acts faithfully on `powersetCard α n` provided `1 ≤ n < ENat.card α`. | true |
NonUnitalStarSubalgebra.instIsSemitopologicalSemiring | Mathlib.Topology.Algebra.NonUnitalStarAlgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : TopologicalSpace A] [inst_2 : Star A]
[inst_3 : NonUnitalSemiring A] [inst_4 : Module R A] [IsSemitopologicalSemiring A] (s : NonUnitalStarSubalgebra R A),
IsSemitopologicalSemiring ↥s | null | true |
_private.Mathlib.Algebra.QuadraticAlgebra.Defs.0.QuadraticAlgebra.instNonUnitalNonAssocSemiring._abel_5 | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {a b : R} [inst : NonUnitalNonAssocSemiring R] (x x_1 x_2 : QuadraticAlgebra R a b),
x.re * x_2.im + x_1.re * x_2.im + (x.im * x_2.re + x_1.im * x_2.re) + (b * x.im * x_2.im + b * x_1.im * x_2.im) =
x.re * x_2.im + x.im * x_2.re + b * x.im * x_2.im + (x_1.re * x_2.im + x_1.im * x_2.re + b * x_1.i... | null | false |
_private.Lean.Compiler.IR.Basic.0.Lean.IR.FnBody.alphaEqv._sparseCasesOn_4 | Lean.Compiler.IR.Basic | {motive_1 : Lean.IR.Alt → Sort u} →
(t : Lean.IR.Alt) →
((b : Lean.IR.FnBody) → motive_1 (Lean.IR.Alt.default b)) → (Nat.hasNotBit 2 t.ctorIdx → motive_1 t) → motive_1 t | null | false |
Mathlib.Tactic.LibrarySearch.«_aux_Mathlib_Tactic_Observe___macroRules_Mathlib_Tactic_LibrarySearch_tacticObserve?__:_Using__,,_1» | Mathlib.Tactic.Observe | Lean.Macro | null | false |
ProbabilityTheory.iIndepFun.indepFun_mul_right₀ | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_10}
{m : MeasurableSpace β} [inst : Mul β] [MeasurableMul₂ β] {f : ι → Ω → β},
ProbabilityTheory.iIndepFun f μ →
(∀ (i : ι), AEMeasurable (f i) μ) → ∀ (i j k : ι), i ≠ j → i ≠ k → ProbabilityTheory.IndepFun (f i)... | null | true |
Flag.casesOn | Mathlib.Order.Preorder.Chain | {α : Type u_4} →
[inst : LE α] →
{motive : Flag α → Sort u} →
(t : Flag α) →
((carrier : Set α) →
(Chain' : IsChain (fun x1 x2 => x1 ≤ x2) carrier) →
(max_chain' : ∀ ⦃s : Set α⦄, IsChain (fun x1 x2 => x1 ≤ x2) s → carrier ⊆ s → carrier = s) →
motive { carrie... | null | false |
_private.Mathlib.RingTheory.Polynomial.Basic.0.Polynomial.mem_degreeLE._simp_1_4 | Mathlib.RingTheory.Polynomial.Basic | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{f : M →ₛₗ[τ₁₂] M₂} {y : M}, (y ∈ f.ker) = (f y = 0) | null | false |
SchwartzMap.smulLeftCLM_smul | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {𝕜 : Type u_2} {E : Type u_5} {F : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NontriviallyNormedField 𝕜]
[inst_5 : NormedAlgebra ℝ 𝕜] [inst_6 : NormedSpace 𝕜 F] {g : E → 𝕜},
Function.HasTemperateGrowth g → ∀ (c : �... | null | true |
TensorProduct.tensorQuotEquivQuotSMul | Mathlib.LinearAlgebra.TensorProduct.Quotient | {R : Type u_1} →
(M : Type u_2) →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] → [inst_2 : Module R M] → (I : Ideal R) → TensorProduct R M (R ⧸ I) ≃ₗ[R] M ⧸ I • ⊤ | Right tensoring a module with a quotient of the ring is the same as
quotienting that module by the corresponding submodule. | true |
_private.Mathlib.Data.Finset.Union.0.Finset.filter_biUnion._proof_1_1 | Mathlib.Data.Finset.Union | ∀ {α : Type u_2} {β : Type u_1} [inst : DecidableEq β] (s : Finset α) (f : α → Finset β) (p : β → Prop)
[inst_1 : DecidablePred p], Finset.filter p (s.biUnion f) = s.biUnion fun a => Finset.filter p (f a) | null | false |
_private.Mathlib.Data.Nat.Multiplicity.0.Nat.emultiplicity_eq_card_pow_dvd._simp_1_6 | Mathlib.Data.Nat.Multiplicity | ∀ {p q : Prop}, (p ↔ q ∧ p) = (p → q) | null | false |
_private.Mathlib.Topology.Algebra.Group.Matrix.0.Matrix.SpecialLinearGroup.continuous_toGL._simp_1_1 | Mathlib.Topology.Algebra.Group.Matrix | ∀ {M : Type u_1} {X : Type u_3} [inst : TopologicalSpace M] [inst_1 : Monoid M] [inst_2 : TopologicalSpace X]
{f : X → Mˣ}, Continuous f = (Continuous (Units.val ∘ f) ∧ Continuous fun x => ↑(f x)⁻¹) | null | false |
Lean.Meta.getProdFields | Lean.Meta.ProdN | Lean.Expr → Lean.Expr → Lean.MetaM (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr) | Given a product `(e₁, e₂)` of type `t₁ × t₂`, return `(e₁, t₁, e₂, t₂)`. | true |
Lean.Meta.Grind.Arith.Cutsat.CooperSplit.mk.noConfusion | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {P : Sort u} →
{pred : Lean.Meta.Grind.Arith.Cutsat.CooperSplitPred} →
{k : ℕ} →
{h : Lean.Meta.Grind.Arith.Cutsat.CooperSplitProof} →
{pred' : Lean.Meta.Grind.Arith.Cutsat.CooperSplitPred} →
{k' : ℕ} →
{h' : Lean.Meta.Grind.Arith.Cutsat.CooperSplitProof} →
{ pred... | null | false |
WithTop.coe_nsmul._simp_1 | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : AddMonoid α] (a : α) (n : ℕ), n • ↑a = ↑(n • a) | null | false |
SheafOfModules.QuasicoherentData.IsFinitePresentation.mk | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat}
[inst_1 : ∀ (X : C), (J.over X).HasSheafCompose (CategoryTheory.forget₂ RingCat AddCommGrpCat)]
[inst_2 : ∀ (X : C), CategoryTheory.HasWeakSheafify (J.over X) AddCommGrpCat]... | null | true |
CategoryTheory.Subobject.imageFactorisation._proof_3 | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} [CategoryTheory.Limits.HasImages C] (f : X ⟶ Y)
(x : CategoryTheory.Subobject X), CategoryTheory.Limits.HasImage (CategoryTheory.CategoryStruct.comp x.arrow f) | null | false |
Finset.disjoint_range_addRightEmbedding | Mathlib.Algebra.Group.Nat.Range | ∀ (a : ℕ) (s : Finset ℕ), Disjoint (Finset.range a) (Finset.map (addRightEmbedding a) s) | null | true |
neg_mul | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u} [inst : Mul α] [inst_1 : HasDistribNeg α] (a b : α), -a * b = -(a * b) | null | true |
MvPolynomial.optionEquivLeft_apply | Mathlib.Algebra.MvPolynomial.Equiv | ∀ (R : Type u) (S₁ : Type v) [inst : CommSemiring R] (a : MvPolynomial (Option S₁) R),
(MvPolynomial.optionEquivLeft R S₁) a =
(MvPolynomial.aeval fun o => o.elim Polynomial.X fun s => Polynomial.C (MvPolynomial.X s)) a | null | true |
TopCat.Sheaf.existsUnique_gluing | Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {FC : C → C → Type u_2} {CC : C → Type u_3}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC]
[CategoryTheory.Limits.HasLimitsOfSize.{x, x, v_1, u_1} C] [(CategoryTheory.forget C).ReflectsIsomorphisms]... | A more convenient way of obtaining a unique gluing of sections for a sheaf.
| true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.deleteOne_preserves_strongAssignmentsInvariant._proof_1_6 | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | ∀ {n : ℕ} (f : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n) (id : ℕ),
(f.deleteOne id).assignments.size = n →
∀ (i : Std.Tactic.BVDecide.LRAT.Internal.PosFin n) (c : Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n),
f.clauses[id]! = some c →
∀ (l : Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.... | null | false |
Std.Internal.List.getKey!_nil | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Inhabited α] {a : α}, Std.Internal.List.getKey! a [] = default | null | true |
_private.Std.Data.ExtDTreeMap.Lemmas.0.Std.ExtDTreeMap.Const.alter_eq_empty_iff_erase_eq_empty._simp_1_1 | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [Std.TransCmp cmp],
(t = ∅) = (t.isEmpty = true) | null | false |
CategoryTheory.Abelian.SpectralObject.p_fromOpcycles_assoc | Mathlib.Algebra.Homology.SpectralObject.Cycles | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k : ι} (f : i ⟶ j) (g : j ⟶ k) (fg : i ⟶ k)
(h : CategoryTheory.CategoryStruct.comp f g = fg) (n : ... | null | true |
CategoryTheory.MonObj.ofIso._proof_2 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] {M X : C}
[inst_2 : CategoryTheory.MonObj M] (e : M ≅ X),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(CategoryTheory.CategoryStruct.comp CategoryTheor... | null | false |
Con.comap_eq | Mathlib.GroupTheory.Congruence.Hom | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {c : Con M} {f : N →* M},
Con.comap ⇑f ⋯ c = Con.ker (c.mk'.comp f) | Given a monoid homomorphism `f : N → M` and a congruence relation `c` on `M`, the congruence
relation induced on `N` by `f` equals the kernel of `c`'s quotient homomorphism composed with
`f`. | true |
List.Ico.eq_1 | Mathlib.Data.List.Intervals | ∀ (n m : ℕ), List.Ico n m = List.range' n (m - n) | null | true |
CategoryTheory.Cat.comp_eq_comp | Mathlib.CategoryTheory.Category.Cat | ∀ {X Y Z : CategoryTheory.Cat} (F : X ⟶ Y) (G : Y ⟶ Z),
(CategoryTheory.CategoryStruct.comp F G).toFunctor = F.toFunctor.comp G.toFunctor | Composition in the category of categories equals functor composition. | true |
Std.TreeMap.Raw.getKey?_insertIfNew | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF →
∀ {k a : α} {v : β}, (t.insertIfNew k v).getKey? a = if cmp k a = Ordering.eq ∧ k ∉ t then some k else t.getKey? a | null | true |
CategoryTheory.Limits.reflexiveCoforkEquivCofork_functor_obj_π | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(F : CategoryTheory.Functor CategoryTheory.Limits.WalkingReflexivePair C)
(G : CategoryTheory.Limits.ReflexiveCofork F),
((CategoryTheory.Limits.reflexiveCoforkEquivCofork F).functor.obj G).π = G.π | null | true |
FractionalIdeal.mem_add | Mathlib.RingTheory.FractionalIdeal.Basic | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
(I J : FractionalIdeal S P) (x : P), x ∈ I + J ↔ ∃ i ∈ I, ∃ j ∈ J, i + j = x | null | true |
HasSubset.Subset.eq_of_not_ssubset | Mathlib.Order.RelClasses | ∀ {α : Type u} [inst : HasSubset α] [inst_1 : HasSSubset α]
[IsNonstrictStrictOrder α (fun x1 x2 => x1 ⊆ x2) fun x1 x2 => x1 ⊂ x2] {a b : α} [Std.Antisymm fun x1 x2 => x1 ⊆ x2],
a ⊆ b → ¬a ⊂ b → a = b | **Alias** of `eq_of_subset_of_not_ssubset`. | true |
IsNowhereDense.isMeagre | Mathlib.Topology.GDelta.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, IsNowhereDense s → IsMeagre s | A nowhere dense set is meagre. | true |
MeasureTheory.Measure.instPartialOrder._proof_1 | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {x : MeasurableSpace α} (a b : MeasureTheory.Measure α),
(fun m₁ m₂ => ∀ (s : Set α), m₁ s ≤ m₂ s) a b ∧ ¬(fun m₁ m₂ => ∀ (s : Set α), m₁ s ≤ m₂ s) b a ↔
(∀ (s : Set α), a s ≤ b s) ∧ ¬∀ (s : Set α), b s ≤ a s | null | false |
Turing.PartrecToTM2.K'.ofNat_ctorIdx | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (x : Turing.PartrecToTM2.K'), Turing.PartrecToTM2.K'.ofNat x.ctorIdx = x | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks.0.SimpleGraph.Walk.isSubwalk_iff_darts_isInfix._proof_1_53 | Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks | ∀ {V : Type u_1} {G : SimpleGraph V} {u v u' v' : V} {p₁ : G.Walk u v} {p₂ : G.Walk u' v'} (k i : ℕ),
(∀ (h : i < p₁.darts.length), p₂.darts[i + k]? = some p₁.darts[i]) → i + 1 ≤ p₁.darts.length → k + i < p₂.darts.length | null | false |
Lean.Meta.Grind.GoalState.exprs | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.GoalState → Lean.PArray Lean.Expr | null | true |
IO.FS.Metadata.noConfusion | Init.System.IO | {P : Sort u} → {t t' : IO.FS.Metadata} → t = t' → IO.FS.Metadata.noConfusionType P t t' | null | false |
MeasureTheory.LocallyIntegrable.congr | Mathlib.MeasureTheory.Function.LocallyIntegrable | ∀ {X : Type u_1} {ε : Type u_3} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace ε]
[inst_3 : ContinuousENorm ε] {f g : X → ε} {μ : MeasureTheory.Measure X},
MeasureTheory.LocallyIntegrable f μ → f =ᵐ[μ] g → MeasureTheory.LocallyIntegrable g μ | null | true |
Matrix.blockDiag_add | Mathlib.Data.Matrix.Block | ∀ {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type u_12} [inst : Add α] (M N : Matrix (m × o) (n × o) α),
(M + N).blockDiag = M.blockDiag + N.blockDiag | null | true |
Lean.Meta.Grind.CheckResult.progress | Lean.Meta.Tactic.Grind.CheckResult | Lean.Meta.Grind.CheckResult | Updated basis, simplified equations. | true |
RingQuot.eqvGen_rel_eq | Mathlib.Algebra.RingQuot | ∀ {R : Type uR} [inst : Semiring R] (r : R → R → Prop), Relation.EqvGen (RingQuot.Rel r) = RingConGen.Rel r | null | true |
_private.Lean.Meta.Tactic.Simp.SimpCongrTheorems.0.Lean.Meta.SimpCongrTheorems.get.match_1 | Lean.Meta.Tactic.Simp.SimpCongrTheorems | (motive : Option (List Lean.Meta.SimpCongrTheorem) → Sort u_1) →
(x : Option (List Lean.Meta.SimpCongrTheorem)) →
(Unit → motive none) → ((cs : List Lean.Meta.SimpCongrTheorem) → motive (some cs)) → motive x | null | false |
Set.FiniteExhaustion.finite' | Mathlib.Data.Set.FiniteExhaustion | ∀ {α : Type u_1} {s : Set α} (self : s.FiniteExhaustion) (n : ℕ), Finite ↑(self.toFun n) | Every set in a `FiniteExhaustion` is finite. | true |
MeasureTheory.Filtration.coeFn_inf | Mathlib.Probability.Process.Filtration | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} [inst : Preorder ι] {f g : MeasureTheory.Filtration ι m},
↑(f ⊓ g) = ↑f ⊓ ↑g | null | true |
Manifold.IsImmersionAtOfComplement.of_opens | Mathlib.Geometry.Manifold.Immersion | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_7} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_11}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {n : WithTop ℕ∞} [IsManifold I n M]
... | null | true |
CategoryTheory.sheafification | Mathlib.CategoryTheory.Sites.Sheafification | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(J : CategoryTheory.GrothendieckTopology C) →
(D : Type u_1) →
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] →
[CategoryTheory.HasWeakSheafify J D] →
CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ D) (CategoryT... | The sheafification of a presheaf `P`, as a functor. | true |
Aesop.EMap.foldl | Aesop.EMap | {σ : Type} → {α : Type u_1} → σ → (σ → Lean.Expr → α → σ) → Aesop.EMap α → σ | null | true |
Orientation.oangle_sign_sub_left_eq_neg | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (x y : V), (o.oangle (y - x) y).sign = -(o.oangle x y).sign | Subtracting the first vector passed to `oangle` from the second vector negates the sign of
the angle. | true |
OrderedFinpartition.eraseLeft.eq_1 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n : ℕ} (c : OrderedFinpartition (n + 1)) (hc : Set.range (c.emb 0) = {0}),
c.eraseLeft hc =
{ length := c.length - 1,
partSize :=
have this := ⋯;
fun i => c.partSize (Fin.cast this i.succ),
partSize_pos := ⋯,
emb := fun i j =>
have this := ⋯;
(c.emb (Fin.cast t... | null | true |
PNat.dvd_antisymm | Mathlib.Data.PNat.Basic | ∀ {m n : ℕ+}, m ∣ n → n ∣ m → m = n | null | true |
IsRetrocompact.preimage_of_isClosedEmbedding | Mathlib.Topology.Constructible | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {s : Set Y},
Topology.IsClosedEmbedding f → IsCompact (Set.range f)ᶜ → IsRetrocompact s → IsRetrocompact (f ⁻¹' s) | [Stacks Tag 09YE](https://stacks.math.columbia.edu/tag/09YE) (Extracted from the proof) | true |
Mathlib.Tactic.Linarith.PreprocessorBase.mk.inj | Mathlib.Tactic.Linarith.Datatypes | ∀ {name : autoParam Lean.Name Mathlib.Tactic.Linarith.PreprocessorBase.name._autoParam} {description : String}
{name_1 : autoParam Lean.Name Mathlib.Tactic.Linarith.PreprocessorBase.name._autoParam} {description_1 : String},
{ name := name, description := description } = { name := name_1, description := description... | null | true |
Disjoint.closure_right | Mathlib.Topology.Closure | ∀ {X : Type u} [inst : TopologicalSpace X] {s t : Set X}, Disjoint s t → IsOpen s → Disjoint s (closure t) | null | true |
ModuleCat.MonoidalCategory.tensor_ext | Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic | ∀ {R : Type u} [inst : CommRing R] {M₁ M₂ M₃ : ModuleCat R}
{f g : CategoryTheory.MonoidalCategoryStruct.tensorObj M₁ M₂ ⟶ M₃},
(∀ (m : ↑M₁) (n : ↑M₂), (ModuleCat.Hom.hom f) (m ⊗ₜ[R] n) = (ModuleCat.Hom.hom g) (m ⊗ₜ[R] n)) → f = g | null | true |
NonUnitalSubring.map_id | Mathlib.RingTheory.NonUnitalSubring.Basic | ∀ {R : Type u} [inst : NonUnitalNonAssocRing R] (s : NonUnitalSubring R),
NonUnitalSubring.map (NonUnitalRingHom.id R) s = s | null | true |
Path.refl_symm | Mathlib.Topology.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] {a : X}, (Path.refl a).symm = Path.refl a | null | true |
HasDerivAt | Mathlib.Analysis.Calculus.Deriv.Basic | {𝕜 : Type u} →
[inst : NontriviallyNormedField 𝕜] →
{F : Type v} →
[inst_1 : AddCommGroup F] →
[inst_2 : Module 𝕜 F] → [inst_3 : TopologicalSpace F] → [ContinuousSMul 𝕜 F] → (𝕜 → F) → F → 𝕜 → Prop | `f` has the derivative `f'` at the point `x`.
That is, `f x' = f x + (x' - x) • f' + o(x' - x)` where `x'` converges to `x`.
| true |
Std.PRange.UpwardEnumerable.Map.PreservesLE.le_iff | Init.Data.Range.Polymorphic.Map | ∀ {α : Type u_1} {β : Type u_2} {inst : Std.PRange.UpwardEnumerable α} {inst_1 : Std.PRange.UpwardEnumerable β}
{inst_2 : LE α} {inst_3 : LE β} {f : Std.PRange.UpwardEnumerable.Map α β} [self : f.PreservesLE] {a b : α},
a ≤ b ↔ f.toFun a ≤ f.toFun b | null | true |
Equiv.Perm.isCycle_swap_mul_aux₂ | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_4} [inst : DecidableEq α] (n : ℤ) {b x : α} {f : Equiv.Perm α},
(Equiv.swap x (f x) * f) b ≠ b → (f ^ n) (f x) = b → ∃ i, ((Equiv.swap x (f x) * f) ^ i) (f x) = b | null | true |
MeasureTheory.FiniteMeasure.apply_iUnion_le | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] {μ : MeasureTheory.FiniteMeasure Ω} {f : ℕ → Set Ω},
(Summable fun n => μ (f n)) → μ (⋃ n, f n) ≤ ∑' (n : ℕ), μ (f n) | null | true |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.visitConst._sparseCasesOn_1 | Lean.Meta.LetToHave | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | null | false |
Std.DTreeMap.Raw.WF.insertMany | Std.Data.DTreeMap.Raw.WF | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp] {ρ : Type u_1}
[inst : ForIn Id ρ ((a : α) × β a)] {l : ρ} {t : Std.DTreeMap.Raw α β cmp}, t.WF → (t.insertMany l).WF | null | true |
Tactic.ComputeAsymptotics.Monomial.ctorIdx | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Basic | Tactic.ComputeAsymptotics.Monomial → ℕ | null | false |
Not.decidable_imp_symm | Mathlib.Logic.Basic | ∀ {a b : Prop} [Decidable a], (¬a → b) → ¬b → a | **Alias** of `Decidable.not_imp_symm`. | true |
Mathlib.Tactic.Order.AtomicFact.eq.injEq | Mathlib.Tactic.Order.CollectFacts | ∀ (lhs rhs : ℕ) (proof : Lean.Expr) (lhs_1 rhs_1 : ℕ) (proof_1 : Lean.Expr),
(Mathlib.Tactic.Order.AtomicFact.eq lhs rhs proof = Mathlib.Tactic.Order.AtomicFact.eq lhs_1 rhs_1 proof_1) =
(lhs = lhs_1 ∧ rhs = rhs_1 ∧ proof = proof_1) | null | true |
CategoryTheory.Pretriangulated.TriangleMorphism.mk.congr_simp | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ]
{T₁ T₂ : CategoryTheory.Pretriangulated.Triangle C} (hom₁ hom₁_1 : T₁.obj₁ ⟶ T₂.obj₁) (e_hom₁ : hom₁ = hom₁_1)
(hom₂ hom₂_1 : T₁.obj₂ ⟶ T₂.obj₂) (e_hom₂ : hom₂ = hom₂_1) (hom₃ hom₃_1 : T₁.obj₃ ⟶ T₂.obj₃) (e_hom₃ : hom₃ =... | null | true |
_private.Mathlib.Algebra.Category.MonCat.Basic.0.AddMonCat.Hom.mk._flat_ctor | Mathlib.Algebra.Category.MonCat.Basic | {A B : AddMonCat} → (↑A →+ ↑B) → A.Hom B | null | false |
IsRelPrime.mul_add_right_right | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u_1} [inst : CommRing R] {x y : R}, IsRelPrime x y → ∀ (z : R), IsRelPrime x (z * x + y) | null | true |
Ideal.Quotient.groupWithZero._proof_12 | Mathlib.RingTheory.Ideal.Quotient.Basic | ∀ {R : Type u_1} [inst : Ring R] (I : Ideal R) [inst_1 : I.IsTwoSided] [hI : I.IsMaximal] (a : R ⧸ I),
a ≠ 0 → a * a⁻¹ = 1 | null | false |
DenseRange.eq_zero_of_inner_left | Mathlib.Analysis.InnerProductSpace.Continuous | ∀ {E : Type u_4} {ι : Type u_6} (𝕜 : Type u_7) [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] {x : E} {f : ι → E}, DenseRange f → (∀ (i : ι), inner 𝕜 x (f i) = 0) → x = 0 | null | true |
_private.Init.Data.Array.QSort.Basic.0.Array.qsort._auto_6 | Init.Data.Array.QSort.Basic | Lean.Syntax | null | false |
_private.Lean.Meta.Tactic.Simp.SimpAll.0.Lean.Meta.SimpAll.main.match_1 | Lean.Meta.Tactic.Simp.SimpAll | (motive : Array Lean.FVarId × Lean.MVarId → Sort u_1) →
(x : Array Lean.FVarId × Lean.MVarId) →
((fst : Array Lean.FVarId) → (mvarId : Lean.MVarId) → motive (fst, mvarId)) → motive x | null | false |
Finset.le_min' | Mathlib.Data.Finset.Max | ∀ {α : Type u_2} [inst : LinearOrder α] (s : Finset α) (H : s.Nonempty) (x : α), (∀ y ∈ s, x ≤ y) → x ≤ s.min' H | null | true |
Computation.thinkN._sunfold | Mathlib.Data.Seq.Computation | {α : Type u} → Computation α → ℕ → Computation α | null | false |
_private.Mathlib.Tactic.Translate.Reorder.0.Mathlib.Tactic.Translate.decomposePerm.match_10 | Mathlib.Tactic.Translate.Reorder | (motive : Option Mathlib.Tactic.Translate.Permutation → Sort u_1) →
(x : Option Mathlib.Tactic.Translate.Permutation) →
(Unit → motive none) → ((a : Mathlib.Tactic.Translate.Permutation) → motive (some a)) → motive x | null | false |
Std.HashSet.get_diff | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{k : α} {h_mem : k ∈ m₁ \ m₂}, (m₁ \ m₂).get k h_mem = m₁.get k ⋯ | null | true |
List.splitOnPPrepend_cons_neg | Init.Data.List.SplitOn.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {a : α} {l acc : List α},
p a = false → List.splitOnPPrepend p (a :: l) acc = List.splitOnPPrepend p l (a :: acc) | null | true |
CategoryTheory.Hom.ring._proof_11 | Mathlib.CategoryTheory.Monoidal.Ring | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {R : C} [inst_3 : CategoryTheory.RingObj R] {X : C} (n : ℕ) (a : X ⟶ R),
SubNegMonoid.zsmul (Int.negSucc n) a = -SubNegMonoid.zsmul (↑n.succ) a | null | false |
_private.Mathlib.Data.List.Lattice.0.List.erase_bagInter_of_not_mem._proof_1_1 | Mathlib.Data.List.Lattice | ∀ {α : Type u_1} {a : α} [inst : DecidableEq α] {l₂ : List α}, ([].erase a).bagInter l₂ = [].bagInter l₂ | null | false |
Real.smoothTransition | Mathlib.Analysis.SpecialFunctions.SmoothTransition | ℝ → ℝ | An infinitely smooth function `f : ℝ → ℝ` such that `f x = 0` for `x ≤ 0`,
`f x = 1` for `1 ≤ x`, and `0 < f x < 1` for `0 < x < 1`. | true |
EReal.sub_lt_of_lt_add | Mathlib.Data.EReal.Operations | ∀ {a b c : EReal}, a < b + c → a - c < b | null | true |
DomMulAct.symm_mk_one | Mathlib.GroupTheory.GroupAction.DomAct.Basic | ∀ {M : Type u_1} [inst : One M], DomMulAct.mk.symm 1 = 1 | null | true |
Mathlib.Tactic.etaStruct? | Mathlib.Tactic.DefEqTransformations | Lean.Expr → optParam Bool true → Lean.MetaM (Option Lean.Expr) | Checks if the expression is of the form `S.mk x.1 ... x.n` with `n` nonzero
and `S.mk` a structure constructor and returns `x`.
Each projection `x.i` can be either a native projection or from a projection function.
`tryWhnfR` controls whether to try applying `whnfR` to arguments when none of them
are obviously project... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.