name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ContinuousLinearMapWOT.comp.congr_simp | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | ∀ {𝕜₁ : Type u_5} {𝕜₂ : Type u_6} {𝕜₃ : Type u_7} {E : Type u_9} {F : Type u_10} {G : Type u_11} [inst : NormedField 𝕜₁]
[inst_1 : NormedField 𝕜₂] [inst_2 : NormedField 𝕜₃] {σ₁₂ : 𝕜₁ →+* 𝕜₂} {σ₁₃ : 𝕜₁ →+* 𝕜₃} {σ₂₃ : 𝕜₂ →+* 𝕜₃}
[inst_3 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] [inst_4 : AddCommGroup E] [inst_5 : ... | null | true |
Subgroup.Normal.conj_smul_eq_self | Mathlib.Algebra.Group.Subgroup.Pointwise | ∀ {G : Type u_2} [inst : Group G] (g : G) (H : Subgroup G) [h : H.Normal], MulAut.conj g • H = H | null | true |
AlgebraicGeometry.specTargetImageFactorization._proof_1 | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X : AlgebraicGeometry.Scheme} {A : CommRingCat} (f : X ⟶ AlgebraicGeometry.Spec A),
AlgebraicGeometry.specTargetImageIdeal f ≤ AlgebraicGeometry.specTargetImageIdeal f | null | false |
_private.Mathlib.Topology.Instances.EReal.Lemmas.0.EReal.tendsto_nhds_top_iff_real._simp_1_1 | Mathlib.Topology.Instances.EReal.Lemmas | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Ioi b) = (b < x) | null | false |
Real.sinOrderIso._proof_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | Real.sin '' Set.Icc (-(Real.pi / 2)) (Real.pi / 2) = Set.Icc (-1) 1 | null | false |
UInt8.not_le | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, ¬a ≤ b ↔ b < a | null | true |
Std.BundledIterM.Equiv._proof_1 | Std.Data.Iterators.Lemmas.Equivalence.Basic | ∀ (m : Type u_1 → Type u_2) (β : Type u_1) [inst : Monad m] [inst_1 : LawfulMonad m]
(R S : Std.BundledIterM m β → Std.BundledIterM m β → Prop),
Lean.Order.PartialOrder.rel R S →
∀ (ita itb : Std.BundledIterM m β),
Std.Iterators.HetT.map (Std.IterStep.mapIterator (Quot.mk S)) ita.step =
Std.Iter... | null | false |
RestrictedProduct.mk.congr_simp | Mathlib.Topology.Algebra.RestrictedProduct.Units | ∀ {ι : Type u_1} {R : ι → Type u_2} {A : (i : ι) → Set (R i)} {𝓕 : Filter ι} (x x_1 : (i : ι) → R i) (e_x : x = x_1)
(hx : ∀ᶠ (i : ι) in 𝓕, x i ∈ A i), RestrictedProduct.mk x hx = RestrictedProduct.mk x_1 ⋯ | null | true |
Matrix.toMatrix₂Aux_toLinearMap₂'Aux | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ (R : Type u_1) {R₁ : Type u_2} {S₁ : Type u_3} {R₂ : Type u_4} {S₂ : Type u_5} {N₂ : Type u_10} {n : Type u_11}
{m : Type u_12} [inst : CommSemiring R] [inst_1 : Semiring R₁] [inst_2 : Semiring S₁] [inst_3 : Semiring R₂]
[inst_4 : Semiring S₂] [inst_5 : AddCommMonoid N₂] [inst_6 : Module R N₂] [inst_7 : Module S₁... | null | true |
LowerSet.prod_self_lt_prod_self._simp_1 | Mathlib.Order.UpperLower.Prod | ∀ {α : Type u_1} [inst : Preorder α] {s₁ s₂ : LowerSet α}, (s₁ ×ˢ s₁ < s₂ ×ˢ s₂) = (s₁ < s₂) | null | false |
Lean.Meta.Grind.Methods.evalTactic | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.Methods → Lean.Meta.Grind.EvalTactic | null | true |
_private.Mathlib.Algebra.Homology.ExactSequenceFour.0.CategoryTheory.ComposableArrows.IsComplex.cokerToKer'._proof_3 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {n : ℕ}, ∀ k ≤ n, ¬k + 1 ≤ n + 3 → False | null | false |
Algebra.exists_aeval_invOf_eq_zero_of_idealMap_adjoin_sup_span_eq_top | Mathlib.RingTheory.Polynomial.Ideal | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (x : S) (I : Ideal R),
I ≠ ⊤ →
∀ [inst_3 : Invertible x],
Ideal.map (algebraMap R ↥R[x]) I ⊔ Ideal.span {⟨x, ⋯⟩} = ⊤ →
∃ p, p.leadingCoeff - 1 ∈ I ∧ (Polynomial.aeval ⅟x) p = 0 | null | true |
ULift.semiring._proof_9 | Mathlib.Algebra.Ring.ULift | ∀ {R : Type u_2} [inst : Semiring R] (a b c : ULift.{u_1, u_2} R), (a + b) * c = a * c + b * c | null | false |
OrderedFinpartition.extendLeft._proof_14 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n : ℕ} (c : OrderedFinpartition n) (i : Fin c.length), 0 < Fin.cons 1 c.partSize i.succ | null | false |
_private.Lean.Parser.Level.0.Lean.Parser.Level.hole._regBuiltin.Lean.Parser.Level.hole.declRange_3 | Lean.Parser.Level | IO Unit | null | false |
Lean.Meta.Match.Overlaps.noConfusionType | Lean.Meta.Match.MatcherInfo | Sort u → Lean.Meta.Match.Overlaps → Lean.Meta.Match.Overlaps → Sort u | null | false |
BoundedContinuousFunction.instModule'._proof_8 | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u_1} {β : Type u_2} {𝕜 : Type u_3} [inst : NormedField 𝕜] [inst_1 : TopologicalSpace α]
[inst_2 : SeminormedAddCommGroup β] [inst_3 : NormedSpace 𝕜 β] (f : BoundedContinuousFunction α β), 1 • f = f | null | false |
CategoryTheory.Triangulated.Octahedron.map_m₁ | Mathlib.CategoryTheory.Triangulated.Functor | ∀ {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.HasShift C ℤ]
[inst_3 : CategoryTheory.HasShift D ℤ] [inst_4 : CategoryTheory.Limits.HasZeroObject C]
[inst_5 : CategoryTheory.Limits.HasZeroObject D] [inst_6 : Ca... | null | true |
CharacterModule.instModule._proof_5 | Mathlib.Algebra.Module.CharacterModule | ∀ (R : Type u_2) [inst : CommRing R] (A : Type u_1) [inst_1 : AddCommGroup A] [inst_2 : Module R A] (r s : R)
(x : CharacterModule A), (r + s) • x = r • x + s • x | null | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Basic.0.CategoryTheory.IsPullback.of_iso'._simp_1_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : Z ⟶ Y} {g : Z ⟶ X},
(CategoryTheory.CategoryStruct.comp f α.inv = g) = (f = CategoryTheory.CategoryStruct.comp g α.hom) | null | false |
IsPurelyInseparable.surjective_algebraMap_of_isSeparable | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ (F : Type u_1) (E : Type u_2) [inst : CommRing F] [inst_1 : Ring E] [inst_2 : Algebra F E] [IsPurelyInseparable F E]
[Algebra.IsSeparable F E], Function.Surjective ⇑(algebraMap F E) | If `E / F` is both purely inseparable and separable, then `algebraMap F E` is surjective. | true |
CategoryTheory.Lax.OplaxTrans.homCategory._proof_4 | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] {C : Type u_5} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.LaxFunctor B C} {X Y : F ⟶ G} (f : CategoryTheory.Lax.OplaxTrans.Hom X Y),
{ as := f.as.vcomp { as := CategoryTheory.Lax.OplaxTrans.Modification.id Y }.as } = f | null | false |
Lean.Order.CompleteLattice.casesOn | Init.Internal.Order.Basic | {α : Sort u} →
{motive : Lean.Order.CompleteLattice α → Sort u_1} →
(t : Lean.Order.CompleteLattice α) →
([toPartialOrder : Lean.Order.PartialOrder α] →
(has_sup : ∀ (c : α → Prop), Exists (Lean.Order.is_sup c)) →
motive { toPartialOrder := toPartialOrder, has_sup := has_sup }) →
... | null | false |
Matrix.transpose_fromRows | Mathlib.Data.Matrix.ColumnRowPartitioned | ∀ {R : Type u_1} {m₁ : Type u_3} {m₂ : Type u_4} {n : Type u_5} (A₁ : Matrix m₁ n R) (A₂ : Matrix m₂ n R),
(A₁.fromRows A₂).transpose = A₁.transpose.fromCols A₂.transpose | A row partitioned matrix when transposed gives a column partitioned matrix with rows of the
initial matrix transposed to become columns. | true |
LinearMap.ofIsCompl_eq_add | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_3}
[inst_3 : AddCommGroup F] [inst_4 : Module R F] {p q : Submodule R E} (hpq : IsCompl p q) {φ : ↥p →ₗ[R] F}
{ψ : ↥q →ₗ[R] F}, LinearMap.ofIsCompl hpq φ ψ = φ ∘ₗ p.projectionOnto q hpq + ψ ∘ₗ q.projectionOnt... | null | true |
RingEquiv.prodProdProdComm._proof_3 | Mathlib.Algebra.Ring.Prod | ∀ (R : Type u_2) (R' : Type u_1) (S : Type u_4) (S' : Type u_3) [inst : NonAssocSemiring R]
[inst_1 : NonAssocSemiring S] [inst_2 : NonAssocSemiring R'] [inst_3 : NonAssocSemiring S'] (x y : (R × R') × S × S'),
(MulEquiv.prodProdProdComm R R' S S').toFun (x * y) =
(MulEquiv.prodProdProdComm R R' S S').toFun x *... | null | false |
_private.Mathlib.CategoryTheory.Sites.Hypercover.ZeroFamily.0.CategoryTheory.PreZeroHypercoverFamily.mem_precoverage_iff.match_1_1 | Mathlib.CategoryTheory.Sites.Hypercover.ZeroFamily | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {P : CategoryTheory.PreZeroHypercoverFamily C} {X : C}
(motive : (R : CategoryTheory.Presieve X) → R ∈ P.precoverage.coverings X → Prop) (R : CategoryTheory.Presieve X)
(x : R ∈ P.precoverage.coverings X),
(∀ (E : CategoryTheory.PreZeroHypercover X) (... | null | false |
IO.FS.Mode.recOn | Init.System.IO | {motive : IO.FS.Mode → Sort u} →
(t : IO.FS.Mode) →
motive IO.FS.Mode.read →
motive IO.FS.Mode.write →
motive IO.FS.Mode.writeNew → motive IO.FS.Mode.readWrite → motive IO.FS.Mode.append → motive t | null | false |
Vector.flatMap_push | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {β : Type u_2} {m : ℕ} {xs : Vector α n} {x : α} {f : α → Vector β m},
(xs.push x).flatMap f = Vector.cast ⋯ (xs.flatMap f ++ f x) | null | true |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Raw.Internal.foldRev.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} {δ : Type w} (f : δ → (a : α) → β a → δ) (init : δ) (b : Std.DHashMap.Raw α β),
Std.DHashMap.Raw.Internal.foldRev f init b =
(Std.DHashMap.Raw.Internal.foldRevM (fun x1 x2 x3 => pure (f x1 x2 x3)) init b).run | null | true |
UInt8.reduceAdd | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | Lean.Meta.Simp.DSimproc | null | true |
LocallyConstant.desc | Mathlib.Topology.LocallyConstant.Basic | {X : Type u_5} →
{α : Type u_6} →
{β : Type u_7} →
[inst : TopologicalSpace X] →
{g : α → β} → (f : X → α) → (h : LocallyConstant X β) → g ∘ f = ⇑h → Function.Injective g → LocallyConstant X α | If a locally constant function factors through an injection, then it factors through a locally
constant function. | true |
DFinsupp.filter.congr_simp | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} [inst : (i : ι) → Zero (β i)] (p p_1 : ι → Prop),
p = p_1 →
∀ {inst_1 : DecidablePred p} [inst_2 : DecidablePred p_1] (x x_1 : Π₀ (i : ι), β i),
x = x_1 → DFinsupp.filter p x = DFinsupp.filter p_1 x_1 | null | true |
CategoryTheory.Lax.OplaxTrans.LaxFunctor.bicategory_leftUnitor_inv_as_app | Mathlib.CategoryTheory.Bicategory.FunctorBicategory.Lax | ∀ (B : Type u₁) [inst : CategoryTheory.Bicategory B] (C : Type u₂) [inst_1 : CategoryTheory.Bicategory C]
{x x_1 : CategoryTheory.LaxFunctor B C} (η : x ⟶ x_1) (a : B),
(CategoryTheory.Bicategory.leftUnitor η).inv.as.app a = (CategoryTheory.Bicategory.leftUnitor (η.app a)).inv | null | true |
ComplexShape.TensorSigns.casesOn | Mathlib.Algebra.Homology.ComplexShapeSigns | {I : Type u_7} →
[inst : AddMonoid I] →
{c : ComplexShape I} →
{motive : c.TensorSigns → Sort u} →
(t : c.TensorSigns) →
((ε' : Multiplicative I →* ℤˣ) →
(rel_add : ∀ (p q r : I), c.Rel p q → c.Rel (p + r) (q + r)) →
(add_rel : ∀ (p q r : I), c.Rel p q → c.Rel... | null | false |
CategoryTheory.Subobject.ofLEMk_comp | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {B A : C} {X : CategoryTheory.Subobject B} {f : A ⟶ B}
[inst_1 : CategoryTheory.Mono f] (h : X ≤ CategoryTheory.Subobject.mk f),
CategoryTheory.CategoryStruct.comp (X.ofLEMk f h) f = X.arrow | null | true |
_private.Mathlib.Analysis.Normed.Group.Basic.0.enorm'_eq_iff_norm_eq._simp_1_1 | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_4} [inst : SeminormedGroup E] (x : E), ‖x‖ₑ = ENNReal.ofReal ‖x‖ | null | false |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Summable.0.EisensteinSeries.tendsto_double_sum_S_act._simp_1_1 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Summable | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : β → γ} {g : α → β} {x : Filter α} {y : Filter γ},
Filter.Tendsto f (Filter.map g x) y = Filter.Tendsto (f ∘ g) x y | null | false |
ENat.toENNReal_strictMono | Mathlib.Basic.Real.ENatENNReal | StrictMono ENat.toENNReal | null | true |
CategoryTheory.CommRingObjCat.instCategory | Mathlib.CategoryTheory.Monoidal.Ring | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] →
CategoryTheory.Category.{v, max u v} (CategoryTheory.CommRingObjCat C) | null | true |
Lean.Elab.Tactic.throwOrLogError | Lean.Elab.Tactic.Basic | Lean.MessageData → Lean.Elab.Tactic.TacticM Unit | Like `throwError`, but, if recovery is enabled, logs the error instead.
| true |
_private.Mathlib.GroupTheory.Perm.Cycle.Basic.0.Equiv.Perm.IsCycle.commute_iff._simp_1_1 | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {G : Type u_1} [inst : Group G] {g h : G}, (h ∈ Subgroup.zpowers g) = ∃ k, g ^ k = h | null | false |
descPochhammer_one | Mathlib.RingTheory.Polynomial.Pochhammer | ∀ (R : Type u) [inst : Ring R], descPochhammer R 1 = Polynomial.X | null | true |
Lean.Meta.Simp.Arith.Int.ToLinear.State.mk.inj | Lean.Meta.Tactic.Simp.Arith.Int.Basic | ∀ {varMap : Lean.Meta.KExprMap ℕ} {vars : Array Lean.Expr} {varMap_1 : Lean.Meta.KExprMap ℕ} {vars_1 : Array Lean.Expr},
{ varMap := varMap, vars := vars } = { varMap := varMap_1, vars := vars_1 } → varMap = varMap_1 ∧ vars = vars_1 | null | true |
_private.Mathlib.Data.Fin.Tuple.Basic.0.Fin.lt_find_iff._simp_1_2 | Mathlib.Data.Fin.Tuple.Basic | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | null | false |
_private.Mathlib.Tactic.Echelon.Reflection.0.Mathlib.Tactic.Echelon.getD_of_isLowerTriangularDiagList._proof_1_12 | Mathlib.Tactic.Echelon.Reflection | ∀ {α : Type u_1} {k : ℕ} {row : List α} (j : ℕ),
(List.drop k row)[j - k]? = row[k + (j - k)]? → j - k + 1 ≤ (List.drop k row).length → k + (j - k) < row.length | null | false |
Set.fintypeUnion._proof_1 | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Set α) [inst_1 : Fintype ↑s] [inst_2 : Fintype ↑t] (x : α),
x ∈ s.toFinset ∪ t.toFinset ↔ x ∈ s ∪ t | null | false |
ContinuousAlternatingMap.instNormedSpace | Mathlib.Analysis.Normed.Module.Alternating.Basic | {𝕜 : Type u} →
{E : Type wE} →
{F : Type wF} →
{ι : Type v} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : SeminormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
[inst_3 : SeminormedAddCommGroup F] →
[inst_4 : NormedSpace 𝕜 F] →
... | null | true |
WithBot.bot_lt_coe | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LT α] (a : α), ⊥ < ↑a | null | true |
Lean.Lsp.DiagnosticRelatedInformation.mk.noConfusion | Lean.Data.Lsp.Diagnostics | {P : Sort u} →
{location : Lean.Lsp.Location} →
{message : String} →
{location' : Lean.Lsp.Location} →
{message' : String} →
{ location := location, message := message } = { location := location', message := message' } →
(location = location' → message = message' → P) → P | null | false |
instInhabitedBool.default | Init.Prelude | Bool | null | true |
_private.Mathlib.LinearAlgebra.Matrix.Notation.0.Matrix.delabMatrixNotation._sparseCasesOn_1 | Mathlib.LinearAlgebra.Matrix.Notation | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
WeierstrassCurve.integralModel | Mathlib.AlgebraicGeometry.EllipticCurve.Reduction | (R : Type u_1) →
[inst : CommRing R] →
{K : Type u_2} →
[inst_1 : Field K] →
[inst_2 : Algebra R K] → (W : WeierstrassCurve K) → [hW : WeierstrassCurve.IsIntegral R W] → WeierstrassCurve R | An integral model of an integral Weierstrass curve. | true |
_private.Std.Time.Date.Unit.Weekday.0.Std.Time.Weekday.toOrdinal.eq_5 | Std.Time.Date.Unit.Weekday | Std.Time.Weekday.friday.toOrdinal = 5 | null | true |
Mathlib.Tactic.ClickSuggestions.RwInfo.casesOn | Mathlib.Tactic.ClickSuggestions.Rewrite | {motive : Mathlib.Tactic.ClickSuggestions.RwInfo → Sort u} →
(t : Mathlib.Tactic.ClickSuggestions.RwInfo) →
((rootExpr subExpr : Lean.Expr) →
(rflTarget? : Option Lean.Expr) →
(pos : Lean.SubExpr.Pos) →
(rwKind : Mathlib.Tactic.ClickSuggestions.RwKind) →
motive
... | null | false |
RBTree.RBNode.IsCut.mk | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {cut : α → Ordering},
(∀ {x y : α} [Std.TransCmp cmp], cmp x y ≠ Ordering.gt → cut x = Ordering.lt → cut y = Ordering.lt) →
(∀ {x y : α} [Std.TransCmp cmp], cmp x y ≠ Ordering.gt → cut y = Ordering.gt → cut x = Ordering.gt) →
RBTree.RBNode.IsCut cmp cut | null | true |
CategoryTheory.Limits.IsTerminal.ofUniqueHom.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} (h : (Y : C) → Y ⟶ X)
(uniq : ∀ (Y : C) (m : Y ⟶ X), m = h Y),
CategoryTheory.Limits.IsTerminal.ofUniqueHom h uniq = CategoryTheory.Limits.IsTerminal.ofUnique X | null | true |
Int.fib_dvd | Mathlib.Data.Int.Fib.Basic | ∀ (m n : ℤ), m ∣ n → Int.fib m ∣ Int.fib n | null | true |
ZMod.inv | Mathlib.Data.ZMod.Basic | (n : ℕ) → ZMod n → ZMod n | The inversion on `ZMod n`.
It is setup in such a way that `a * a⁻¹` is equal to `gcd a.val n`.
In particular, if `a` is coprime to `n`, and hence a unit, `a * a⁻¹ = 1`. | true |
Aesop.instBEqPhaseName.beq | Aesop.Rule.Name | Aesop.PhaseName → Aesop.PhaseName → Bool | null | true |
AbsConvexOpenSets.coe_isOpen | Mathlib.Analysis.LocallyConvex.AbsConvexOpen | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : TopologicalSpace E] [inst_1 : AddCommMonoid E] [inst_2 : SeminormedRing 𝕜]
[inst_3 : SMul 𝕜 E] [inst_4 : PartialOrder 𝕜] (s : AbsConvexOpenSets 𝕜 E), IsOpen ↑s | null | true |
_private.Mathlib.Order.Interval.Set.Disjoint.0.Set.Ioo_disjoint_Ioo._simp_1_2 | Mathlib.Order.Interval.Set.Disjoint | ∀ {α : Type u_1} [inst : Preorder α] {a b : α} [DenselyOrdered α], (Set.Ioo a b = ∅) = ¬a < b | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.IsPath.snd_of_toSubgraph_adj._proof_1_7 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} {u v v' : V} {p : G.Walk u v} (i : ℕ),
(p.getVert i = u ∧ p.getVert (i + 1) = v' ∨ p.getVert i = v' ∧ p.getVert (i + 1) = u) ∧ i < p.length →
i + 1 ≤ p.length | null | false |
_private.Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots.0.IsPrimitiveRoot.card_nthRoots._simp_1_1 | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {α : Type u_1} {s : Multiset α}, (s.card = 0) = (s = 0) | null | false |
Std.TreeSet.isNone_max?_eq_isEmpty | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp], t.max?.isNone = t.isEmpty | null | true |
ProofWidgets.instToJsonRpcEncodablePacket.toJson._@.ProofWidgets.Presentation.Expr.2220529756._hygCtx._hyg.29 | ProofWidgets.Presentation.Expr | ProofWidgets.RpcEncodablePacket✝ → Lean.Json | null | false |
Std.TreeMap.Raw.size_insert | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} {v : β}, (t.insert k v).size = if t.contains k = true then t.size else t.size + 1 | null | true |
Lean.reservedMacroScope | Init.Prelude | ℕ | Macro scope used internally. It is not available for our frontend. | true |
cfcₙ_comp_smul._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
Std.TreeMap.getKey!_union | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α] {k : α}, (t₁ ∪ t₂).getKey! k = t₂.getKeyD k (t₁.getKey! k) | null | true |
LinearMap.ker_eq_top._simp_1 | Mathlib.Algebra.Module.Submodule.Ker | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [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₂}, (f.ker = ⊤) = (f = 0) | null | false |
RegularWreathProduct.mk.injEq | Mathlib.GroupTheory.RegularWreathProduct | ∀ {D : Type u_1} {Q : Type u_2} (left : Q → D) (right : Q) (left_1 : Q → D) (right_1 : Q),
({ left := left, right := right } = { left := left_1, right := right_1 }) = (left = left_1 ∧ right = right_1) | null | true |
Field.Emb.Cardinal.leastExt.eq_1 | Mathlib.FieldTheory.CardinalEmb | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E]
[rank_inf : Fact (Cardinal.aleph0 ≤ Module.rank F E)] [inst_3 : Algebra.IsAlgebraic F E],
Field.Emb.Cardinal.leastExt F E =
⋯.fix fun i ih =>
let s := Set.range fun j => (Field.Emb.Cardinal.wellOrderedBasis F E) (ih ↑j ... | null | true |
ContinuousAlgHom.coe_mk' | Mathlib.Topology.Algebra.Algebra | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Semiring A] [inst_2 : TopologicalSpace A]
{B : Type u_3} [inst_3 : Semiring B] [inst_4 : TopologicalSpace B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
(f : A →ₐ[R] B) (h : Continuous (↑↑f.toRingHom).toFun), ⇑{ toAlgHom := f, cont := h } = ⇑f | null | true |
ProbabilityTheory.variance_id_gaussianReal | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {μ : ℝ} {v : NNReal}, ProbabilityTheory.variance id (ProbabilityTheory.gaussianReal μ v) = ↑v | The variance of a real Gaussian distribution `gaussianReal μ v` is
its variance parameter `v`. | true |
Turing.PartrecToTM2.trStmts₁_supports' | Mathlib.Computability.TuringMachine.ToPartrec | ∀ {S : Finset Turing.PartrecToTM2.Λ'} {q : Turing.PartrecToTM2.Λ'} {K : Finset Turing.PartrecToTM2.Λ'},
Turing.PartrecToTM2.Λ'.Supports S q →
Turing.PartrecToTM2.trStmts₁ q ∪ K ⊆ S →
(K ⊆ S → Turing.PartrecToTM2.Supports K S) → Turing.PartrecToTM2.Supports (Turing.PartrecToTM2.trStmts₁ q ∪ K) S | null | true |
Std.Time.Year.instSubOffset | Std.Time.Date.Unit.Year | Sub Std.Time.Year.Offset | null | true |
Lean.Elab.MonadAutoImplicits.recOn | Lean.Elab.InfoTree.Types | {m : Type → Type} →
{motive : Lean.Elab.MonadAutoImplicits m → Sort u} →
(t : Lean.Elab.MonadAutoImplicits m) →
((getAutoImplicits : m (Array Lean.Expr)) → motive { getAutoImplicits := getAutoImplicits }) → motive t | null | false |
AlgebraicGeometry.Scheme.instCategoryAffineEtale._proof_8 | Mathlib.AlgebraicGeometry.Sites.AffineEtale | ∀ (S : AlgebraicGeometry.Scheme),
autoParam
(∀ {X Y : S.AffineEtale} (f : X ⟶ Y), CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y) = f)
CategoryTheory.Category.comp_id._autoParam | null | false |
Associated.mul_mul | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoid M] {a₁ a₂ b₁ b₂ : M},
Associated a₁ b₁ → Associated a₂ b₂ → Associated (a₁ * a₂) (b₁ * b₂) | null | true |
Std.Async.Sleep.noConfusionType | Std.Async.Timer | Sort u → Std.Async.Sleep → Std.Async.Sleep → Sort u | null | false |
Submodule.generators_card | Mathlib.Algebra.Module.SpanRank | ∀ {R : Type u_1} {M : Type u} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (p : Submodule R M),
Cardinal.mk ↑p.generators = p.spanRank | null | true |
Ordinal.cof_eq_zero._simp_1 | Mathlib.SetTheory.Cardinal.Cofinality.Ordinal | ∀ {o : Ordinal.{u_1}}, (o.cof = 0) = (o = 0) | null | false |
Polynomial.Splits.of_degree_eq_two | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : Field R] {f : Polynomial R} {x : R}, f.degree = 2 → Polynomial.eval x f = 0 → f.Splits | null | true |
Height.AdmissibleAbsValues.mk._flat_ctor | Mathlib.NumberTheory.Height.Basic | {K : Type u_1} →
[inst : Field K] →
(archAbsVal : Multiset (AbsoluteValue K ℝ)) →
(nonarchAbsVal : Set (AbsoluteValue K ℝ)) →
(∀ v ∈ nonarchAbsVal, IsNonarchimedean ⇑v) →
(∀ {x : K}, x ≠ 0 → Function.HasFiniteMulSupport fun v => ↑v x) →
(∀ {x : K}, x ≠ 0 → (Multiset.map (fun x_... | null | false |
Plausible.GenError.ctorIdx | Plausible.Gen | Plausible.GenError → ℕ | null | false |
Lean.Elab.Tactic.Grind.Cache._sizeOf_1 | Lean.Elab.Tactic.Grind.Basic | Lean.Elab.Tactic.Grind.Cache → ℕ | null | false |
Fact.mk | Mathlib.Basic.Logic.Basic | ∀ {p : Prop}, p → Fact p | null | true |
_private.Lean.Meta.Sym.Arith.EvalNum.0.Lean.Meta.Sym.Arith.evalNatCore.match_1 | Lean.Meta.Sym.Arith.EvalNum | (motive : Id (Option ℕ) → Sort u_1) →
(x : Id (Option ℕ)) → ((n : ℕ) → motive (some n)) → ((x : Id (Option ℕ)) → motive x) → motive x | null | false |
Lean.Expr.mapForallBinderNames._f | Mathlib.Lean.Expr.Basic | (x : Lean.Expr) →
Lean.Expr.below (motive := fun x => (Lean.Name → Lean.Name) → Lean.Expr) x → (Lean.Name → Lean.Name) → Lean.Expr | null | false |
Set.chainHeight_coe_univ | Mathlib.Order.Height | ∀ {α : Type u_1} (s : Set α) (r : α → α → Prop), (Set.univ.chainHeight fun x1 x2 => r ↑x1 ↑x2) = s.chainHeight r | null | true |
Valuation.restrict_le_iff_le_embedding | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation R Γ₀)
{x : R} {g : (↑v).ValueGroup₀}, v.restrict x ≤ g ↔ v x ≤ MonoidWithZeroHom.ValueGroup₀.embedding g | null | true |
Lean.Lsp.FileChangeType.recOn | Lean.Data.Lsp.Workspace | {motive : Lean.Lsp.FileChangeType → Sort u} →
(t : Lean.Lsp.FileChangeType) →
motive Lean.Lsp.FileChangeType.Created →
motive Lean.Lsp.FileChangeType.Changed → motive Lean.Lsp.FileChangeType.Deleted → motive t | null | false |
BitVec.getLsbD_succ_last | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x : BitVec (w + 1)), x.getLsbD w = decide (2 ^ w ≤ x.toNat) | null | true |
_private.Mathlib.ModelTheory.Encoding.0.FirstOrder.Language.BoundedFormula.listEncode.match_1.eq_2 | Mathlib.ModelTheory.Encoding | ∀ {L : FirstOrder.Language} {α : Type u_3} (motive : (x : ℕ) → L.BoundedFormula α x → Sort u_4) (x : ℕ)
(t₁ t₂ : L.Term (α ⊕ Fin x)) (h_1 : (n : ℕ) → motive n FirstOrder.Language.BoundedFormula.falsum)
(h_2 : (x : ℕ) → (t₁ t₂ : L.Term (α ⊕ Fin x)) → motive x (FirstOrder.Language.BoundedFormula.equal t₁ t₂))
(h_3 ... | null | true |
CategoryTheory.Pseudofunctor.DescentData'.ofDescentData._proof_13 | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C]
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} {ι : Type u_5} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} (sq : (i j : ι) → CategoryTheory.Limits.ChosenPullback (f i) (f j))
(D : F.DescentData f) (i : ι),
... | null | false |
Composition.reverse_eq_ones | Mathlib.Combinatorics.Enumerative.Composition | ∀ {n : ℕ} {c : Composition n}, c.reverse = Composition.ones n ↔ c = Composition.ones n | null | true |
Lean.Syntax.instForInTopDownOfMonad.match_1 | Lean.Syntax | (motive : Lean.Syntax → Sort u_1) →
(stx : Lean.Syntax) →
((info : Lean.SourceInfo) →
(k : Lean.SyntaxNodeKind) → (args : Array Lean.Syntax) → motive (Lean.Syntax.node info k args)) →
((x : Lean.Syntax) → motive x) → motive stx | null | false |
Array.forIn'_eq_forIn' | Init.Data.Array.Basic | ∀ {α : Type u} {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Monad m], Array.forIn' = forIn' | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.