name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.MorphismProperty.instHasIsosPrecoverageOfContainsIdentitiesOfRespectsIso | Mathlib.CategoryTheory.Sites.MorphismProperty | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P : CategoryTheory.MorphismProperty C}
[P.ContainsIdentities] [P.RespectsIso], P.precoverage.HasIsos | null | true |
Lean.IR.EmitLLVM.ShouldForwardControlFlow.no.sizeOf_spec | Lean.Compiler.IR.EmitLLVM | sizeOf Lean.IR.EmitLLVM.ShouldForwardControlFlow.no = 1 | null | true |
_private.Mathlib.NumberTheory.Chebyshev.0.Chebyshev.sum_PrimePow_eq_sum_sum'.match_1_3 | Mathlib.NumberTheory.Chebyshev | {x : ℝ} →
{N : ℕ} →
(motive :
(x_1 : ℕ × ℕ) →
x_1 ∈
{x_2 ∈ Finset.Icc 1 N ×ˢ Finset.filter Nat.Prime (Finset.Ioc 0 ⌊x⌋₊) |
match x_2 with
| (k, p) => p ≤ ⌊x ^ (↑k)⁻¹⌋₊} →
Sort u_1) →
(x_1 : ℕ × ℕ) →
(x_2 :
x_1 ∈
... | null | false |
List.getElem?_mapIdx | Init.Data.List.MapIdx | ∀ {α : Type u_1} {α_1 : Type u_2} {f : ℕ → α → α_1} {l : List α} {i : ℕ}, (List.mapIdx f l)[i]? = Option.map (f i) l[i]? | null | true |
Std.Iter.Total | Init.Data.Iterators.Consumers.Total | {α : Type w} → Type w → Type w | A wrapper around an iterator that provides strictly terminating consumers. See
`Iter.ensureTermination`.
| true |
ODE.FunSpace.mk.injEq | Mathlib.Analysis.ODE.PicardLindelof | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] {tmin tmax : ℝ} {t₀ : ↑(Set.Icc tmin tmax)} {x₀ : E} {r L : NNReal}
(toFun : ↑(Set.Icc tmin tmax) → E) (lipschitzWith : LipschitzWith L toFun)
(mem_closedBall₀ : toFun t₀ ∈ Metric.closedBall x₀ ↑r) (toFun_1 : ↑(Set.Icc tmin tmax) → E)
(lipschitzWith_1 : LipschitzWith... | null | true |
_private.Mathlib.Algebra.Order.Group.Synonym.0.OrderDual.instIsRightCancelAdd._proof_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : Add α] [IsRightCancelAdd α], IsRightCancelAdd αᵒᵈ | null | false |
Std.ExtTreeMap.size_filterMap_eq_size_iff | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
{f : α → β → Option γ},
(Std.ExtTreeMap.filterMap f t).size = t.size ↔ ∀ (k : α) (h : k ∈ t), (f (t.getKey k h) t[k]).isSome = true | null | true |
Int16.iSizeMinValue_le_toInt | Init.Data.SInt.Lemmas | ∀ (x : Int16), ISize.minValue.toInt ≤ x.toInt | null | true |
Std.DHashMap.Raw.isSome_getKey?_iff_mem._simp_1 | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {a : α}, ((m.getKey? a).isSome = true) = (a ∈ m) | null | false |
act_rel_of_rel_of_act_rel | Mathlib.Algebra.Order.Monoid.Unbundled.Defs | ∀ {M : Type u_1} {N : Type u_2} {μ : M → N → N} {r : N → N → Prop} [CovariantClass M N μ r] [IsTrans N r] (m : M)
{a b c : N}, r a b → r (μ m b) c → r (μ m a) c | null | true |
Fintype.subtype_card | Mathlib.Data.Fintype.Card | ∀ {α : Type u_1} {p : α → Prop} (s : Finset α) (H : ∀ (x : α), x ∈ s ↔ p x), Fintype.card { x // p x } = s.card | null | true |
isPathConnected_stdSimplex | Mathlib.Analysis.Convex.StdSimplex | ∀ (ι : Type u_1) [inst : Fintype ι] [Nonempty ι], IsPathConnected (stdSimplex ℝ ι) | `stdSimplex ℝ ι` is path connected. | true |
IsDedekindDomain.FiniteAdeleRing.instAlgebra | Mathlib.RingTheory.DedekindDomain.FiniteAdeleRing | (R : Type u_1) →
[inst : CommRing R] →
[inst_1 : IsDedekindDomain R] →
(K : Type u_2) →
[inst_2 : Field K] →
[inst_3 : Algebra R K] → [inst_4 : IsFractionRing R K] → Algebra K (IsDedekindDomain.FiniteAdeleRing R K) | null | true |
HahnSeries.ofFinsupp._proof_1 | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : Zero R], { coeff := ⇑0, isPWO_support' := ⋯ } = 0 | null | false |
AddRightCancelMonoid.toIsRightCancelAdd | Mathlib.Algebra.Group.Monoid | ∀ {M : Type u_2} [self : AddRightCancelMonoid M], IsRightCancelAdd M | null | true |
ContinuousMap.sigmaMk._proof_1 | Mathlib.Topology.ContinuousMap.Basic | ∀ {I : Type u_2} {X : I → Type u_1} [inst : (i : I) → TopologicalSpace (X i)] (i : I), Continuous (Sigma.mk i) | null | false |
CategoryTheory.ComposableArrows.IsComplex.cokerToKer'._proof_22 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{n : ℕ} {S : CategoryTheory.ComposableArrows C (n + 3)},
S.IsComplex →
∀ (k : ℕ) (hk : k ≤ n),
CategoryTheory.CategoryStruct.comp (S.map' (k + 1) (k + 1 + 1) ⋯ ⋯) (S.map' (k + 1 + 1) (k + 1 +... | null | false |
Std.TreeMap.Raw.getElem?_inter_of_not_mem_left | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α}, k ∉ t₁ → (t₁ ∩ t₂)[k]? = none | null | true |
Lean.ScopedEnvExtension.Entry.scoped.inj | Lean.ScopedEnvExtension | ∀ {α : Type} {a : Lean.Name} {a_1 : α} {a_2 : Lean.Name} {a_3 : α},
Lean.ScopedEnvExtension.Entry.scoped a a_1 = Lean.ScopedEnvExtension.Entry.scoped a_2 a_3 → a = a_2 ∧ a_1 = a_3 | null | true |
Std.DTreeMap.Internal.Impl.aux_size_modify | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : Std.LawfulEqOrd α] {k : α} {f : β k → β k}
{t : Std.DTreeMap.Internal.Impl α β}, (Std.DTreeMap.Internal.Impl.modify k f t).size = t.size | null | true |
AddCommGroup.torsion_sum | Mathlib.GroupTheory.Torsion | ∀ {G : Type u_1} {H : Type u_2} [inst : AddCommGroup G] [inst_1 : AddCommGroup H],
AddCommGroup.torsion (G × H) = (AddCommGroup.torsion G).prod (AddCommGroup.torsion H) | null | true |
OrderIso.bddAbove_image | Mathlib.Order.GaloisConnection.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (e : α ≃o β) {s : Set α},
BddAbove (⇑e '' s) ↔ BddAbove s | null | true |
_private.Mathlib.Tactic.DeriveEncodable.0.Mathlib.Deriving.Encodable.S.encode.match_1.splitter | Mathlib.Tactic.DeriveEncodable | (motive : Mathlib.Deriving.Encodable.S✝ → Sort u_1) →
(x : Mathlib.Deriving.Encodable.S✝) →
((n : ℕ) → motive (Mathlib.Deriving.Encodable.S.nat✝ n)) →
((a b : Mathlib.Deriving.Encodable.S✝) → motive (Mathlib.Deriving.Encodable.S.cons✝ a b)) → motive x | null | true |
BitVec.ne_of_lt | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} {x y : BitVec n}, x < y → x ≠ y | null | true |
Equiv.Perm.toList_eq_nil_iff | Mathlib.GroupTheory.Perm.Cycle.Concrete | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {p : Equiv.Perm α} {x : α}, p.toList x = [] ↔ x ∉ p.support | null | true |
Lean.Meta.Grind.Arith.isRelevantPred | Lean.Meta.Tactic.Grind.Arith.IsRelevant | Lean.Expr → Lean.Meta.Grind.GoalM Bool | null | true |
ContMDiff.sumElim | Mathlib.Geometry.Manifold.ContMDiff.Constructions | ∀ {𝕜 : 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] {M' : Type u_16} [inst_6 : TopologicalS... | null | true |
Std.TreeSet.merge | Std.Data.TreeSet.Basic | {α : Type u} → {cmp : α → α → Ordering} → Std.TreeSet α cmp → Std.TreeSet α cmp → Std.TreeSet α cmp | Returns a set that contains all mappings of `t₁` and `t₂.
This function ensures that `t₁` is used linearly.
Hence, as long as `t₁` is unshared, the performance characteristics follow the following imperative
description: Iterate over all mappings in `t₂`, inserting them into `t₁`.
Hence, the runtime of this method sc... | true |
_private.Mathlib.Combinatorics.Graph.Basic.0.Graph.banana_inc._simp_1_2 | Mathlib.Combinatorics.Graph.Basic | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, b ∧ p x) = (b ∧ ∃ x, p x) | null | false |
RegularExpression.map_pow._f | Mathlib.Computability.RegularExpressions | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (P : RegularExpression α) (x : ℕ) (f_1 : Nat.below x),
RegularExpression.map f (P ^ x) = RegularExpression.map f P ^ x | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.insert._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Coalgebra.coassoc | Mathlib.RingTheory.Coalgebra.Basic | ∀ {R : Type u} {A : Type v} {inst : CommSemiring R} {inst_1 : AddCommMonoid A} {inst_2 : Module R A}
[self : Coalgebra R A],
↑(TensorProduct.assoc R A A A) ∘ₗ LinearMap.rTensor A CoalgebraStruct.comul ∘ₗ CoalgebraStruct.comul =
LinearMap.lTensor A CoalgebraStruct.comul ∘ₗ CoalgebraStruct.comul | The comultiplication is coassociative | true |
IsLocalization.Away.coe_liftAlgHom | Mathlib.RingTheory.Localization.Away.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S] {P : Type u_3}
[inst_3 : CommSemiring P] (x : R) [inst_4 : IsLocalization.Away x S] {A : Type u_4} [inst_5 : CommSemiring A]
[inst_6 : Algebra A R] [inst_7 : Algebra A S] [inst_8 : Algebra A P] [inst_9 : IsScala... | null | true |
RootPairing.isSimpleModule_weylGroupRootRep | Mathlib.LinearAlgebra.RootSystem.Irreducible | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [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) [P.IsIrreducible],
IsSimpleModule (MonoidAlgebra R ↥P.weylGroup) P.weylGroupRootRep.asModule | null | true |
Std.LawfulRightIdentity.recOn | Init.Core | {α : Sort u} →
{β : Sort u_1} →
{op : α → β → α} →
{o : β} →
{motive : Std.LawfulRightIdentity op o → Sort u_2} →
(t : Std.LawfulRightIdentity op o) →
([toRightIdentity : Std.RightIdentity op o] → (right_id : ∀ (a : α), op a o = a) → motive ⋯) → motive t | null | false |
_private.Lean.Parser.Term.0.Lean.Parser.Term.borrowed._regBuiltin.Lean.Parser.Term.borrowed_1 | Lean.Parser.Term | IO Unit | null | false |
Lean.Server.FileWorker.SemanticTokensState.mk.sizeOf_spec | Lean.Server.FileWorker.SemanticHighlighting | sizeOf { } = 1 | null | true |
Nat.stirlingFirst_one_right | Mathlib.Combinatorics.Enumerative.Stirling | ∀ (n : ℕ), (n + 1).stirlingFirst 1 = n.factorial | null | true |
CategoryTheory.GrothendieckTopology.OneHypercover.id_h₁ | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C}
(E : J.OneHypercover S) {i j : E.I₀} (x : E.I₁ i j),
(CategoryTheory.CategoryStruct.id E).h₁ x = CategoryTheory.CategoryStruct.id (E.Y x) | null | true |
ModuleCat.instModuleCarrierMkOfSMul' | Mathlib.Algebra.Category.ModuleCat.Basic | {R : Type u} →
[inst : Ring R] → {A : AddCommGrpCat} → (φ : R →+* CategoryTheory.End A) → Module R ↑(ModuleCat.mkOfSMul' φ) | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics.0.isLittleO_exp_neg_mul_rpow_atTop._simp_1_6 | Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
_private.Lean.Meta.Basic.0.Lean.Meta.realizeValue.match_7 | Lean.Meta.Basic | (motive : Option Lean.Meta.RealizeValueResult✝ → Sort u_1) →
(x : Option Lean.Meta.RealizeValueResult✝) →
((res : Lean.Meta.RealizeValueResult✝) → motive (some res)) →
((x : Option Lean.Meta.RealizeValueResult✝) → motive x) → motive x | null | false |
HeytAlg.Hom.recOn | Mathlib.Order.Category.HeytAlg | {X Y : HeytAlg} →
{motive : X.Hom Y → Sort u_1} → (t : X.Hom Y) → ((hom' : HeytingHom ↑X ↑Y) → motive { hom' := hom' }) → motive t | null | false |
Aesop.Options'.ctorIdx | Aesop.Options.Internal | Aesop.Options' → ℕ | null | false |
_private.Mathlib.Tactic.Linarith.Verification.0.Mathlib.Tactic.Linarith.mkLTZeroProof.match_1 | Mathlib.Tactic.Linarith.Verification | (motive : List (Lean.Expr × ℕ) → Sort u_1) →
(x : List (Lean.Expr × ℕ)) →
(Unit → motive []) →
((h : Lean.Expr) → (c : ℕ) → motive [(h, c)]) →
((h : Lean.Expr) → (c : ℕ) → (t : List (Lean.Expr × ℕ)) → motive ((h, c) :: t)) → motive x | null | false |
BinaryTree.right | Mathlib.Data.Tree.Basic | {α : Type u} → BinaryTree α → BinaryTree α | The right child of the tree, or `nil` if the tree is `nil` | true |
Lean.Meta.Grind.AC.getOpId | Lean.Meta.Tactic.Grind.AC.Util | Lean.Meta.Grind.AC.ACM ℕ | null | true |
Multiset.singleton_inj | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {a b : α}, {a} = {b} ↔ a = b | null | true |
Lean.Lsp.instToJsonWorkspaceClientCapabilities | Lean.Data.Lsp.Capabilities | Lean.ToJson Lean.Lsp.WorkspaceClientCapabilities | null | true |
IsBoundedBilinearMap.isBigO' | Mathlib.Analysis.Normed.Operator.BoundedLinearMaps | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : Semiring 𝕜] [inst_1 : SeminormedAddCommGroup E]
[inst_2 : Module 𝕜 E] [inst_3 : SeminormedAddCommGroup F] [inst_4 : Module 𝕜 F] [inst_5 : SeminormedAddCommGroup G]
[inst_6 : Module 𝕜 G] {f : E × F → G}, IsBoundedBilinearMap 𝕜 f → f =O[⊤] fu... | null | true |
Std.WP.EStackEnd | Std.WP.EStack | Type | The last component of an exception postcondition stack. It reduces to `Unit`, so every
`Unit` instance applies. It is a named constant, so only a stack prints as `EStack⟨…⟩`. | true |
_private.Mathlib.NumberTheory.LSeries.Nonvanishing.0.DirichletCharacter.one_lt_re_one_add | Mathlib.NumberTheory.LSeries.Nonvanishing | ∀ {x : ℝ}, 0 < x → ∀ (y : ℝ), 1 < (1 + ↑x).re ∧ 1 < (1 + ↑x + Complex.I * ↑y).re ∧ 1 < (1 + ↑x + 2 * Complex.I * ↑y).re | null | true |
_private.Init.Data.String.Iterator.0.String.Legacy.Iterator.hasNext.eq_1 | Init.Data.String.Iterator | ∀ (s : String) (i : String.Pos.Raw), { s := s, i := i }.hasNext = decide (i.byteIdx < s.rawEndPos.byteIdx) | null | true |
_private.Mathlib.Tactic.Simps.Basic.0.Lean.Meta.mkSimpContextResult._sparseCasesOn_1 | Mathlib.Tactic.Simps.Basic | {motive : Lean.Elab.Tactic.Simp.DischargeWrapper → Sort u} →
(t : Lean.Elab.Tactic.Simp.DischargeWrapper) →
motive Lean.Elab.Tactic.Simp.DischargeWrapper.default → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
IsSemitopologicalSemiring.continuousNeg_of_mul | Mathlib.Topology.Algebra.Ring.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : NonAssocRing R] [SeparatelyContinuousMul R], ContinuousNeg R | If `R` is a ring with a separately continuous multiplication, then negation is continuous as
well since it is just multiplication with `-1`. | true |
PowerSeries.coe_orderHom | Mathlib.RingTheory.PowerSeries.Order | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : NoZeroDivisors R] [inst_2 : Nontrivial R],
⇑PowerSeries.orderHom = PowerSeries.order | null | true |
Finset.Ico_diff_Ico_left | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : LocallyFiniteOrder α] (a b c : α),
Finset.Ico a b \ Finset.Ico a c = Finset.Ico (max a c) b | **Alias** of `Finset.Ico_sdiff_Ico_left`. | true |
GrpCat.groupObj._aux_3 | Mathlib.Algebra.Category.Grp.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_2, u_3} J] →
(F : CategoryTheory.Functor J GrpCat) → (j : J) → Mul ((F.comp (CategoryTheory.forget GrpCat)).obj j) | null | false |
CategoryTheory.ShortComplex.exact_of_f_is_kernel | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(S : CategoryTheory.ShortComplex C) (hS : CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.KernelFork.ofι S.f ⋯))
[S.HasHomology], S.Exact | null | true |
CoxeterSystem.map_simple | Mathlib.GroupTheory.Coxeter.Basic | ∀ {B : Type u_1} {W : Type u_3} {H : Type u_4} [inst : Group W] [inst_1 : Group H] {M : CoxeterMatrix B}
(cs : CoxeterSystem M W) (e : W ≃* H) (i : B), (cs.map e).simple i = e (cs.simple i) | null | true |
ENNReal.mul_inv_le_one | Mathlib.Basic.ENNReal.Inv | ∀ (a : ENNReal), a * a⁻¹ ≤ 1 | null | true |
Lean.Order.le_meet_of_eq | Std.Internal.Order.Lemmas | ∀ {l : Type uₗ} [inst : Lean.Order.CompleteLattice l] {P Q R T : l},
T = Lean.Order.meet Q R →
Lean.Order.PartialOrder.rel P Q → Lean.Order.PartialOrder.rel P R → Lean.Order.PartialOrder.rel P T | null | true |
Std.DHashMap.Raw.Const.get_unitOfList | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {l : List α} {k : α} {h : k ∈ Std.DHashMap.Raw.Const.unitOfList l},
Std.DHashMap.Raw.Const.get (Std.DHashMap.Raw.Const.unitOfList l) k h = () | null | true |
WeierstrassCurve._sizeOf_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Weierstrass | {R : Type u} → [SizeOf R] → WeierstrassCurve R → ℕ | null | false |
Std.Async.ETask.bind | Std.Async.Basic | {ε α β : Type} →
Std.Async.ETask ε α →
(α → Std.Async.ETask ε β) → optParam Task.Priority Task.Priority.default → optParam Bool false → Std.Async.ETask ε β | Creates a new `ETask` that will run after `x` has completed. If `x`:
- errors, return an `ETask` that resolves to the error.
- succeeds, run `f` on the result of `x` and return the `ETask` produced by `f`.
| true |
Codisjoint.eq_top_of_le | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderTop α] {a b : α}, Codisjoint a b → b ≤ a → a = ⊤ | null | true |
Array.find?_range_eq_some._simp_1 | Init.Data.Array.Range | ∀ {n i : ℕ} {p : ℕ → Bool},
(Array.find? p (Array.range n) = some i) = (p i = true ∧ i ∈ Array.range n ∧ ∀ j < i, (!p j) = true) | null | false |
CategoryTheory.NatTrans.IsMonoidal.hcomp | Mathlib.CategoryTheory.Monoidal.NaturalTransformation | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D] {E : Type u₃}
[inst_4 : CategoryTheory.Category.{v₃, u₃} E] [inst_5 : CategoryTheory.MonoidalCategory E]
... | null | true |
Aesop.Script.LazyStep.postGoals | Aesop.Script.Step | Aesop.Script.LazyStep → Array Lean.MVarId | null | true |
ContinuousMap.instSemigroupWithZeroOfContinuousMul | Mathlib.Topology.ContinuousMap.Algebra | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] → [inst_2 : SemigroupWithZero β] → [ContinuousMul β] → SemigroupWithZero C(α, β) | null | true |
IsLocalizedModule.map_surjective._simp_1 | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (S : Submonoid R) {M : Type u_2} {M' : Type u_3} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M'] [inst_3 : Module R M] [inst_4 : Module R M'] (f : M →ₗ[R] M')
[inst_5 : IsLocalizedModule S f] {N : Type u_6} {N' : Type u_7} [inst_6 : AddCommMonoid N] [inst_7 : AddCommM... | null | false |
IsPrimitiveRoot.integralPowerBasisOfPrimePow.eq_1 | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {p k : ℕ} {K : Type u} [inst : Field K] {ζ : K} [hp : Fact (Nat.Prime p)] [inst_1 : CharZero K]
[inst_2 : IsCyclotomicExtension {p ^ k} ℚ K] (hζ : IsPrimitiveRoot ζ (p ^ k)),
hζ.integralPowerBasisOfPrimePow = (Algebra.adjoin.powerBasis' ⋯).map hζ.adjoinEquivRingOfIntegersOfPrimePow | null | true |
_private.Mathlib.CategoryTheory.WithTerminal.Cone.0.CategoryTheory.WithTerminal.id.match_1.eq_1 | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u_1} (motive : CategoryTheory.WithTerminal C → Sort u_2) (a : C)
(h_1 : (a : C) → motive (CategoryTheory.WithTerminal.of a)) (h_2 : Unit → motive CategoryTheory.WithTerminal.star),
(match CategoryTheory.WithTerminal.of a with
| CategoryTheory.WithTerminal.of a => h_1 a
| CategoryTheory.WithTermi... | null | true |
Subgroup.commutator | Mathlib.GroupTheory.Commutator.Basic | {G : Type u_1} → [inst : Group G] → Bracket (Subgroup G) (Subgroup G) | The commutator of two subgroups `H₁` and `H₂`. | true |
Submodule.tensorSpanEquivSpan._proof_1 | Mathlib.LinearAlgebra.Span.TensorProduct | ∀ (A : Type u_1) [inst : CommSemiring A], RingHomCompTriple (RingHom.id A) (RingHom.id A) (RingHom.id A) | null | false |
ContinuousLinearMap.opNNNorm_mul_flip_apply | Mathlib.Analysis.CStarAlgebra.Unitization | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NonUnitalNormedRing E]
[inst_2 : StarRing E] [NormedStarGroup E] [inst_4 : NormedSpace 𝕜 E] [inst_5 : IsScalarTower 𝕜 E E]
[inst_6 : SMulCommClass 𝕜 E E] [RegularNormedAlgebra 𝕜 E] (a : E), ‖(ContinuousLinearMap.mul 𝕜 E).flip a‖₊ = ... | null | true |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.IsTopologicalBasis.compacts._proof_1_12 | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α] (K : TopologicalSpace.Compacts α) (w : Set (Set α)),
(¬∀ W ∈ w, (↑K ∩ W).Nonempty) → ∀ W ∈ {W | W ∈ w ∧ (↑K ∩ W).Nonempty}, (↑K ∩ W).Nonempty | null | false |
Mathlib.Tactic.Bicategory.StructuralOfExpr_bicategoricalComp | Mathlib.Tactic.CategoryTheory.Bicategory.Datatypes | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b : B} {f g h i : a ⟶ b}
[inst_1 : CategoryTheory.BicategoricalCoherence g h] (η : f ⟶ g) (η' : f ≅ g),
η'.hom = η →
∀ (θ : h ⟶ i) (θ' : h ≅ i),
θ'.hom = θ → (CategoryTheory.bicategoricalIsoComp η' θ').hom = CategoryTheory.bicategoricalComp η θ | null | true |
_private.Plausible.Tactic.0._aux_Plausible_Tactic___elabRules_plausibleSyntax_1.match_6 | Plausible.Tactic | (motive : Array Lean.FVarId × Lean.MVarId → Sort u_1) →
(x : Array Lean.FVarId × Lean.MVarId) → ((fst : Array Lean.FVarId) → (g : Lean.MVarId) → motive (fst, g)) → motive x | null | false |
_private.Batteries.Data.Float.Lemmas.0.Float.Model.UnpackedFloat.isNaNBits_packedNaN._simp_1_4 | Batteries.Data.Float.Lemmas | ∀ {p : Prop} {x : Decidable p}, (decide p = false) = ¬p | null | false |
_private.Lean.Compiler.LCNF.JoinPoints.0.Lean.Compiler.LCNF.JoinPointContextExtender.extend.go._unsafe_rec | Lean.Compiler.LCNF.JoinPoints | Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure →
Lean.Compiler.LCNF.JoinPointContextExtender.ExtendM (Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) | null | false |
CategoryTheory.ObjectProperty.tStructure._proof_8 | Mathlib.CategoryTheory.Triangulated.TStructure.Induced | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(P : CategoryT... | null | false |
HomogeneousLocalization.NumDenSameDeg.instCommMonoid._proof_5 | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | ∀ {ι : Type u_1} {A : Type u_2} {σ : Type u_3} [inst : CommRing A] [inst_1 : SetLike σ A]
[inst_2 : AddSubmonoidClass σ A] {𝒜 : ι → σ} (x : Submonoid A) [inst_3 : AddCommMonoid ι] [inst_4 : DecidableEq ι]
[inst_5 : GradedRing 𝒜] (x_1 : HomogeneousLocalization.NumDenSameDeg 𝒜 x), x_1 * 1 = x_1 | null | false |
Rack.toEnvelGroup.mapAux.eq_2 | Mathlib.Algebra.Quandle | ∀ {R : Type u_1} [inst : Rack R] {G : Type u_2} [inst_1 : Group G] (f : ShelfHom R (Quandle.Conj G)) (x_1 : R),
Rack.toEnvelGroup.mapAux f (Rack.PreEnvelGroup.incl x_1) = f x_1 | null | true |
ContinuousMonoidHom.mk._flat_ctor | Mathlib.Topology.Algebra.ContinuousMonoidHom | {A : Type u_2} →
{B : Type u_3} →
[inst : Monoid A] →
[inst_1 : Monoid B] →
[inst_2 : TopologicalSpace A] →
[inst_3 : TopologicalSpace B] →
(toFun : A → B) →
toFun 1 = 1 →
(∀ (x y : A), toFun (x * y) = toFun x * toFun y) →
autoPar... | null | false |
_private.Mathlib.Combinatorics.Matroid.Rank.Cardinal.0.Matroid.rankFinite_iff_cRank_lt_aleph0.match_1_1 | Mathlib.Combinatorics.Matroid.Rank.Cardinal | ∀ {α : Type u_1} {M : Matroid α} (motive : M.RankFinite → Prop) (h : M.RankFinite),
(∀ (B : Set α) (hB : M.IsBase B) (fin : B.Finite), motive ⋯) → motive h | null | false |
ProbabilityTheory.covarianceBilinDual_apply | Mathlib.Probability.Moments.CovarianceBilinDual | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] {mE : MeasurableSpace E} {μ : MeasureTheory.Measure E}
[inst_1 : NormedSpace ℝ E] [inst_2 : BorelSpace E] [CompleteSpace E] [MeasureTheory.IsFiniteMeasure μ],
MeasureTheory.MemLp id 2 μ →
∀ (L₁ L₂ : StrongDual ℝ E),
((ProbabilityTheory.covarianceBilinDual μ) ... | null | true |
SSet.Subcomplex.Pairing.op._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Op | ∀ {X : SSet} {A : X.Subcomplex} (P : A.Pairing),
⇑SSet.Subcomplex.N.opEquiv ⁻¹' P.I ∩ ⇑SSet.Subcomplex.N.opEquiv ⁻¹' P.II = ∅ | null | false |
StateTransition.EvalsTo.mk | Mathlib.Computability.StateTransition | {σ : Type u_1} →
{f : σ → Option σ} →
{a : σ} → {b : Option σ} → (steps : ℕ) → (flip bind f)^[steps] (some a) = b → StateTransition.EvalsTo f a b | null | true |
Real.nonempty_algEquiv_or | Mathlib.Analysis.Complex.Polynomial.Basic | ∀ (F : Type u_1) [inst : Field F] [inst_1 : Algebra ℝ F] [Algebra.IsAlgebraic ℝ F],
Nonempty (F ≃ₐ[ℝ] ℝ) ∨ Nonempty (F ≃ₐ[ℝ] ℂ) | An algebraic extension of ℝ is isomorphic to either ℝ or ℂ as an ℝ-algebra. | true |
deriv_fun_mul | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {𝔸 : Type u_3} [inst_1 : NormedRing 𝔸]
[inst_2 : NormedAlgebra 𝕜 𝔸] {c d : 𝕜 → 𝔸},
DifferentiableAt 𝕜 c x → DifferentiableAt 𝕜 d x → deriv (fun y => c y * d y) x = deriv c x * d x + c x * deriv d x | null | true |
TopCat.Presheaf.SheafConditionPairwiseIntersections.coneEquivUnitIsoApp | Mathlib.Topology.Sheaves.SheafCondition.EqualizerProducts | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasProducts C] →
{X : TopCat} →
(F : TopCat.Presheaf C X) →
{ι : Type v'} →
(U : ι → TopologicalSpace.Opens ↑X) →
(c : CategoryTheory.Limits.Cone ((CategoryTheory.Pairwise.d... | Implementation of `SheafConditionPairwiseIntersections.coneEquiv`. | true |
Graph.IsSubgraph.isLoopAt_congr | Mathlib.Combinatorics.Graph.Subgraph | ∀ {α : Type u_1} {β : Type u_2} {x : α} {e : β} {G H : Graph α β},
H ≤ G → e ∈ H.edgeSet → (H.IsLoopAt e x ↔ G.IsLoopAt e x) | null | true |
_private.Std.Data.DHashMap.Internal.RawLemmas.0.Std.DHashMap.Internal.Raw₀.Const.mem_toArray_iff_get?_eq_some._simp_1_1 | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β),
Std.DHashMap.Raw.Const.toArray ↑m = (Std.DHashMap.Raw.Const.toList ↑m).toArray | null | false |
Lean.Parser.«command_Builtin_cbv_simproc_decl_(_):=_» | Init.CbvSimproc | Lean.ParserDescr | null | true |
Aesop.Script.LazyStep.tacticBuilders_ne._autoParam | Aesop.Script.Step | Lean.Syntax | null | false |
CategoryTheory.NonPreadditiveAbelian.monoIsKernelOfCokernel | Mathlib.CategoryTheory.Abelian.NonPreadditive | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.NonPreadditiveAbelian C] →
{X Y : C} →
{f : X ⟶ Y} →
[CategoryTheory.Mono f] →
(s : CategoryTheory.Limits.Cofork f 0) →
CategoryTheory.Limits.IsColimit s →
Category... | In a `NonPreadditiveAbelian` category, a mono is the kernel of its cokernel. More precisely:
If `f` is a monomorphism and `s` is some colimit cokernel cocone on `f`, then `f` is a kernel
of `Cofork.π s`. | true |
Set.mul_subset_mul | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Mul α] {s₁ s₂ t₁ t₂ : Set α}, s₁ ⊆ t₁ → s₂ ⊆ t₂ → s₁ * s₂ ⊆ t₁ * t₂ | null | true |
CategoryTheory.Functor.CoreMonoidal.toOplaxMonoidal._proof_4 | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D} (h : F.CoreMonoidal) (x : C),
(CategoryTheory.MonoidalCategoryStr... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.