name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CommRingCat.instCategory._proof_1 | Mathlib.Algebra.Category.Ring.Basic | ∀ {X Y : CommRingCat} (f : X.Hom Y), { hom' := f.hom'.comp { hom' := RingHom.id ↑X }.hom' } = f | null | false |
mul_eq_zero_iff_right | Mathlib.Algebra.GroupWithZero.Defs | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [NoZeroDivisors M₀] {a b : M₀}, b ≠ 0 → (a * b = 0 ↔ a = 0) | null | true |
_private.Mathlib.Tactic.Translate.TagUnfoldBoundary.0.Mathlib.Tactic.Translate.elabInsertCastAux | Mathlib.Tactic.Translate.TagUnfoldBoundary | Lean.Name →
Mathlib.Tactic.Translate.CastKind✝ →
Lean.Term → Mathlib.Tactic.Translate.TranslateData → Lean.Elab.Command.CommandElabM (Lean.Name × Lean.Name) | `elabInsertCastAux` is used to implement the `insert_cast` and `insert_cast_fun` commands.
Given a definition `declName`, we create a casting function and a dual of this casting function.
The casting function is defined using reflexivity/the identity function,
and its translation is defined using the user-provided term... | true |
CategoryTheory.Triangulated.TStructure.isIso_truncLE_map_iff | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} 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]
(t : CategoryT... | null | true |
WithLp.instProdPseudoMetricSpace | Mathlib.Analysis.Normed.Lp.ProdLp | (p : ENNReal) →
(α : Type u_2) →
(β : Type u_3) →
[hp : Fact (1 ≤ p)] → [PseudoMetricSpace α] → [PseudoMetricSpace β] → PseudoMetricSpace (WithLp p (α × β)) | `PseudoMetricSpace` instance on the product of two pseudometric spaces, using the
`L^p` distance, and having as uniformity the product uniformity. | true |
CategoryTheory.Limits.LimitPresentation.changeDiag | Mathlib.CategoryTheory.Limits.Presentation | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : CategoryTheory.Category.{t, w} J] →
{X : C} →
(P : CategoryTheory.Limits.LimitPresentation J X) →
{F : CategoryTheory.Functor J C} → (F ≅ P.diag) → CategoryTheory.Limits.LimitPresentation J X | If `P` is a limit presentation of `X`, it is possible to define another
limit presentation of `X` where `P.diag` is replaced by an isomorphic functor. | true |
Stream'.Seq.cons_not_terminatedAt_zero._simp_1 | Mathlib.Data.Seq.Defs | ∀ {α : Type u} {x : α} {s : Stream'.Seq α}, (Stream'.Seq.cons x s).TerminatedAt 0 = False | null | false |
Denumerable | Mathlib.Logic.Denumerable | Type u_3 → Type u_3 | A denumerable type is (constructively) bijective with `ℕ`. Typeclass equivalent of `α ≃ ℕ`. | true |
Quotient.outRelEmbedding_apply | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} {x : Setoid α} {r : α → α → Prop} (H : ∀ (a₁ b₁ a₂ b₂ : α), a₁ ≈ a₂ → b₁ ≈ b₂ → r a₁ b₁ = r a₂ b₂)
(a : Quotient x), (Quotient.outRelEmbedding H) a = a.out | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.0.Int.reduceDiv._regBuiltin.Int.reduceDiv.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.1894218574._hygCtx._hyg.23 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int | IO Unit | null | false |
ContinuousLinearMap.coprod_apply | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.PiProd | ∀ {R : Type u_1} {M : Type u_3} {M₁ : Type u_5} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : TopologicalSpace M]
[inst_2 : TopologicalSpace M₁] [inst_3 : TopologicalSpace M₂] [inst_4 : AddCommMonoid M] [inst_5 : Module R M]
[inst_6 : ContinuousAdd M] [inst_7 : AddCommMonoid M₁] [inst_8 : Module R M₁] [inst_9 : Add... | null | true |
Std.HashMap.getKey!_union_of_not_mem_left | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.HashMap α β} [inst : Inhabited α] [EquivBEq α]
[LawfulHashable α] {k : α}, k ∉ m₁ → (m₁ ∪ m₂).getKey! k = m₂.getKey! k | null | true |
CategoryTheory.NatTrans.shift_app | Mathlib.CategoryTheory.Shift.CommShift | ∀ {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] {F₁ F₂ : CategoryTheory.Functor C D} (τ : F₁ ⟶ F₂) {A : Type u_5}
[inst_2 : AddMonoid A] [inst_3 : CategoryTheory.HasShift C A] [inst_4 : CategoryTheory.HasShift D A]
[inst_5 : F₁.CommShif... | null | true |
BitVec.toInt_sshiftRight' | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, (x.sshiftRight' y).toInt = x.toInt >>> y.toNat | null | true |
_private.Mathlib.Logic.Denumerable.0.nonempty_denumerable_iff.match_1_1 | Mathlib.Logic.Denumerable | ∀ {α : Type u_1} (motive : Nonempty (Denumerable α) → Prop) (x : Nonempty (Denumerable α)),
(∀ (val : Denumerable α), motive ⋯) → motive x | null | false |
List.TProd.elim'.congr_simp | Mathlib.Data.Prod.TProd | ∀ {ι : Type u} {α : ι → Type v} {l : List ι} {inst : DecidableEq ι} [inst_1 : DecidableEq ι] (h : ∀ (i : ι), i ∈ l)
(v v_1 : List.TProd α l), v = v_1 → ∀ (i : ι), List.TProd.elim' h v i = List.TProd.elim' h v_1 i | null | true |
TopologicalSpace.Opens.map_id_obj | Mathlib.Topology.Category.TopCat.Opens | ∀ {X : TopCat} (U : TopologicalSpace.Opens ↑X),
(TopologicalSpace.Opens.map (CategoryTheory.CategoryStruct.id X)).obj U = U | null | true |
_private.Mathlib.Tactic.NormNum.Ineq.0.Mathlib.Meta.NormNum.evalLT.core.nnratArm | Mathlib.Tactic.NormNum.Ineq | {u : Lean.Level} →
{α : Q(Type u)} →
(lα : Q(LT «$α»)) →
{a b : Q(«$α»)} →
Mathlib.Meta.NormNum.Result a →
Mathlib.Meta.NormNum.Result b →
have e := q(«$a» < «$b»);
Lean.MetaM (Mathlib.Meta.NormNum.Result e) | null | true |
normSeminorm | Mathlib.Analysis.Seminorm | (𝕜 : Type u_3) →
(E : Type u_7) →
[inst : NormedField 𝕜] → [inst_1 : SeminormedAddCommGroup E] → [inst_2 : NormedSpace 𝕜 E] → Seminorm 𝕜 E | The norm of a seminormed group as a seminorm. | true |
_private.Mathlib.Algebra.GroupWithZero.Basic.0.zero_pow.match_1_1 | Mathlib.Algebra.GroupWithZero.Basic | ∀ (motive : (x : ℕ) → x ≠ 0 → Prop) (x : ℕ) (x_1 : x ≠ 0), (∀ (n : ℕ) (x : n + 1 ≠ 0), motive n.succ x) → motive x x_1 | null | false |
CategoryTheory.ShortComplex.Splitting.map | Mathlib.Algebra.Homology.ShortComplex.Exact | {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.Preadditive C] →
[inst_3 : CategoryTheory.Preadditive D] →
{S : CategoryTheory.ShortComplex C} →
S.Splittin... | If a short complex `S` has a splitting and `F` is an additive functor, then
`S.map F` also has a splitting. | true |
Lean.PersistentHashMap.Node.brecOn_3 | Lean.Data.PersistentHashMap | {α : Type u} →
{β : Type v} →
{motive_1 : Lean.PersistentHashMap.Node α β → Sort u_1} →
{motive_2 : Array (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β)) → Sort u_1} →
{motive_3 : List (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β)) → Sort u_1} →
{... | null | false |
_private.Mathlib.Analysis.InnerProductSpace.Reproducing.0.RKHS.isSelfAdjoint_finsuppSum | Mathlib.Analysis.InnerProductSpace.Reproducing | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {X : Type u_2} {V : Type u_3} [inst_1 : NormedAddCommGroup V]
[inst_2 : InnerProductSpace 𝕜 V] [inst_3 : CompleteSpace V] {K : Matrix X X (V →L[𝕜] V)},
K.IsHermitian → ∀ (f : X →₀ V →L[𝕜] V), IsSelfAdjoint (f.sum fun i xi => f.sum fun j xj => star xi * K i j * xj) | null | true |
_private.Init.Data.String.Lemmas.Order.0.String.Pos.le_ofSliceFrom_iff._simp_1_2 | Init.Data.String.Lemmas.Order | ∀ {s : String} {p₀ : s.Pos} {p : (s.sliceFrom p₀).Pos} {q : s.Pos},
(String.Pos.ofSliceFrom p < q) = ∃ (h : p₀ ≤ q), p < p₀.sliceFrom q h | null | false |
MeasureTheory.L1.SimpleFunc.setToL1SCLM.congr_simp | Mathlib.MeasureTheory.Integral.SetToL1 | ∀ (α : Type u_1) (E : Type u_2) {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {m : MeasurableSpace α} (μ : MeasureTheory.Measure α)
{T T_1 : Set α → E →L[ℝ] F} (e_T : T = T_1) {C C_1 : ℝ} (e_C : C = C_1)
(hT : MeasureTheory.Domin... | null | true |
deriv_const_rpow_id | Mathlib.Analysis.SpecialFunctions.Pow.Deriv | ∀ {x a : ℝ}, 0 < a → deriv (fun x => a ^ x) x = Real.log a * a ^ x | null | true |
Subgroup.prod_eq_bot_iff._simp_2 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] {H : Subgroup G} {K : Subgroup N},
(H.prod K = ⊥) = (H = ⊥ ∧ K = ⊥) | null | false |
specializingMap_iff_isClosed_image_closure_singleton | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
Continuous f → (SpecializingMap f ↔ ∀ (x : X), IsClosed (f '' closure {x})) | null | true |
CategoryTheory.MonoidalCategory.tensorHom_def'_assoc | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X₁ Y₁ X₂ Y₂ : C}
(f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂) {Z : C} (h : CategoryTheory.MonoidalCategoryStruct.tensorObj Y₁ Y₂ ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.tensorHom f g) h =
... | null | true |
Module.Basis.traceDual_traceDual | Mathlib.RingTheory.Trace.Basic | ∀ {K : Type u_4} {L : Type u_5} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {ι : Type w}
[inst_3 : FiniteDimensional K L] [inst_4 : Algebra.IsSeparable K L] [inst_5 : Finite ι] [inst_6 : DecidableEq ι]
(b : Module.Basis ι K L), b.traceDual.traceDual = b | null | true |
Lean.Meta.Match.Pattern.val.sizeOf_spec | Lean.Meta.Match.Basic | ∀ (e : Lean.Expr), sizeOf (Lean.Meta.Match.Pattern.val e) = 1 + sizeOf e | null | true |
ValuativeRel.instSemiringWithPreorder._aux_4 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | {R : Type u_1} → [Semiring R] → Zero (ValuativeRel.WithPreorder R) | null | false |
TopologicalSpace.NonemptyCompacts.continuous_singleton | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α], Continuous fun x => {x} | null | true |
MeasureTheory.MemLp.of_fst_of_snd_prodLp | Mathlib.MeasureTheory.SpecificCodomains.WithLp | ∀ {X : Type u_1} {mX : MeasurableSpace X} {μ : MeasureTheory.Measure X} {p q : ENNReal} [inst : Fact (1 ≤ q)]
{E : Type u_2} {F : Type u_3} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedAddCommGroup F]
{f : X → WithLp q (E × F)},
MeasureTheory.MemLp (fun x => (f x).fst) p μ ∧ MeasureTheory.MemLp (fun x => (f x)... | **Alias** of the reverse direction of `MeasureTheory.memLp_prodLp_iff`. | true |
Equiv.completeAtomicBooleanAlgebra._proof_7 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : CompleteAtomicBooleanAlgebra β], e (e.symm ⊤) = ⊤ | null | false |
Subarray.array.eq_1 | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} (xs : Subarray α), xs.array = xs.internalRepresentation.array | null | true |
Delone.DeloneSet.mapIsometry_refl | Mathlib.Analysis.AperiodicOrder.Delone.Basic | ∀ {X : Type u_1} [inst : MetricSpace X] (D : Delone.DeloneSet X),
(Delone.DeloneSet.mapIsometry (IsometryEquiv.refl X)) D = D | null | true |
stalkSkyscraperSheafAdjunction._proof_1 | Mathlib.Topology.Sheaves.Skyscraper | ∀ {X : TopCat} (p₀ : ↑X) [inst : (U : TopologicalSpace.Opens ↑X) → Decidable (p₀ ∈ U)] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] [inst_2 : CategoryTheory.Limits.HasTerminal C]
[inst_3 : CategoryTheory.Limits.HasColimits C] (𝓐 𝓑 : TopCat.Sheaf C X) (f : 𝓐 ⟶ 𝓑),
(CategoryTheory.CategoryStru... | null | false |
Set.inv_mem_center | Mathlib.Algebra.Group.Center | ∀ {M : Type u_1} [inst : DivisionMonoid M] {a : M}, a ∈ Set.center M → a⁻¹ ∈ Set.center M | null | true |
Std.DTreeMap.minKey?_eq_some_iff_getKey?_eq_self_and_forall | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {km : α},
t.minKey? = some km ↔ t.getKey? km = some km ∧ ∀ k ∈ t, (cmp km k).isLE = true | null | true |
Nat.ceil_add_le | Mathlib.Algebra.Order.Floor.Semiring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] [IsStrictOrderedRing R]
(a b : R), ⌈a + b⌉₊ ≤ ⌈a⌉₊ + ⌈b⌉₊ | null | true |
_private.Mathlib.CategoryTheory.Monoidal.Category.0.CategoryTheory.MonoidalCategory.whisker_exchange._simp_1_1 | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C)
{Y₁ Y₂ : C} (f : Y₁ ⟶ Y₂),
CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f =
CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.id X) f | null | false |
QuotientGroup.mulEquivPiModRangePowMonoidHom._proof_1 | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {ι : Type u_1} (A : ι → Type u_2) [inst : (i : ι) → CommGroup (A i)] (n : ℕ), (fun x => ↑(1 x)) = 1 | null | false |
MeasureTheory.Measure.pi.isOpenPosMeasure | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasurableSpace (α i)]
(μ : (i : ι) → MeasureTheory.Measure (α i)) [∀ (i : ι), MeasureTheory.SigmaFinite (μ i)]
[inst_3 : (i : ι) → TopologicalSpace (α i)] [∀ (i : ι), (μ i).IsOpenPosMeasure],
(MeasureTheory.Measure.pi μ).IsOpenPosMeasure | null | true |
LocallyConstant.indicator_of_notMem | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {R : Type u_5} [inst_1 : Zero R] {U : Set X} (f : LocallyConstant X R)
{a : X} (hU : IsClopen U), a ∉ U → (f.indicator hU) a = 0 | null | true |
Lean.Grind.instCommRingUSize._proof_5 | Init.GrindInstances.Ring.UInt | ∀ (n : ℕ) (a : USize), ↑↑n * a = ↑n * a | null | false |
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_srem._proof_1_1 | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} {x : BitVec w}, x.toInt < 0 → 0 ≤ x.toInt → False | null | false |
CategoryTheory.Functor.PreOneHypercoverDenseData.multicospanIndex | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {C₀ : Type u₀} →
{C : Type u} →
[inst : CategoryTheory.Category.{v₀, u₀} C₀] →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C₀ C} →
{A : Type u'} →
[inst_2 : CategoryTheory.Category.{v', u'} A] →
{X : C} →
(data : F.Pre... | The diagram of the multiforks attached to `data : F.PreOneHypercoverDenseData X`. | true |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.step_filterM.match_1.eq_2 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {β : Type u_1} {n : Type u_1 → Type u_2} {f : β → n (ULift.{u_1, 0} Bool)} [inst : MonadAttach n] (out : β)
(motive : Subtype (MonadAttach.CanReturn (f out)) → Sort u_3) (hf : MonadAttach.CanReturn (f out) { down := true })
(h_1 : (hf : MonadAttach.CanReturn (f out) { down := false }) → motive ⟨{ down := false },... | null | true |
Bipointed.swapEquiv_functor_map_toFun | Mathlib.CategoryTheory.Category.Bipointed | ∀ {X Y : Bipointed} (f : X ⟶ Y) (a : X.X), (Bipointed.swapEquiv.functor.map f).toFun a = f.toFun a | null | true |
FormalMultilinearSeries.compChangeOfVariables_blocksFun | Mathlib.Analysis.Analytic.Composition | ∀ (m M N : ℕ) {i : (n : ℕ) × (Fin n → ℕ)} (hi : i ∈ FormalMultilinearSeries.compPartialSumSource m M N) (j : Fin i.fst),
(FormalMultilinearSeries.compChangeOfVariables m M N i hi).snd.blocksFun ⟨↑j, ⋯⟩ = i.snd j | null | true |
Set.infinite_of_finite_compl | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} [Infinite α] {s : Set α}, sᶜ.Finite → s.Infinite | null | true |
Nat.greatestFib.eq_1 | Mathlib.Data.Nat.Fib.Zeckendorf | ∀ (n : ℕ), n.greatestFib = Nat.findGreatest (fun k => Nat.fib k ≤ n) (n + 1) | null | true |
WeierstrassCurve.Δ._proof_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Weierstrass | (7 + 1).AtLeastTwo | null | false |
Real.deriv_arccos | Mathlib.Analysis.SpecialFunctions.Trigonometric.InverseDeriv | deriv Real.arccos = fun x => -(1 / √(1 - x ^ 2)) | null | true |
Algebra.TensorProduct.instNonUnitalRing | Mathlib.RingTheory.TensorProduct.Basic | {R : Type uR} →
{A : Type uA} →
{B : Type uB} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalRing A] →
[inst_2 : Module R A] →
[SMulCommClass R A A] →
[IsScalarTower R A A] →
[inst_5 : NonUnitalSemiring B] →
[inst_6 : Module R B] ... | null | true |
surjOn_Icc_of_monotone_surjective | Mathlib.Order.Interval.Set.SurjOn | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : PartialOrder β] {f : α → β},
Monotone f → Function.Surjective f → ∀ {a b : α}, a ≤ b → Set.SurjOn f (Set.Icc a b) (Set.Icc (f a) (f b)) | null | true |
MeasureTheory.JordanDecomposition.zero_posPart | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | ∀ {α : Type u_1} [inst : MeasurableSpace α], MeasureTheory.JordanDecomposition.posPart 0 = 0 | null | true |
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem._proof_1_14 | Mathlib.Data.List.Triplewise | ∀ {α : Type u_1} (tail : List α) (i j k : ℕ), i < j → j < k → k < tail.length + 1 → i < tail.length | null | false |
QuadraticModuleCat.Hom.mk.injEq | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat | ∀ {R : Type u} [inst : CommRing R] {V W : QuadraticModuleCat R} (toIsometry' toIsometry'_1 : V.form →qᵢ W.form),
({ toIsometry' := toIsometry' } = { toIsometry' := toIsometry'_1 }) = (toIsometry' = toIsometry'_1) | null | true |
MapClusterPt.prodMap | Mathlib.Topology.Constructions | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {α : Type u_5} {β : Type u_6}
{f : α → X} {g : β → Y} {la : Filter α} {lb : Filter β} {x : X} {y : Y},
MapClusterPt x la f → MapClusterPt y lb g → MapClusterPt (x, y) (la ×ˢ lb) (Prod.map f g) | null | true |
Std.ExtDHashMap.mem_inter_iff._simp_1 | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α}, (k ∈ m₁ ∩ m₂) = (k ∈ m₁ ∧ k ∈ m₂) | null | false |
Std.Tactic.BVDecide.Normalize.BitVec.zero_ult' | Std.Tactic.BVDecide.Normalize.BitVec | ∀ {w : ℕ} (a : BitVec w), (0#w).ult a = !a == 0#w | null | true |
GroupExtension.Splitting.semidirectProductMulEquiv | Mathlib.GroupTheory.GroupExtension.Basic | {N : Type u_1} →
{G : Type u_2} →
[inst : Group N] →
[inst_1 : Group G] →
{E : Type u_3} → [inst_2 : Group E] → {S : GroupExtension N E G} → (s : S.Splitting) → N ⋊[s.conjAct] G ≃* E | The group associated to a split extension is isomorphic to a semidirect product. | true |
CompTriple.IsId.rec | Mathlib.Logic.Function.CompTypeclasses | {M : Type u_1} →
{σ : M → M} →
{motive : CompTriple.IsId σ → Sort u} → ((eq_id : σ = id) → motive ⋯) → (t : CompTriple.IsId σ) → motive t | null | false |
_private.Lean.Data.Array.0.Array.mask.match_1 | Lean.Data.Array | {α : Type u_1} →
(motive : Option (α × Subarray α) → Sort u_2) →
(x : Option (α × Subarray α)) →
(Unit → motive none) → ((x : α) → (s' : Subarray α) → motive (some (x, s'))) → motive x | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeftConst.go._unary._proof_3 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (input : aig.RefVec w)
(distance curr : ℕ) (hcurr : curr ≤ w) (s : aig.RefVec curr) (hidx : curr < w) (hdist : ¬curr < distance),
InvImage (fun x1 x2 => x1 < x2)
(fun x => PSigma.casesOn x fun curr hcurr => PSigma.casesOn hc... | null | false |
CategoryTheory.Pi.closedUnit._proof_2 | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type u_2} {C : I → Type u_3} [inst : (i : I) → CategoryTheory.Category.{u_1, u_3} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] [inst_2 : (i : I) → CategoryTheory.MonoidalClosed (C i)]
(X : (i : I) → C i) ⦃X_1 Y : (i : I) → C i⦄ (f : X_1 ⟶ Y),
(CategoryTheory.CategoryStruct.comp ((Categ... | null | false |
DirectSum.instCommRingOfNat._proof_8 | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} [inst : DecidableEq ι] (A : ι → Type u_2) [inst_1 : (i : ι) → AddCommGroup (A i)]
[inst_2 : AddCommMonoid ι] [inst_3 : DirectSum.GCommRing A] (x : ℕ) (x_1 : A 0),
(DirectSum.of A 0) (x • x_1) = x • (DirectSum.of A 0) x_1 | null | false |
neg_add_cancel_comm_assoc | Mathlib.Algebra.Group.Defs | ∀ {G : Type u_1} [inst : AddCommGroup G] (a b : G), -a + (b + a) = b | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.equiv_iff_toList_perm._simp_1_4 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {t t' : Std.DTreeMap.Internal.Impl α β}, t.Equiv t' = t.toListModel.Perm t'.toListModel | null | false |
Set.countable_setOf_finite_subset | Mathlib.Data.Set.Countable | ∀ {α : Type u} {s : Set α}, s.Countable → {t | t.Finite ∧ t ⊆ s}.Countable | The set of finite subsets of a countable set is countable. | true |
CategoryTheory.Pi.μ_def | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type w₁} {C : I → Type u₁} [inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] (i : I) (X Y : (i : I) → C i),
CategoryTheory.Functor.LaxMonoidal.μ (CategoryTheory.Pi.eval C i) X Y =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalC... | null | true |
CategoryTheory.Limits.filtered_colim_preservesFiniteLimits_of_types | Mathlib.CategoryTheory.Limits.FilteredColimitCommutesFiniteLimit | ∀ {K : Type u₂} [inst : CategoryTheory.Category.{v₂, u₂} K] [inst_1 : Small.{v, u₂} K] [CategoryTheory.IsFiltered K],
CategoryTheory.Limits.PreservesFiniteLimits CategoryTheory.Limits.colim | null | true |
_private.Mathlib.Analysis.Convex.PathConnected.0.Path.range_segment._simp_1_1 | Mathlib.Analysis.Convex.PathConnected | ∀ {E : Type u_1} [inst : AddCommGroup E] [inst_1 : Module ℝ E] [inst_2 : TopologicalSpace E] [inst_3 : ContinuousAdd E]
[inst_4 : ContinuousSMul ℝ E] (a b : E) (t : ↑unitInterval), (AffineMap.lineMap a b) ↑t = (Path.segment a b) t | null | false |
LinearMap.coe_restrictScalars | Mathlib.Algebra.Module.LinearMap.Defs | ∀ (R : Type u_1) {S : Type u_5} {M : Type u_8} {M₂ : Type u_10} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R M₂]
[inst_6 : Module S M] [inst_7 : Module S M₂] [inst_8 : LinearMap.CompatibleSMul M M₂ R S] (f : M →ₗ[S] M₂),
... | null | true |
IntervalIntegrable.mono_set | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {ε : Type u_3} [inst : TopologicalSpace ε] [inst_1 : ENormedAddMonoid ε] {f : ℝ → ε} {a b c d : ℝ}
{μ : MeasureTheory.Measure ℝ} [TopologicalSpace.PseudoMetrizableSpace ε],
IntervalIntegrable f μ a b → Set.uIcc c d ⊆ Set.uIcc a b → IntervalIntegrable f μ c d | null | true |
Set.restrict_ite_compl | Mathlib.Data.Set.Restrict | ∀ {α : Type u_1} {β : Type u_2} (f g : α → β) (s : Set α) [inst : (x : α) → Decidable (x ∈ s)],
(sᶜ.restrict fun a => if a ∈ s then f a else g a) = sᶜ.restrict g | null | true |
CategoryTheory.LocalizerMorphism.IsRightDerivabilityStructure.Constructor.fromRightResolution_map | Mathlib.CategoryTheory.Localization.DerivabilityStructure.Constructor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} (Φ : CategoryTheory.LocalizerMorphism W₁ W₂) {D : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, ... | null | true |
descPochhammer_eval_eq_descFactorial | Mathlib.RingTheory.Polynomial.Pochhammer | ∀ (R : Type u) [inst : Ring R] (n k : ℕ), Polynomial.eval (↑n) (descPochhammer R k) = ↑(n.descFactorial k) | null | true |
ONote.NFBelow | Mathlib.SetTheory.Ordinal.Notation | ONote → Ordinal.{0} → Prop | `NFBelow o b` says that `o` is a normal form ordinal notation satisfying `repr o < ω ^ b`. | true |
Option.decidableForallMem._proof_1 | Init.Data.Option.Instances | ∀ {α : Type u_1} {p : α → Prop}, ∀ a ∈ none, p a | null | false |
Units.instDecidableEq | Mathlib.Algebra.Group.Units.Defs | {α : Type u} → [inst : Monoid α] → [DecidableEq α] → DecidableEq αˣ | Units have decidable equality if the base `Monoid` has decidable equality. | true |
_private.Mathlib.Analysis.Complex.Convex.0.Complex.instPathConnectedSpaceUnits._simp_3 | Mathlib.Analysis.Complex.Convex | ∀ {a b : Prop}, (¬(a ∧ b)) = (¬a ∨ ¬b) | null | false |
_private.Plausible.Testable.0.Plausible.instEvalExprConfiguration.evalExpr | Plausible.Testable | Lean.Expr → Lean.MetaM Plausible.Configuration | null | true |
OneHomClass | Mathlib.Algebra.Group.Hom.Defs | (F : Type u_10) → (M : outParam (Type u_11)) → (N : outParam (Type u_12)) → [One M] → [One N] → [FunLike F M N] → Prop | `OneHomClass F M N` states that `F` is a type of one-preserving homomorphisms.
You should extend this typeclass when you extend `OneHom`.
| true |
Std.Do.«term_∧ₚ_» | Std.Do.PostCond | Lean.TrailingParserDescr | Conjunction of postconditions.
This is defined pointwise, as the conjunction of the assertions about the return value and the
conjunctions of the assertions about each potential exception.
| true |
R0Space.closure_singleton | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] [R0Space X] (x : X), closure {x} = (nhds x).ker | null | true |
Fin.val_natCast | Mathlib.Data.Fin.Basic | ∀ (a n : ℕ) [inst : NeZero n], ↑↑a = a % n | null | true |
OneHom.coe_id | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_10} [inst : One M], ⇑(OneHom.id M) = id | null | true |
Lean.Meta.Sym.DSimp.SymDSimpVariantEntry.mk.injEq | Lean.Meta.Sym.DSimp.Variant | ∀ (name : Lean.Name) (variant : Lean.Meta.Sym.DSimp.SymDSimpVariant) (name_1 : Lean.Name)
(variant_1 : Lean.Meta.Sym.DSimp.SymDSimpVariant),
({ name := name, variant := variant } = { name := name_1, variant := variant_1 }) =
(name = name_1 ∧ variant = variant_1) | null | true |
Std.DHashMap.Const.getKey!_unitOfList_of_contains_eq_false | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [EquivBEq α] [LawfulHashable α] [inst : Inhabited α] {l : List α} {k : α},
l.contains k = false → (Std.DHashMap.Const.unitOfList l).getKey! k = default | null | true |
HomologicalComplex.mapBifunctor₁₂.D₁.congr_simp | Mathlib.Algebra.Homology.BifunctorAssociator | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₁₂ : Type u_3} {C₃ : Type u_5} {C₄ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_5} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_6} C₄]
[inst_4 : CategoryTheory.Category.{v_... | null | true |
Finset.SupIndep.le_sup_iff | Mathlib.Order.SupIndep | ∀ {α : Type u_1} {ι : Type u_3} [inst : Lattice α] [inst_1 : OrderBot α] {s t : Finset ι} {f : ι → α} {i : ι},
s.SupIndep f → t ⊆ s → i ∈ s → (∀ (i : ι), f i ≠ ⊥) → (f i ≤ t.sup f ↔ i ∈ t) | null | true |
_private.Mathlib.Dynamics.TopologicalEntropy.CoverEntropy.0.Dynamics.nonempty_inter_of_coverMincard._simp_1_1 | Mathlib.Dynamics.TopologicalEntropy.CoverEntropy | ∀ {α : Type u} {s t : Set α} (x : α), (x ∈ s \ t) = (x ∈ s ∧ x ∉ t) | null | false |
Lean.MessageSeverity.recOn | Lean.Message | {motive : Lean.MessageSeverity → Sort u} →
(t : Lean.MessageSeverity) →
motive Lean.MessageSeverity.information →
motive Lean.MessageSeverity.warning → motive Lean.MessageSeverity.error → motive t | null | false |
_private.Mathlib.MeasureTheory.Integral.Bochner.L1.0.MeasureTheory.SimpleFunc.integral_mono_measure._simp_1_1 | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {f : MeasureTheory.SimpleFunc α β} {p : β → Prop},
(∀ y ∈ f.range, p y) = ∀ (x : α), p (f x) | null | false |
Lean.Meta.Grind.Arith.Cutsat.VarInfo.maxDvdCoeff._default | Lean.Meta.Tactic.Grind.Arith.Cutsat.ReorderVars | ℕ | null | false |
_private.Mathlib.RingTheory.PowerSeries.Derivative.0.PowerSeries.derivativeFun_coe_mul_coe | Mathlib.RingTheory.PowerSeries.Derivative | ∀ {R : Type u_1} [inst : CommSemiring R] (f g : Polynomial R),
(↑f * ↑g).derivativeFun = ↑f * ↑(Polynomial.derivative g) + ↑g * ↑(Polynomial.derivative f) | null | true |
AlgebraicTopology.DoldKan.Γ₀.splitting._proof_3 | Mathlib.AlgebraicTopology.DoldKan.FunctorGamma | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[CategoryTheory.Limits.HasFiniteCoproducts C] (K : ChainComplex C ℕ) (Δ : SimplexCategoryᵒᵖ),
CategoryTheory.Limits.HasColimit
(CategoryTheory.Discrete.functor (CategoryTheory.SimplicialObject.Splitting.summan... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.