name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Subsemiring.mk'._proof_4 | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R] (s : Set R) (sa : AddSubmonoid R), ↑sa = s → 0 ∈ s | null | false |
deriv_fun_pow | Mathlib.Analysis.Calculus.Deriv.Pow | ∀ {𝕜 : Type u_1} {𝔸 : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedCommRing 𝔸]
[inst_2 : NormedAlgebra 𝕜 𝔸] {f : 𝕜 → 𝔸} {x : 𝕜},
DifferentiableAt 𝕜 f x → ∀ (n : ℕ), deriv (fun i => f i ^ n) x = ↑n * f x ^ (n - 1) * deriv f x | Eta-expanded form of `deriv_pow` | true |
Int.Cooper.mul_resolve_left_inv_le | Init.Data.Int.Cooper | ∀ {b q : ℤ} (a p k : ℤ), 0 < a → b * k + b * p ≤ a * q → a ∣ k + p → b * Int.Cooper.resolve_left_inv a p k ≤ q | null | true |
CategoryTheory.ProjectiveResolution.isoLeftDerivedToHomotopyCategoryObj | Mathlib.CategoryTheory.Abelian.LeftDerived | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type u_1} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] →
[inst_2 : CategoryTheory.Abelian C] →
[inst_3 : CategoryTheory.HasProjectiveResolutions C] →
[inst_4 : CategoryTheory.Abelian D] →
{X : C}... | If `P : ProjectiveResolution Z` and `F : C ⥤ D` is an additive functor, this is
an isomorphism between `F.leftDerivedToHomotopyCategory.obj X` and the complex
obtained by applying `F` to `P.complex`. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.IsCycle.snd_ne_penultimate._proof_1_1 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u_1} {G : SimpleGraph V} {u : V} {p : G.Walk u u}, 3 ≤ p.length → 1 ≤ p.length | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.mem_toList_iff_getKey?_eq_some_and_get?_eq_some._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
Real.sigmoid_pos | Mathlib.Analysis.SpecialFunctions.Sigmoid | ∀ (x : ℝ), 0 < x.sigmoid | null | true |
_private.Mathlib.Algebra.Category.MonCat.Basic.0.AddCommMonCat.Hom.mk.noConfusion | Mathlib.Algebra.Category.MonCat.Basic | {A B : AddCommMonCat} →
{P : Sort u_1} → {hom' hom'' : ↑A →+ ↑B} → { hom' := hom' } = { hom' := hom'' } → (hom' ≍ hom'' → P) → P | null | false |
monotoneOn_univ._simp_1 | Mathlib.Order.Monotone.Defs | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β}, MonotoneOn f Set.univ = Monotone f | null | false |
_private.Init.Data.List.Nat.Sublist.0.List.append_sublist_of_sublist_right._proof_1_1 | Init.Data.List.Nat.Sublist | ∀ {α : Type u_1} {xs ys zs : List α}, zs.length ≤ ys.length → xs.length + ys.length ≤ zs.length → ¬xs.length = 0 → False | null | false |
CategoryTheory.Functor.IsDenseSubsite.sheafEquiv | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
(J : CategoryTheory.GrothendieckTopology C) →
(K : CategoryTheory.GrothendieckTopology D) →
(G : CategoryTheory.Functor C D) →
(A : ... | If `G : C ⥤ D` exhibits `(C, J)` as a dense subsite of `(D, K)`, and the
pushforward functor `Sheaf K A ⥤ Sheaf J A` is an equivalence, then this
is the equivalence `Sheaf K A ≌ Sheaf J A`. | true |
Std.DHashMap.mem_toArray_iff_get?_eq_some | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [inst : LawfulBEq α] {k : α}
{v : β k}, ⟨k, v⟩ ∈ m.toArray ↔ m.get? k = some v | null | true |
Module.AEval.restrict_equiv_mapSubmodule._proof_3 | Mathlib.Algebra.Polynomial.Module.AEval | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(p : Submodule R M), IsScalarTower R R ↥p | null | false |
Mathlib.Meta.NormNum.IsNNRat.to_eq | Mathlib.Tactic.NormNum.Result | ∀ {α : Type u_1} [inst : DivisionSemiring α] {n d : ℕ} {a n' d' : α},
Mathlib.Meta.NormNum.IsNNRat a n d → ↑n = n' → ↑d = d' → a = n' / d' | null | true |
Lean.Meta.Grind.instInhabitedEMatchTheoremConstraint | Lean.Meta.Tactic.Grind.Extension | Inhabited Lean.Meta.Grind.EMatchTheoremConstraint | null | true |
_private.Mathlib.Tactic.Linter.FlexibleLinter.0.Mathlib.Linter.Flexible.TacticData.mk.sizeOf_spec | Mathlib.Tactic.Linter.FlexibleLinter | ∀ (stx : Lean.Syntax) (ci : Lean.Elab.ContextInfo) (mctxBefore mctxAfter : Lean.MetavarContext)
(goalsTargetedBy goalsCreatedBy : List Lean.MVarId),
sizeOf
{ stx := stx, ci := ci, mctxBefore := mctxBefore, mctxAfter := mctxAfter, goalsTargetedBy := goalsTargetedBy,
goalsCreatedBy := goalsCreatedBy } =... | null | true |
smul_add_smul_le_smul_add_smul | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : Semiring α] [inst_1 : PartialOrder α] [IsStrictOrderedRing α] [ExistsAddOfLE α]
[inst_4 : AddCommMonoid β] [inst_5 : PartialOrder β] [IsOrderedCancelAddMonoid β] [inst_7 : Module α β]
[PosSMulMono α β] {a₁ a₂ : α} {b₁ b₂ : β}, a₁ ≤ a₂ → b₁ ≤ b₂ → a₁ • b₂ + a₂ • b₁ ≤ a₁ • b₁ +... | Binary **rearrangement inequality**. | true |
_private.Lean.Meta.Tactic.Grind.MatchCond.0.Lean.Meta.Grind.collectMatchCondLhss._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.MatchCond | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Quaternion.coe_real_complex_mul | Mathlib.Analysis.Quaternion | ∀ (r : ℝ) (z : ℂ), r • ↑z = ↑r * ↑z | null | true |
IsLocalization.instForallPiUniv | Mathlib.RingTheory.Localization.Pi | ∀ {ι : Type u_1} (R : ι → Type u_2) (S : ι → Type u_3) [inst : (i : ι) → CommSemiring (R i)]
[inst_1 : (i : ι) → CommSemiring (S i)] [inst_2 : (i : ι) → Algebra (R i) (S i)] (M : (i : ι) → Submonoid (R i))
[∀ (i : ι), IsLocalization (M i) (S i)], IsLocalization (Submonoid.pi Set.univ M) ((i : ι) → S i) | If `S i` is a localization of `R i` at the submonoid `M i` for each `i`,
then `Π i, S i` is a localization of `Π i, R i` at the product submonoid. | true |
Homotopy.nullHomotopicMap'_f_eq_zero | Mathlib.Algebra.Homology.Homotopy | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ι} {C D : HomologicalComplex V c} {k₀ : ι},
(∀ (l : ι), ¬c.Rel k₀ l) →
(∀ (l : ι), ¬c.Rel l k₀) → ∀ (h : (i j : ι) → c.Rel j i → (C.X i ⟶ D.X j)), (Homotopy.nullHomotopicMap' h).f k₀... | null | true |
IsLocalization.AtPrime.coe_orderIsoOfPrime_symm_apply_coe | Mathlib.RingTheory.Localization.AtPrime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (S : Type u_2) [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (I : Ideal R)
[hI : I.IsPrime] [inst_3 : IsLocalization.AtPrime S I] (a : { p // p.IsPrime ∧ p ≤ I }),
↑↑((RelIso.symm (IsLocalization.AtPrime.orderIsoOfPrime S I)) a) =
⋂ s,
⋂ (_ :
↑↑((OrderIs... | null | true |
List.subset_dedup | Mathlib.Data.List.Dedup | ∀ {α : Type u_1} [inst : DecidableEq α] (l : List α), l ⊆ l.dedup | null | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound.0.Std.Tactic.BVDecide.LRAT.Internal.addEmptyCaseSound._proof_1_3 | Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound | ∀ {α : Type u_2} {β : Type u_1} {σ : Type u_3} [inst : Std.Tactic.BVDecide.LRAT.Internal.Clause α β]
[inst_1 : Std.Tactic.BVDecide.LRAT.Internal.Entails α σ] [inst_2 : Std.Tactic.BVDecide.LRAT.Internal.Formula α β σ]
(f : σ),
Std.Tactic.BVDecide.LRAT.Internal.Clause.empty ∈
Std.Tactic.BVDecide.LRAT.Internal.F... | null | false |
Subring.topologicalClosure._proof_3 | Mathlib.Topology.Algebra.Ring.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : Ring R] [inst_2 : IsSemitopologicalRing R] (S : Subring R)
{a b : R}, a ∈ S.topologicalClosure.carrier → b ∈ S.topologicalClosure.carrier → a * b ∈ S.topologicalClosure.carrier | null | false |
USize.ofFin_mk | Init.Data.UInt.Lemmas | ∀ {n : ℕ} (hn : n < USize.size), USize.ofFin ⟨n, hn⟩ = USize.ofNatLT n hn | null | true |
LawfulBitraversable.binaturality' | Mathlib.Control.Bitraversable.Basic | ∀ {t : Type u → Type u → Type u} {inst : Bitraversable t} [self : LawfulBitraversable t] {F G : Type u → Type u}
[inst_1 : Applicative F] [inst_2 : Applicative G] [LawfulApplicative F] [LawfulApplicative G]
(η : ApplicativeTransformation F G) {α α' β β' : Type u} (f : α → F β) (f' : α' → F β'),
(fun {α} => η.app ... | null | true |
Localization.eq_1 | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : CommMonoid M] (S : Submonoid M), Localization S = OreLocalization S M | null | true |
Finsupp.fst_sumFinsuppAddEquivProdFinsupp | Mathlib.Data.Finsupp.Basic | ∀ {M : Type u_5} [inst : AddMonoid M] {α : Type u_12} {β : Type u_13} (f : α ⊕ β →₀ M) (x : α),
(Finsupp.sumFinsuppAddEquivProdFinsupp f).1 x = f (Sum.inl x) | null | true |
List.scanrM_map | Init.Data.List.Scan.Lemmas | ∀ {m : Type u_1 → Type u_2} {α₁ : Type u_3} {α₂ : Type u_4} {β : Type u_1} {init : β} [inst : Monad m] [LawfulMonad m]
{f : α₁ → α₂} {g : α₂ → β → m β} {as : List α₁},
List.scanrM g init (List.map f as) = List.scanrM (fun a b => g (f a) b) init as | null | true |
_private.Lean.Meta.Tactic.Grind.Order.Proof.0.Lean.Meta.Grind.Order.mkPropagateSelfEqFalseProofCore | Lean.Meta.Tactic.Grind.Order.Proof | Lean.Expr → Lean.Meta.Grind.Order.OrderM Lean.Expr | null | true |
Std.TreeMap.Raw.instCoeWFWFInner | Std.Data.TreeMap.Raw.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → {t : Std.TreeMap.Raw α β cmp} → Coe t.WF t.inner.WF | null | true |
Representation.linearize._proof_2 | Mathlib.RepresentationTheory.Action | ∀ (k : Type u_1) (G : Type u_3) [inst : Monoid G] [inst_1 : Semiring k] (X : Action (Type u_2) G) (x x_1 : G),
Finsupp.lmapDomain k k ⇑(CategoryTheory.ConcreteCategory.hom (X.ρ (x * x_1))) =
Finsupp.lmapDomain k k ⇑(CategoryTheory.ConcreteCategory.hom (X.ρ x)) *
Finsupp.lmapDomain k k ⇑(CategoryTheory.Concr... | null | false |
_private.Init.Data.String.Lemmas.Pattern.Memcmp.0.String.Slice.Pattern.Internal.memcmpStr_eq_true_iff._proof_1_8 | Init.Data.String.Lemmas.Pattern.Memcmp | ∀ {lhs rhs : String} {lstart rstart : String.Pos.Raw} {len : String.Pos.Raw} (curr : String.Pos.Raw),
¬len.byteIdx < curr.byteIdx → ¬len.byteIdx = curr.byteIdx + (len.byteIdx - curr.byteIdx) → False | null | false |
NNReal.iSup_div | Mathlib.Data.NNReal.Basic | ∀ {ι : Sort u_3} (f : ι → NNReal) (a : NNReal), (⨆ i, f i) / a = ⨆ i, f i / a | null | true |
SeminormedAddCommGroup.toIsTopologicalAddGroup | Mathlib.Analysis.Normed.Group.Uniform | ∀ {E : Type u_2} [inst : SeminormedAddCommGroup E], IsTopologicalAddGroup E | null | true |
_private.Lean.Elab.Tactic.Do.Spec.0.Lean.Elab.Tactic.Do.dischargeMGoal | Lean.Elab.Tactic.Do.Spec | {n : Type → Type} →
[Monad n] → [MonadLiftT Lean.MetaM n] → Lean.Elab.Tactic.Do.ProofMode.MGoal → Lean.Name → Bool → n Lean.Expr | null | true |
List.dropWhile_eq_self_iff | Mathlib.Data.List.TakeWhile | ∀ {α : Type u_1} {p : α → Bool} {l : List α}, List.dropWhile p l = l ↔ ∀ (hl : 0 < l.length), ¬p l[0] = true | null | true |
FirstOrder.Language.BoundedFormula.realize_relabel._simp_1 | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {β : Type v'} {m n : ℕ}
{φ : L.BoundedFormula α n} {g : α → β ⊕ Fin m} {v : β → M} {xs : Fin (m + n) → M},
(FirstOrder.Language.BoundedFormula.relabel g φ).Realize v xs =
φ.Realize (Sum.elim v (xs ∘ Fin.castAdd n) ∘ g) (xs ∘ Fin.natAd... | null | false |
map_mem_separableClosure_iff | Mathlib.FieldTheory.SeparableClosure | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {K : Type w} [inst_3 : Field K]
[inst_4 : Algebra F K] (i : E →ₐ[F] K) {x : E}, i x ∈ separableClosure F K ↔ x ∈ separableClosure F E | If `i` is an `F`-algebra homomorphism from `E` to `K`, then `i x` is contained in
`separableClosure F K` if and only if `x` is contained in `separableClosure F E`. | true |
UInt32.toBitVec_toUInt8 | Init.Data.UInt.Lemmas | ∀ (n : UInt32), n.toUInt8.toBitVec = BitVec.setWidth 8 n.toBitVec | null | true |
_private.Lean.Elab.Tactic.Do.ProofMode.Basic.0.Lean.Elab.Tactic.Do.ProofMode.elabMStop._regBuiltin.Lean.Elab.Tactic.Do.ProofMode.elabMStop_1 | Lean.Elab.Tactic.Do.ProofMode.Basic | IO Unit | null | false |
Aesop.PostponedSafeRule.mk._flat_ctor | Aesop.Tree.UnsafeQueue | Aesop.SafeRule → Aesop.RuleTacOutput → Aesop.PostponedSafeRule | null | false |
AddGroupSeminorm.toSeminormedAddGroup._proof_1 | Mathlib.Analysis.Normed.Group.Defs | ∀ {E : Type u_1} [inst : AddGroup E] (f : AddGroupSeminorm E) (x : E), f (-x + x) = 0 | null | false |
CategoryTheory.instHasLimitsInd | Mathlib.CategoryTheory.Limits.Indization.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasLimits C],
CategoryTheory.Limits.HasLimits (CategoryTheory.Ind C) | null | true |
List.map_zip_eq_zipWith | Init.Data.List.Zip | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α × β → γ} {l : List α} {l' : List β},
List.map f (l.zip l') = List.zipWith (Function.curry f) l l' | null | true |
Matrix.kroneckerTMulAlgEquiv_symm_apply | Mathlib.RingTheory.MatrixAlgebra | ∀ {m : Type u_2} {n : Type u_3} (R : Type u_5) (S : Type u_6) {A : Type u_7} {B : Type u_8} [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : Fintype n]
[inst_6 : DecidableEq n] [inst_7 : CommSemiring S] [inst_8 : Algebra R S] [inst_9 : Algeb... | null | true |
tendsto_fib_succ_div_fib_atTop | Mathlib.Analysis.SpecificLimits.Fibonacci | Filter.Tendsto (fun n => ↑(Nat.fib (n + 1)) / ↑(Nat.fib n)) Filter.atTop (nhds Real.goldenRatio) | The limit of `fib (n + 1) / fib n` as `n → ∞` is the golden ratio. | true |
CommGroup.subgroupOrderIsoSubgroupMonoidHom.eq_1 | Mathlib.GroupTheory.FiniteAbelian.Duality | ∀ (G : Type u_1) (M : Type u_2) [inst : CommGroup G] [inst_1 : Finite G] [inst_2 : CommMonoid M]
[hM : HasEnoughRootsOfUnity M (Monoid.exponent G)],
CommGroup.subgroupOrderIsoSubgroupMonoidHom G M =
{ toFun := fun H => OrderDual.toDual (MonoidHom.restrictHom H Mˣ).ker,
invFun := fun Φ =>
(CommGrou... | null | true |
Nat.lcm_eq_mul_iff | Init.Data.Nat.Lcm | ∀ {m n : ℕ}, m.lcm n = m * n ↔ m = 0 ∨ n = 0 ∨ m.gcd n = 1 | null | true |
Nat.choose_lt_pow | Mathlib.Data.Nat.Choose.Bounds | ∀ {n k : ℕ}, n ≠ 0 → 2 ≤ k → n.choose k < n ^ k | null | true |
String.Slice.SplitIterator.instIteratorIdSubslice.eq_1 | Init.Data.String.Slice | ∀ {ρ : Type} {σ : String.Slice → Type}
[inst : (s : String.Slice) → Std.Iterator (σ s) Id (String.Slice.Pattern.SearchStep s)] {pat : ρ}
[inst_1 : String.Slice.Pattern.ToForwardSearcher pat σ] {s : String.Slice},
String.Slice.SplitIterator.instIteratorIdSubslice =
{
IsPlausibleStep := fun x x_1 =>
... | null | true |
CategoryTheory.Limits.WidePushoutShape.struct._proof_5 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type u_1} {Z : CategoryTheory.Limits.WidePushoutShape J}, Z = Z | null | false |
CategoryTheory.Functor.copyObj.eq_1 | Mathlib.CategoryTheory.NatIso | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) (obj : C → D) (e : (X : C) → F.obj X ≅ obj X),
F.copyObj obj e =
{ obj := obj,
map := fun {X Y} f =>
CategoryTheory.CategoryStruct.comp (e X).inv... | null | true |
Basis.le_span'' | Mathlib.LinearAlgebra.Dimension.StrongRankCondition | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [RankCondition R]
{ι : Type u_2} [inst_4 : Fintype ι] (b : Module.Basis ι R M) {w : Set M} [inst_5 : Fintype ↑w],
Submodule.span R w = ⊤ → Fintype.card ι ≤ Fintype.card ↑w | An auxiliary lemma for `Basis.le_span`.
If `R` satisfies the rank condition,
then for any finite basis `b : Basis ι R M`,
and any finite spanning set `w : Set M`,
the cardinality of `ι` is bounded by the cardinality of `w`.
| true |
Module.Baer.extensionOfMaxAdjoin._proof_2 | Mathlib.Algebra.Module.Injective | ∀ {R : Type u_2} [inst : Ring R] {Q : Type u_1} [inst_1 : AddCommGroup Q] [inst_2 : Module R Q] {M : Type u_3}
{N : Type u_4} [inst_3 : AddCommGroup M] [inst_4 : AddCommGroup N] [inst_5 : Module R M] [inst_6 : Module R N]
(i : M →ₗ[R] N) (f : M →ₗ[R] Q) [inst_7 : Fact (Function.Injective ⇑i)] (h : Module.Baer R Q) ... | null | false |
BitVec.forall_zero_iff | Init.Data.BitVec.Decidable | ∀ {P : BitVec 0 → Prop}, (∀ (v : BitVec 0), P v) ↔ P 0#0 | null | true |
_private.Mathlib.Topology.DiscreteSubset.0.isClosed_and_discrete_iff._simp_1_1 | Mathlib.Topology.DiscreteSubset | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = (a ⊓ b = ⊥) | null | false |
Subspace.orderIsoFiniteCodimDim._proof_2 | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_1} {V : Type u_2} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
(W : { W // FiniteDimensional K ↥W }ᵒᵈ), FiniteDimensional K (V ⧸ Submodule.dualCoannihilator ↑(OrderDual.ofDual W)) | null | false |
Lean.Compiler.LCNF.instBEqParam.beq | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.Param pu → Lean.Compiler.LCNF.Param pu → Bool | null | true |
List.Vector.get_replicate | Mathlib.Data.Vector.Basic | ∀ {α : Type u_1} {n : ℕ} (a : α) (i : Fin n), (List.Vector.replicate n a).get i = a | null | true |
_private.Mathlib.Data.Seq.Parallel.0.Computation.parallel.aux1.eq_1 | Mathlib.Data.Seq.Parallel | ∀ {α : Type u} (l : List (Computation α)) (S : Stream'.WSeq (Computation α)),
Computation.parallel.aux1✝ (l, S) =
Computation.rmap
(fun l' =>
match Stream'.Seq.destruct S with
| none => (l', Stream'.Seq.nil)
| some (none, S') => (l', S')
| some (some c, S') => (c :: l', S'))
... | null | true |
Int.sign_eq_neg_one_iff_neg | Init.Data.Int.Order | ∀ {a : ℤ}, a.sign = -1 ↔ a < 0 | null | true |
ULift.seminormedRing | Mathlib.Analysis.Normed.Ring.Basic | {α : Type u_2} → [SeminormedRing α] → SeminormedRing (ULift.{u_5, u_2} α) | null | true |
TensorProduct.AlgebraTensorModule.congr_symm_tmul | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type uR} {A : Type uA} {M : Type uM} {N : Type uN} {P : Type uP} {Q : Type uQ} [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M]
[inst_6 : IsScalarTower R A M] [inst_7 : AddCommMonoid N] [inst_8 : Module R N] [inst_9 : ... | null | true |
_private.Mathlib.RingTheory.QuasiFinite.Basic.0.Algebra.QuasiFinite.of_isIntegral_of_finiteType._simp_1_2 | Mathlib.RingTheory.QuasiFinite.Basic | ∀ (R : Type u) (S : Type v) (A : Type w) [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] (x : R),
(algebraMap S A) ((algebraMap R S) x) = (algebraMap R A) x | null | false |
CategoryTheory.Triangulated.SpectralObject.recOn | Mathlib.CategoryTheory.Triangulated.SpectralObject | {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.Limits.HasZeroObject C] →
[inst_3 : CategoryTheory.HasShift C ℤ] →
[inst_4 : CategoryTheory.Preadditive C] →
... | null | false |
ISize.toInt_inj | Init.Data.SInt.Lemmas | ∀ {x y : ISize}, x.toInt = y.toInt ↔ x = y | null | true |
CategoryTheory.ChosenPullbacksAlong.isoInv_pullback_obj_left | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {Y X : C} (f : Y ≅ X) (Z : CategoryTheory.Over Y),
((CategoryTheory.ChosenPullbacksAlong.pullback f.inv).obj Z).left = Z.left | null | true |
List.min?_eq_none_iff._simp_1 | Init.Data.List.MinMax | ∀ {α : Type u_1} {xs : List α} [inst : Min α], (xs.min? = none) = (xs = []) | null | false |
Lean.Elab.Term.wrapAsyncAsSnapshot | Lean.Elab.Term.TermElabM | {α : Type} →
(α → Lean.Elab.TermElabM Unit) →
Option IO.CancelToken →
autoParam String Lean.Elab.Term.wrapAsyncAsSnapshot._auto_1 →
Lean.Elab.TermElabM (α → BaseIO Lean.Language.SnapshotTree) | Wraps the given action for use in `BaseIO.asTask` etc., discarding its final state except for
`logSnapshotTask` tasks, which are reported as part of the returned tree. The given cancellation
token, if any, should be stored in a `SnapshotTask` for the server to trigger it when the result is
no longer needed.
| true |
_private.Mathlib.Order.Cover.0.WithTop.coe_wcovBy_top._simp_1_2 | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, Set.Ioo ↑a ⊤ = WithTop.some '' Set.Ioi a | null | false |
Std.DTreeMap.Internal.Impl.balanceLErase._proof_14 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (rs : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner rs k v l r).Balanced →
∀ (ls : ℕ) (lk : α) (lv : β lk),
Std.DTreeMap.Internal.delta * rs < ls →
∀ (x : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Int... | null | false |
Mathlib.Tactic.Sat.Clause.expr | Mathlib.Tactic.Sat.FromLRAT | Mathlib.Tactic.Sat.Clause → Lean.Expr | The clause expression of type `Clause` | true |
_private.Mathlib.LinearAlgebra.Prod.0.Submodule.map_inl._simp_1_7 | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {M' : Type u_8}
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] {p : Submodule R M} {q : Submodule R M'} {x : M × M'},
(x ∈ p.prod q) = (x.1 ∈ p ∧ x.2 ∈ q) | null | false |
AddMonoidHom.ext_nat | Mathlib.Algebra.Group.Nat.Hom | ∀ {A : Type u_2} [inst : AddZeroClass A] {f g : ℕ →+ A}, f 1 = g 1 → f = g | null | true |
_private.Mathlib.Algebra.ContinuedFractions.Computation.Translations.0.Option.getD.match_1.eq_2 | Mathlib.Algebra.ContinuedFractions.Computation.Translations | ∀ {α : Type u_1} (motive : Option α → Sort u_2) (h_1 : (x : α) → motive (some x)) (h_2 : Unit → motive none),
(match none with
| some x => h_1 x
| none => h_2 ()) =
h_2 () | null | true |
Real.Angle.abs_toReal_coe_eq_self_iff | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ : ℝ}, |(↑θ).toReal| = θ ↔ 0 ≤ θ ∧ θ ≤ Real.pi | null | true |
_private.Mathlib.AlgebraicTopology.ModelCategory.FibrantObjectHomotopy.0.HomotopicalAlgebra.FibrantObject.instHasQuotientWeakEquivalencesHomRel._simp_1 | Mathlib.AlgebraicTopology.ModelCategory.FibrantObjectHomotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C],
HomotopicalAlgebra.weakEquivalences C f = HomotopicalAlgebra.WeakEquivalence f | null | false |
_private.Mathlib.Data.Option.Basic.0.Option.iget_of_mem.match_1_1 | Mathlib.Data.Option.Basic | ∀ {α : Type u_1} {a : α} (motive : (x : Option α) → a ∈ x → Prop) (x : Option α) (x_1 : a ∈ x),
(∀ (a_1 : Unit), motive (some a) ⋯) → motive x x_1 | null | false |
Complex.measurableEquivRealProd | Mathlib.MeasureTheory.Measure.Lebesgue.Complex | ℂ ≃ᵐ ℝ × ℝ | Measurable equivalence between `ℂ` and `ℝ × ℝ`. | true |
_private.Mathlib.Data.ENat.Pow.0.ENat.epow_top._proof_1_3 | Mathlib.Data.ENat.Pow | ¬⊤ < ⊤ | null | false |
Std.TreeSet.getD_max? | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {km fallback : α},
t.max? = some km → t.getD km fallback = km | null | true |
Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLetI___1 | Init.Tactics | Lean.Macro | `letI` behaves like `let`, but inlines the value instead of producing a `let` term. | false |
CategoryTheory.Under.instHasColimitsOfSizeOfHasWidePushouts | Mathlib.CategoryTheory.Limits.Constructions.Over.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {B : C} [CategoryTheory.Limits.HasWidePushouts C],
CategoryTheory.Limits.HasColimitsOfSize.{w, w, v, max u v} (CategoryTheory.Under B) | null | true |
Polynomial.divModByMonicAux.congr_simp | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} [inst : Ring R] (_p _p_1 : Polynomial R),
_p = _p_1 → ∀ {q q_1 : Polynomial R} (e_q : q = q_1) (a : q.Monic), _p.divModByMonicAux a = _p_1.divModByMonicAux ⋯ | null | true |
List.infix_append' | Init.Data.List.Sublist | ∀ {α : Type u_1} (l₁ l₂ l₃ : List α), l₂ <:+: l₁ ++ (l₂ ++ l₃) | null | true |
_private.Mathlib.Probability.Kernel.IonescuTulcea.Maps.0.IocProdIoc_preimage._proof_1_15 | Mathlib.Probability.Kernel.IonescuTulcea.Maps | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : LocallyFiniteOrder ι] {a b c : ι} (hab : a ≤ b) (w : ι) (w_1 : b < w)
(w_2 : w ≤ c), ↑⟨w, ⋯⟩ ∈ Finset.Ioc b c | null | false |
summable_of_hasFiniteSupport | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α}
{L : SummationFilter β} [L.HasSupport], Function.HasFiniteSupport f → Summable f L | null | true |
SetLike.GradeZero.instRing._aux_6 | Mathlib.Algebra.DirectSum.Internal | {ι : Type u_3} →
{σ : Type u_2} →
{R : Type u_1} →
[inst : Ring R] →
[inst_1 : AddMonoid ι] →
[inst_2 : SetLike σ R] → [AddSubgroupClass σ R] → (A : ι → σ) → [SetLike.GradedMonoid A] → ℤ → ↥(A 0) | null | false |
LinearMap.re_inner_adjoint_mul_self_nonneg | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : FiniteDimensional 𝕜 E] (T : E →ₗ[𝕜] E) (x : E), 0 ≤ RCLike.re (inner 𝕜 x ((LinearMap.adjoint T * T) x)) | The Gram operator T†T is a positive operator. | true |
Algebra.norm_eq_of_ringEquiv | Mathlib.RingTheory.Norm.Basic | ∀ {A : Type u_8} {B : Type u_9} {C : Type u_10} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Ring C]
[inst_3 : Algebra A C] [inst_4 : Algebra B C] (e : A ≃+* B),
(algebraMap B C).comp ↑e = algebraMap A C → ∀ (x : C), e ((Algebra.norm A) x) = (Algebra.norm B) x | null | true |
Std.Time.Modifier.ctorElimType | Std.Time.Format.Basic | {motive : Std.Time.Modifier → Sort u} → ℕ → Sort (max 1 u) | null | false |
Lean.IR.Decl.ctorElim | Lean.Compiler.IR.Basic | {motive : Lean.IR.Decl → Sort u} →
(ctorIdx : ℕ) → (t : Lean.IR.Decl) → ctorIdx = t.ctorIdx → Lean.IR.Decl.ctorElimType ctorIdx → motive t | null | false |
instIsPredArchimedeanOrderDualOfIsSuccArchimedean | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] [IsSuccArchimedean α], IsPredArchimedean αᵒᵈ | null | true |
MulEquiv.val_piUnits_apply | Mathlib.Algebra.Group.Pi.Units | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] (f : ((i : ι) → M i)ˣ) (i : ι),
↑(MulEquiv.piUnits f i) = ↑f i | null | true |
_private.Lean.Elab.PatternVar.0.Lean.Elab.Term.CollectPatternVars.collect.processId.match_1 | Lean.Elab.PatternVar | (motive : Option Lean.ConstantInfo → Sort u_1) →
(x : Option Lean.ConstantInfo) →
((val : Lean.ConstructorVal) → motive (some (Lean.ConstantInfo.ctorInfo val))) →
((val : Lean.ConstantInfo) → motive (some val)) → (Unit → motive none) → motive x | null | false |
Equiv.isCancelAdd | Mathlib.Algebra.Group.TransferInstance | ∀ {α : Type u_2} {β : Type u_3} (e : α ≃ β) [inst : Add β] [IsCancelAdd β], IsCancelAdd α | Transfer `IsCancelAdd` across an `Equiv` | true |
_private.Mathlib.Topology.UniformSpace.Closeds.0.UniformSpace.hausdorff.uniformContinuous_union.match_1_1 | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} (U : Set (α × α)) (a : (Set α × Set α) × Set α × Set α)
(motive : a ∈ entourageProd (hausdorffEntourage U) (hausdorffEntourage U) → Prop)
(h : a ∈ entourageProd (hausdorffEntourage U) (hausdorffEntourage U)),
(∀ (h₁ : (a.1.1, a.2.1) ∈ hausdorffEntourage U) (h₂ : (a.1.2, a.2.2) ∈ hausdorffEntourag... | null | false |
_private.Mathlib.Tactic.Linter.FindDeprecations.0.Mathlib.Tactic.rewriteOneFile.match_7 | Mathlib.Tactic.Linter.FindDeprecations | (motive : List String.Pos.Raw → Sort u_1) →
(x : List String.Pos.Raw) →
((a b _c : String.Pos.Raw) → motive [a, b, _c]) → ((x : List String.Pos.Raw) → motive x) → motive x | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.