name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.Do.Spec.Iter.forIn_filterMap | Std.Do.Triple.SpecLemmas | ∀ {α β β₂ γ : Type w} [inst : Std.Iterator α Id β] {ps : Std.Do.PostShape} {n : Type w → Type u_1} [inst_1 : Monad n]
[LawfulMonad n] [inst_3 : Std.Do.WPMonad n ps] [Std.Iterators.Finite α Id] [inst_5 : Std.IteratorLoop α Id n]
[Std.LawfulIteratorLoop α Id n] {it : Std.Iter β} {f : β → Option β₂} {init : γ} {g : β₂... | null | true |
Submodule.span | Mathlib.LinearAlgebra.Span.Defs | (R : Type u_1) →
{M : Type u_2} → [inst : Semiring R] → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → Set M → Submodule R M | The span of a set `s ⊆ M` is the smallest submodule of M that contains `s`. | true |
_private.Init.Data.String.Lemmas.Pattern.String.Basic.0.String.Slice.Pattern.Model.ForwardSliceSearcher.isLongestRevMatchAt_iff_extract._simp_1_3 | Init.Data.String.Lemmas.Pattern.String.Basic | ∀ {s : String.Slice} {l r : s.Pos}, (l ≤ r) = (l.offset ≤ r.offset) | null | false |
Std.Iterators.Types.StepSizeIterator.instIterator._proof_1 | Std.Data.Iterators.Combinators.Monadic.StepSize | ∀ {α : Type u_1} {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Std.Iterator α m β] (it : Std.IterM m β)
(s : Std.PlausibleIterStep (Std.IterM.IsPlausibleNthOutputStep it.internalState.nextIdx it.internalState.inner)),
Std.IterM.IsPlausibleNthOutputStep it.internalState.nextIdx it.internalState.inner
(Std.Ite... | null | false |
CategoryTheory.ShortComplex.LeftHomologyData.map | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | {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.Limits.HasZeroMorphisms C] →
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] →
{S : CategoryTheory.ShortComplex C} →
... | When a left homology data `h` of a short complex `S` is preserved by a functor `F`,
this is the induced left homology data `h.map F` for the short complex `S.map F`. | true |
Lean.Data.Trie.node1.elim | Lean.Data.Trie | {α : Type} →
{motive_1 : Lean.Data.Trie α → Sort u} →
(t : Lean.Data.Trie α) →
t.ctorIdx = 1 →
((a : Option α) → (a_1 : UInt8) → (a_2 : Lean.Data.Trie α) → motive_1 (Lean.Data.Trie.node1 a a_1 a_2)) →
motive_1 t | null | false |
Algebra.Generators.cotangentRestrict._proof_1 | Mathlib.RingTheory.Extension.Cotangent.Basic | ∀ {R : Type u_1} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {ι : Type u_2}
(P : Algebra.Generators R S ι), SMulCommClass R P.toExtension.Ring P.toExtension.Ring | null | false |
Lean.Meta.DiscrTree.fold | Lean.Meta.DiscrTree.Util | {σ : Type u_1} → {α : Type} → (σ → Array Lean.Meta.DiscrTree.Key → α → σ) → σ → Lean.Meta.DiscrTree α → σ | Fold over the keys and values stored in a `DiscrTree`
| true |
CategoryTheory.MorphismProperty.HasQuotient.recOn | Mathlib.CategoryTheory.MorphismProperty.Quotient | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{W : CategoryTheory.MorphismProperty C} →
{homRel : HomRel C} →
[inst_1 : CategoryTheory.HomRel.IsStableUnderPrecomp homRel] →
[inst_2 : CategoryTheory.HomRel.IsStableUnderPostcomp homRel] →
{motive : W.HasQuotien... | null | false |
CategoryTheory.Functor.OplaxMonoidal.ofBifunctor.secondMap₂_app_app_app | Mathlib.CategoryTheory.Monoidal.Multifunctor | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{v_2, u_2} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D}
(δ : CategoryTheory.MonoidalCategory.curriedTensorPost F ⟶ Catego... | null | true |
CategoryTheory.GradedObject.Monoidal.pentagon_inv_assoc | Mathlib.CategoryTheory.GradedObject.Monoidal | ∀ {I : Type u} [inst : AddMonoid I] {C : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} C]
[inst_2 : CategoryTheory.MonoidalCategory C] (X₁ X₂ X₃ X₄ : CategoryTheory.GradedObject I C)
[inst_3 : X₁.HasTensor X₂] [inst_4 : X₂.HasTensor X₃] [inst_5 : X₃.HasTensor X₄]
[inst_6 : (CategoryTheory.GradedObject.Mo... | null | true |
LinearMap.isCompl_iSup_ker_pow_iInf_range_pow | Mathlib.RingTheory.Artinian.Module | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [IsArtinian R M]
[IsNoetherian R M] (f : M →ₗ[R] M), IsCompl (⨆ n, (f ^ n).ker) (⨅ n, (f ^ n).range) | This is the Fitting decomposition of the module `M` with respect to the endomorphism `f`.
See also `LinearMap.eventually_isCompl_ker_pow_range_pow` for an alternative spelling. | true |
Ordinal.type_le_iff' | Mathlib.SetTheory.Ordinal.Basic | ∀ {α β : Type u_1} {r : α → α → Prop} {s : β → β → Prop} [inst : IsWellOrder α r] [inst_1 : IsWellOrder β s],
Ordinal.type r ≤ Ordinal.type s ↔ Nonempty (r ↪r s) | null | true |
_private.Mathlib.Algebra.Star.Pointwise.0.Set.star_mul._simp_1_1 | Mathlib.Algebra.Star.Pointwise | ∀ {α : Type u_1} {s : Set α} [inst : InvolutiveStar α], star s = star '' s | null | false |
BoundedContinuousFunction.extend._proof_2 | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u_3} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β] {δ : Type u_1}
[inst_2 : TopologicalSpace δ] [DiscreteTopology δ] (f : α ↪ δ) (g : BoundedContinuousFunction α β)
(h : BoundedContinuousFunction δ β), Continuous (Function.extend ⇑f ⇑g ⇑h) | null | false |
_private.Mathlib.Computability.PartrecBasis.0.Nat.Partrec'.rfindOpt._simp_1_3 | Mathlib.Computability.PartrecBasis | ∀ {α : Type u_1} {β : Type u_2} {f : Part α} {g : α → Part β} {b : β}, (b ∈ f.bind g) = ∃ a ∈ f, b ∈ g a | null | false |
Std.DTreeMap.Raw.getKey?_inter | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α}, (t₁ ∩ t₂).getKey? k = if t₂.contains k = true then t₁.getKey? k else none | null | true |
_private.Init.Data.String.Iterator.0.String.Legacy.Iterator.foldUntil.eq_def | Init.Data.String.Iterator | ∀ {α : Type u_1} (it : String.Legacy.Iterator) (init : α) (f : α → Char → Option α),
it.foldUntil init f =
if it.atEnd = true then (init, it)
else
match f init it.curr with
| some a => it.next.foldUntil a f
| x => (init, it) | null | true |
_private.Mathlib.Data.Set.Image.0.Set.image_comp_image._proof_1_1 | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} {f : α → β} {g : β → γ}, Set.image g ∘ Set.image f = Set.image (g ∘ f) | null | false |
_private.Mathlib.Tactic.DefEqAbuse.0.Lean.MessageData.visitWithAndAscendM._auto_3 | Mathlib.Tactic.DefEqAbuse | Lean.Syntax | null | false |
selfAdjoint.instIntCastSubtypeMemAddSubgroup | Mathlib.Algebra.Star.SelfAdjoint | {R : Type u_1} → [inst : Ring R] → [inst_1 : StarRing R] → IntCast ↥(selfAdjoint R) | null | true |
MeasureTheory.Measure.finiteSpanningSetsIn_volumeIoiPow_range_Iio | Mathlib.MeasureTheory.Constructions.HaarToSphere | (n : ℕ) → (MeasureTheory.Measure.volumeIoiPow n).FiniteSpanningSetsIn (Set.range Set.Iio) | The intervals `(0, k + 1)` have finite measure `MeasureTheory.Measure.volumeIoiPow _`
and cover the whole open ray `(0, +∞)`. | true |
StarMulEquiv.toMulEquiv_symm | Mathlib.Algebra.Star.MonoidHom | ∀ {A : Type u_2} {B : Type u_3} [inst : Mul A] [inst_1 : Mul B] [inst_2 : Star A] [inst_3 : Star B] (f : A ≃⋆* B),
f.symm.toMulEquiv = f.symm | null | true |
SummationFilter.HasSupport | Mathlib.Topology.Algebra.InfiniteSum.SummationFilter | {β : Type u_2} → SummationFilter β → Prop | Typeclass asserting that the sets in `L.filter` are eventually contained in `L.support`. This
is a sufficient condition for `L`-summation to behave well on finitely-supported functions: every
finitely-supported `f` is `L`-summable with the sum `∑ᶠ x ∈ L.support, f x` (and similarly for
products). | true |
PowerSeries.IsWeierstrassFactorization.degree_eq_coe_lift_order_map | Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | ∀ {A : Type u_1} [inst : CommRing A] [inst_1 : IsLocalRing A] {g : PowerSeries A} {f : Polynomial A} {h : PowerSeries A}
(H : g.IsWeierstrassFactorization f h), f.degree = ↑(((PowerSeries.map (IsLocalRing.residue A)) g).order.lift ⋯) | null | true |
instMetricSpaceEmpty | Mathlib.Topology.MetricSpace.Defs | MetricSpace Empty | null | true |
Quaternion.expSeries_even_of_imaginary | Mathlib.Analysis.Normed.Algebra.QuaternionExponential | ∀ {q : Quaternion ℝ},
q.re = 0 →
∀ (n : ℕ),
((NormedSpace.expSeries ℝ (Quaternion ℝ) (2 * n)) fun x => q) = ↑((-1) ^ n * ‖q‖ ^ (2 * n) / ↑(2 * n).factorial) | The even terms of `expSeries` are real, and correspond to the series for $\cos ‖q‖$. | true |
CommRingCat.Under.instPreservesLimitsOfShapeUnderWalkingParallelPairTensorProdOfFlatCarrier | Mathlib.Algebra.Category.Ring.Under.Limits | ∀ {R S : CommRingCat} [inst : Algebra ↑R ↑S] [Module.Flat ↑R ↑S],
CategoryTheory.Limits.PreservesLimitsOfShape CategoryTheory.Limits.WalkingParallelPair (R.tensorProd S) | null | true |
_private.Mathlib.MeasureTheory.VectorMeasure.BoundedVariation.0.BoundedVariationOn.variation_vectorMeasure_Ioi._simp_1_2 | Mathlib.MeasureTheory.VectorMeasure.BoundedVariation | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (Set.Ioc b a ⊆ Set.Ioi b) = True | null | false |
Lean.instInhabitedLiteral.default | Lean.Expr | Lean.Literal | null | true |
MonoidHom.toMulEquiv_symm_apply | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : MulOneClass M] [inst_1 : MulOneClass N] (f : M →* N) (g : N →* M)
(h₁ : g.comp f = MonoidHom.id M) (h₂ : f.comp g = MonoidHom.id N), ⇑(f.toMulEquiv g h₁ h₂).symm = ⇑g | null | true |
Mathlib.Tactic.Echelon.DecompositionCert.rec | Mathlib.Tactic.Echelon.Cert | {u : Lean.Level} →
{m n : ℕ} →
{α : Q(Type u)} →
{rα : Q(CommRing «$α»)} →
{A : Q(Matrix (Fin «$m») (Fin «$n») «$α»)} →
{motive : Mathlib.Tactic.Echelon.DecompositionCert rα A → Sort u} →
((L : Mathlib.Tactic.Echelon.ListMatrixLit α m m) →
(σ : Q(Equiv.Perm (Fin... | null | false |
equicontinuousWithinAt_finite | Mathlib.Topology.UniformSpace.Equicontinuity | ∀ {ι : Type u_1} {X : Type u_3} {α : Type u_6} [tX : TopologicalSpace X] [uα : UniformSpace α] [Finite ι]
{F : ι → X → α} {S : Set X} {x₀ : X}, EquicontinuousWithinAt F S x₀ ↔ ∀ (i : ι), ContinuousWithinAt (F i) S x₀ | null | true |
_private.Lean.Meta.Match.Match.0.Lean.Meta.Match.MatcherKey.mk.sizeOf_spec | Lean.Meta.Match.Match | ∀ (value : Lean.Expr) (compile isPrivate : Bool),
sizeOf { value := value, compile := compile, isPrivate := isPrivate } =
1 + sizeOf value + sizeOf compile + sizeOf isPrivate | null | true |
ContinuousMap.starMul._proof_1 | Mathlib.Topology.ContinuousMap.Star | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Mul β]
[inst_3 : ContinuousMul β] [inst_4 : StarMul β] [inst_5 : ContinuousStar β] (x x_1 : C(α, β)),
star (x * x_1) = star x_1 * star x | null | false |
SimpleGraph.Walk.getLast_support | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | ∀ {V : Type u} {G : SimpleGraph V} {a b : V} (p : G.Walk a b), p.support.getLast ⋯ = b | null | true |
CategoryTheory.Limits.BinaryBicone.IsBilimit.isColimit | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{P Q : C} →
{b : CategoryTheory.Limits.BinaryBicone P Q} → b.IsBilimit → CategoryTheory.Limits.IsColimit b.toCocone | Structure witnessing that a binary bicone is a limit cone and a limit cocone. | true |
Filter.comk._proof_3 | Mathlib.Order.Filter.Defs | ∀ {α : Type u_1} (p : Set α → Prop),
(∀ (t : Set α), p t → ∀ s ⊆ t, p s) → ∀ {x y : Set α}, x ∈ {t | p tᶜ} → x ⊆ y → p yᶜ | null | false |
TrivSqZeroExt.instL1NormedRing._proof_3 | Mathlib.Analysis.Normed.Algebra.TrivSqZeroExt | ∀ {R : Type u_1} {M : Type u_2} [inst : NormedRing R] [inst_1 : NormedAddCommGroup M] [inst_2 : Module R M]
[inst_3 : Module Rᵐᵒᵖ M] [inst_4 : IsBoundedSMul R M] [inst_5 : IsBoundedSMul Rᵐᵒᵖ M]
[inst_6 : SMulCommClass R Rᵐᵒᵖ M] (a b : TrivSqZeroExt R M), ‖a * b‖ ≤ ‖a‖ * ‖b‖ | null | false |
String.isEmpty_sliceFrom._simp_1 | Init.Data.String.Lemmas.IsEmpty | ∀ {s : String} {p : s.Pos}, ((s.sliceFrom p).isEmpty = true) = (p = s.endPos) | null | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal.0.AugmentedSimplexCategory.tensorHom.match_1.eq_5 | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | ∀ (motive : (x₁ y₁ x₂ y₂ : AugmentedSimplexCategory) → (x₁ ⟶ y₁) → (x₂ ⟶ y₂) → Sort u_1) (a a_1 : SimplexCategory)
(f₁ : CategoryTheory.WithInitial.of a ⟶ CategoryTheory.WithInitial.of a_1)
(x : CategoryTheory.WithInitial.star ⟶ CategoryTheory.WithInitial.star)
(h_1 :
(a a_2 a_3 a_4 : SimplexCategory) →
... | null | true |
_private.Std.Http.Protocol.H1.Parser.0.Std.Http.Protocol.H1.sp | Std.Http.Protocol.H1.Parser | Std.Internal.Parsec.ByteArray.Parser Unit | Parses a single space (SP, 0x20).
| true |
CommRingCat.tensorProd._proof_2 | Mathlib.Algebra.Category.Ring.Under.Basic | ∀ (R S : CommRingCat) [inst : Algebra ↑R ↑S] (X : CategoryTheory.Under R),
(Algebra.TensorProduct.map (AlgHom.id ↑S ↑S) (CommRingCat.toAlgHom (CategoryTheory.CategoryStruct.id X))).toUnder =
CategoryTheory.CategoryStruct.id (S.mkUnder (TensorProduct ↑R ↑S ↑X.right)) | null | false |
MulOpposite.instGroup._proof_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : Group α] (x : αᵐᵒᵖ), x⁻¹ * x = 1 | null | false |
RootPairing.GeckConstruction.equivRootSystem._proof_1 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basis | ∀ {K : Type u_1} [inst : Field K] [inst_1 : CharZero K] {ι : Type u_2} {M : Type u_3} {N : Type u_4}
[inst_2 : Fintype ι] [inst_3 : DecidableEq ι] [inst_4 : AddCommGroup M] [inst_5 : Module K M]
[inst_6 : AddCommGroup N] [inst_7 : Module K N] {P : RootPairing ι K M N} [inst_8 : P.IsCrystallographic]
(b : P.Base),... | null | false |
WithTop.preimage_coe_Ioi | Mathlib.Order.Interval.Set.WithBotTop | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, WithTop.some ⁻¹' Set.Ioi ↑a = Set.Ioi a | null | true |
TotallyBounded.image | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} {β : Type v} [uniformSpace : UniformSpace α] [inst : UniformSpace β] {f : α → β} {s : Set α},
TotallyBounded s → UniformContinuous f → TotallyBounded (f '' s) | The image of a totally bounded set under a uniformly continuous map is totally bounded. | true |
TestFunction.instAdd._proof_3 | Mathlib.Analysis.Distribution.TestFunction | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_2}
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {n : ℕ∞} (f g : TestFunction Ω F n),
(tsupport fun x => f x + g x) ⊆ ↑Ω | null | false |
dimH_iUnion | Mathlib.Topology.MetricSpace.HausdorffDimension | ∀ {X : Type u_2} [inst : EMetricSpace X] {ι : Sort u_4} [Countable ι] (s : ι → Set X), dimH (⋃ i, s i) = ⨆ i, dimH (s i) | null | true |
Subgroup.instMulActionQuotientDiff._proof_5 | Mathlib.GroupTheory.SchurZassenhaus | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G} [inst_1 : IsMulCommutative ↥H] [inst_2 : H.FiniteIndex]
[inst_3 : H.Normal] (g₁ g₂ : G) (q : H.QuotientDiff), (g₁ * g₂) • q = g₁ • g₂ • q | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0.Int32.reduceOfInt._regBuiltin.Int32.reduceOfInt.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.3685453738._hygCtx._hyg.405 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | null | false |
_private.Mathlib.Data.Option.NAry.0.Option.map_map₂_antidistrib_left._proof_1_1 | Mathlib.Data.Option.NAry | ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_2} {δ : Type u_1} {f : α → β → γ} {a : Option α} {b : Option β}
{β' : Type u_5} {g : γ → δ} {f' : β' → α → δ} {g' : β → β'},
(∀ (a : α) (b : β), g (f a b) = f' (g' b) a) → Option.map g (Option.map₂ f a b) = Option.map₂ f' (Option.map g' b) a | null | false |
CompactlySupportedContinuousMap.semilatticeSup._proof_2 | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : SemilatticeSup β] [inst_2 : Zero β]
[inst_3 : TopologicalSpace β] [inst_4 : ContinuousSup β] (a b : CompactlySupportedContinuousMap α β),
b ≤ { toFun := ⇑a ⊔ ⇑b, continuous_toFun := ⋯, hasCompactSupport' := ⋯ } | null | false |
Subgroup.two_mul_widthInfty_mem_strictPeriods | Mathlib.NumberTheory.ModularForms.Cusps | ∀ (𝒢 : Subgroup (GL (Fin 2) ℝ)), 2 * 𝒢.widthInfty ∈ 𝒢.strictPeriods | null | true |
_private.Init.Data.Slice.Lemmas.0.Std.Slice.foldlM_toArray._simp_1_2 | Init.Data.Slice.Lemmas | ∀ {α β : Type w} {γ : Type x} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id] {m : Type x → Type x'}
[inst_2 : Monad m] [LawfulMonad m] [inst_4 : Std.IteratorLoop α Id m] [Std.LawfulIteratorLoop α Id m]
{f : γ → β → m γ} {init : γ} {it : Std.Iter β}, Std.Iter.foldM f init it = Array.foldlM f init it.toArra... | null | false |
subalgebraOfSubring._proof_1 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_1} [inst : Ring R] (S : Subring R), (algebraMap ℤ R) 0 ∈ S.carrier | null | false |
_private.Mathlib.Tactic.FieldSimp.0.Mathlib.Tactic.FieldSimp.qNF.mkMulProof._unary.eq_def | Mathlib.Tactic.FieldSimp | ∀ {v : Lean.Level} {M : Q(Type v)} (iM : Q(CommGroupWithZero «$M»))
(_x : (_ : Mathlib.Tactic.FieldSimp.qNF M) ×' Mathlib.Tactic.FieldSimp.qNF M),
Mathlib.Tactic.FieldSimp.qNF.mkMulProof._unary iM _x =
PSigma.casesOn _x fun l₁ l₂ =>
match l₁, l₂ with
| [], l =>
have a := l.toNF;
q(⋯)... | null | false |
CategoryTheory.MorphismProperty.instIsClosedUnderIsomorphismsStructuredArrowStructuredArrowObjOfRespectsIso | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] {T : Type u_3}
[inst_1 : CategoryTheory.Category.{v_3, u_3} T] (L : CategoryTheory.Functor A T)
{W : CategoryTheory.MorphismProperty T} {X : T} [W.RespectsIso],
(CategoryTheory.MorphismProperty.structuredArrowObj L W).IsClosedUnderIsomorphisms | null | true |
Continuous.image_Ico_of_strictMono | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : ConditionallyCompleteLinearOrder α] [OrderTopology α]
[DenselyOrdered α] {δ : Type u_1} [inst_4 : LinearOrder δ] [inst_5 : TopologicalSpace δ] [OrderClosedTopology δ]
{a b : α} {f : α → δ}, Continuous f → StrictMono f → f '' Set.Ico a b = Set.Ico (f a) (f b) | null | true |
_private.Mathlib.RingTheory.Valuation.ValuationSubring.0.ValuationSubring.unitGroup_le_unitGroup._simp_1_1 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u} [inst : Field K] (A : ValuationSubring K), (0 ∈ A) = True | null | false |
Std.ExtHashMap.contains_insertMany_list | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {l : List (α × β)} {k : α},
(m.insertMany l).contains k = (m.contains k || (List.map Prod.fst l).contains k) | null | true |
LinearMap.BilinForm.isSymm_toMatrix'_iff_isSymm._simp_1 | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₁ : Type u_1} [inst : CommSemiring R₁] {n : Type u_5} [inst_1 : Fintype n] [inst_2 : DecidableEq n]
{B : LinearMap.BilinForm R₁ (n → R₁)}, (LinearMap.BilinForm.toMatrix' B).IsSymm = B.IsSymm | null | false |
CochainComplex.homologyδOfTriangle._proof_2 | Mathlib.Algebra.Homology.DerivedCategory.HomologySequence | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(T : CategoryTheory.Pretriangulated.Triangle (CochainComplex C ℤ)) (n₀ : ℤ),
(HomologicalComplex.sc T.obj₃ n₀).HasHomology | null | false |
CommRingCat.Colimits.descFunLift.match_1 | Mathlib.Algebra.Category.Ring.Colimits | {J : Type u_1} →
[inst : CategoryTheory.SmallCategory J] →
(F : CategoryTheory.Functor J CommRingCat) →
(motive : CommRingCat.Colimits.Prequotient F → Sort u_2) →
(x : CommRingCat.Colimits.Prequotient F) →
((j : J) → (x : ↑(F.obj j)) → motive (CommRingCat.Colimits.Prequotient.of j x)) →
... | null | false |
_private.Lean.Elab.App.0.Lean.Elab.Term.ElabAppArgs.processImplicitArg._unsafe_rec | Lean.Elab.App | Lean.Name → Lean.Elab.Term.ElabAppArgs.M Lean.Expr | null | false |
CategoryTheory.Limits.isLimitOfHasKernelOfPreservesLimit | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Kernels | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] →
(G : CategoryTheory.Functor C D) →
... | If `G` preserves kernels and `C` has them, then the fork constructed of the mapped morphisms of
a kernel fork is a limit.
| true |
Complex.UnitDisc.re_neg | Mathlib.Analysis.Complex.UnitDisc.Basic | ∀ (z : Complex.UnitDisc), (-z).re = -z.re | null | true |
Differentiable.norm | Mathlib.Analysis.InnerProductSpace.Calculus | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [InnerProductSpace 𝕜 E]
[inst : NormedSpace ℝ E] {G : Type u_4} [inst_2 : NormedAddCommGroup G] [inst_3 : NormedSpace ℝ G] {f : G → E},
Differentiable ℝ f → (∀ (x : G), f x ≠ 0) → Differentiable ℝ fun y => ‖f y‖ | null | true |
RBTree.RBNode.Path.ins | Batteries.Recycling.RBTree.Basic | {α : Type u_1} → RBTree.RBNode.Path α → RBTree.RBNode α → RBTree.RBNode α | This function does the second part of `RBNode.ins`,
which unwinds the stack and rebuilds the tree.
| true |
Std.Iterators.PostconditionT.ext | Init.Data.Iterators.PostconditionMonad | ∀ {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] {α : Type w} {x y : Std.Iterators.PostconditionT m α}
(h : x.Property = y.Property), (fun p => ⟨↑p, ⋯⟩) <$> x.operation = y.operation → x = y | null | true |
Array.forIn'.loop.eq_2 | Init.Data.List.ToArray | ∀ {α : Type u} {β : Type v} {m : Type v → Type w} [inst : Monad m] (as : Array α)
(f : (a : α) → a ∈ as → β → m (ForInStep β)) (b : β) (i_1 : ℕ) (h_1 : i_1 + 1 ≤ as.size),
Array.forIn'.loop as f i_1.succ h_1 b = do
let __do_lift ← f as[as.size - 1 - i_1] ⋯ b
match __do_lift with
| ForInStep.done b => ... | null | true |
Std.Time.Internal.Bounded.LE.mul_pos._proof_1 | Std.Time.Internal.Bounded | ∀ {n m : ℤ} (bounded : Std.Time.Internal.Bounded.LE n m), ∀ num ≥ 0, n * num ≤ ↑bounded * num ∧ ↑bounded * num ≤ m * num | null | false |
FiniteIndexNormalSubgroup.instMax | Mathlib.GroupTheory.FiniteIndexNormalSubgroup | {G : Type u_1} → [inst : Group G] → Max (FiniteIndexNormalSubgroup G) | null | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Roi.isEmpty_iff_forall_not_mem._simp_1_5 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | null | false |
Nat.Internal.Linear.ExprCnstr.mk.injEq | Init.Data.Nat.Internal.Linear | ∀ (eq : Bool) (lhs rhs : Nat.Internal.Linear.Expr) (eq_1 : Bool) (lhs_1 rhs_1 : Nat.Internal.Linear.Expr),
({ eq := eq, lhs := lhs, rhs := rhs } = { eq := eq_1, lhs := lhs_1, rhs := rhs_1 }) =
(eq = eq_1 ∧ lhs = lhs_1 ∧ rhs = rhs_1) | null | true |
Quaternion.ofComplex._proof_3 | Mathlib.Analysis.Quaternion | ∀ (x : ℝ), ↑((algebraMap ℝ ℂ) x) = ↑((algebraMap ℝ ℂ) x) | null | false |
Nat.Partrec.Code.brecOn.eq | Mathlib.Computability.PartrecCode | ∀ {motive : Nat.Partrec.Code → Sort u} (t : Nat.Partrec.Code)
(F_1 : (t : Nat.Partrec.Code) → Nat.Partrec.Code.below t → motive t),
Nat.Partrec.Code.brecOn t F_1 = F_1 t (Nat.Partrec.Code.brecOn.go t F_1).2 | null | true |
_private.Mathlib.Analysis.Convex.Strong.0.aux_add | Mathlib.Analysis.Convex.Strong | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] {a b m : ℝ} {x y : E} {f : E → ℝ},
0 ≤ a →
0 ≤ b →
a + b = 1 →
a * (f x + m / 2 * ‖x‖ ^ 2) + b * (f y + m / 2 * ‖y‖ ^ 2) - m / 2 * ‖a • x + b • y‖ ^ 2 =
a * f x + b * f y + m / 2 * a * b * ‖x - y‖ ^ 2 | null | true |
EuclideanGeometry.concyclic_empty | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P], EuclideanGeometry.Concyclic ∅ | The empty set is concyclic. | true |
ContinuousAlgHom.coe_comp'._simp_1 | 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]
{C : Type u_4} [inst_7 : Semiring C] [inst_8 : Algebra R C] [inst_9 : TopologicalSpace C] (h : ... | null | false |
Nat.stirlingFirst_succ_self_left | Mathlib.Combinatorics.Enumerative.Stirling | ∀ (n : ℕ), (n + 1).stirlingFirst n = (n + 1).choose 2 | null | true |
Submodule.codisjoint_span_image_of_codisjoint | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} {v : ι → M} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M],
Submodule.span R (Set.range v) = ⊤ →
∀ {s t : Set ι}, Codisjoint s t → Codisjoint (Submodule.span R (v '' s)) (Submodule.span R (v '' t)) | null | true |
PartOrd.instConcreteCategoryOrderHomCarrier._proof_3 | Mathlib.Order.Category.PartOrd | ∀ {X : PartOrd} (x : ↑X), (CategoryTheory.CategoryStruct.id X).hom' x = x | null | false |
List.exists_le_of_prod_le | Mathlib.Algebra.Order.BigOperators.Group.List | ∀ {ι : Type u_1} {M : Type u_3} [inst : Monoid M] [inst_1 : LinearOrder M] [MulLeftStrictMono M] [MulLeftMono M]
[MulRightStrictMono M] [MulRightMono M] {l : List ι},
l ≠ [] → ∀ (f g : ι → M), (List.map f l).prod ≤ (List.map g l).prod → ∃ x ∈ l, f x ≤ g x | null | true |
DoResultPRBC.return.elim | Init.Core | {α β σ : Type u} →
{motive : DoResultPRBC α β σ → Sort u_1} →
(t : DoResultPRBC α β σ) → t.ctorIdx = 1 → ((a : β) → (a_1 : σ) → motive (DoResultPRBC.return a a_1)) → motive t | null | false |
CategoryTheory.Comonad.Coalgebra.counit._autoParam | Mathlib.CategoryTheory.Monad.Algebra | Lean.Syntax | null | false |
Set.Ioo_union_right | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, b < a → Set.Ioo b a ∪ {a} = Set.Ioc b a | null | true |
CategoryTheory.Functor.mapTriangle._proof_2 | Mathlib.CategoryTheory.Triangulated.Functor | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.HasShift C ℤ]
[inst_3 : CategoryTheory.HasShift D ℤ] (F : CategoryTheory.Functor C D) [inst_4 : F.CommShift ℤ]
{X Y : CategoryTheory.Pretriangulated.Triangle C} (f... | null | false |
PowerSeries.aeval | Mathlib.RingTheory.PowerSeries.Evaluation | {R : Type u_1} →
[inst : CommRing R] →
{S : Type u_2} →
[inst_1 : CommRing S] →
{a : S} →
[inst_2 : UniformSpace R] →
[inst_3 : UniformSpace S] →
[IsUniformAddGroup R] →
[IsTopologicalSemiring R] →
[IsUniformAddGroup S] →
... | For `HasEval a`,
the evaluation homomorphism at `a` on `PowerSeries`, as an `AlgHom`. | true |
_private.Lean.Compiler.LCNF.Types.0.Lean.Compiler.LCNF.isPropFormerTypeQuick._sparseCasesOn_2 | Lean.Compiler.LCNF.Types | {motive : Lean.Level → Sort u} →
(t : Lean.Level) → motive Lean.Level.zero → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Lean.Meta.Simp.NormCastConfig.zetaDelta._inherited_default | Init.MetaTypes | Bool | null | false |
Function.Injective.addGroupWithOne._proof_1 | Mathlib.Algebra.Ring.InjSurj | ∀ {R : Type u_1} {S : Type u_2} [inst : Zero S] [inst_1 : One S] [inst_2 : Add S] [inst_3 : SMul ℕ S]
[inst_4 : NatCast S] [inst_5 : IntCast S] [inst_6 : AddGroupWithOne R] (f : S → R) (hf : Function.Injective f)
(zero : f 0 = 0) (one : f 1 = 1) (add : ∀ (x y : S), f (x + y) = f x + f y)
(nsmul : ∀ (n : ℕ) (x : S... | null | false |
ProbabilityTheory.Kernel.compProd_eq_iff | Mathlib.Probability.Kernel.CompProdEqIff | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {μ : MeasureTheory.Measure α}
{κ η : ProbabilityTheory.Kernel α β} [MeasurableSpace.CountableOrCountablyGenerated α β]
[MeasureTheory.IsFiniteMeasure μ] [ProbabilityTheory.IsFiniteKernel κ] [ProbabilityTheory.IsFiniteKernel η],
μ.co... | Two finite kernels `κ` and `η` are `μ`-a.e. equal iff the composition-products `μ ⊗ₘ κ`
and `μ ⊗ₘ η` are equal. | true |
_private.Lean.Elab.PreDefinition.Structural.BRecOn.0.Lean.Elab.Structural.replaceRecApps.loop.match_12 | Lean.Elab.PreDefinition.Structural.BRecOn | (motive : Option Lean.Meta.MatcherApp → Sort u_1) →
(__do_lift : Option Lean.Meta.MatcherApp) →
((matcherApp : Lean.Meta.MatcherApp) → motive (some matcherApp)) → (Unit → motive none) → motive __do_lift | null | false |
CategoryTheory.Limits.PullbackCone.IsWeakLimit.lift.congr_simp | Mathlib.CategoryTheory.Limits.WeakLimits.WeakPullbacks | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
{t : CategoryTheory.Limits.PullbackCone f g} (ht ht_1 : CategoryTheory.Limits.IsWeakLimit t),
ht = ht_1 →
∀ {W : C} (h h_1 : W ⟶ X) (e_h : h = h_1) (k k_1 : W ⟶ Y) (e_k : k = k_1)
(w : CategoryTheory.Categor... | null | true |
LightCondensed.discrete._proof_1 | Mathlib.Condensed.Discrete.Basic | CategoryTheory.Precoherent LightProfinite | null | false |
PseudoMetric.noConfusion | Mathlib.Topology.MetricSpace.BundledFun | {P : Sort u} →
{X : Type u_1} →
{R : Type u_2} →
{inst : Zero R} →
{inst_1 : Add R} →
{inst_2 : LE R} →
{t : PseudoMetric X R} →
{X' : Type u_1} →
{R' : Type u_2} →
{inst' : Zero R'} →
{inst'_1 : Add R'} →
... | null | false |
NormedSpace.expSeries_sum_eq | Mathlib.Analysis.Normed.Algebra.Exponential | ∀ {𝕂 : Type u_1} {𝔸 : Type u_2} [inst : Field 𝕂] [inst_1 : Ring 𝔸] [inst_2 : Algebra 𝕂 𝔸] [inst_3 : TopologicalSpace 𝔸]
[inst_4 : IsTopologicalRing 𝔸] (x : 𝔸), (NormedSpace.expSeries 𝕂 𝔸).sum x = ∑' (n : ℕ), (↑n.factorial)⁻¹ • x ^ n | null | true |
_private.Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity.0.chevalley_mvPolynomial_mvPolynomial._simp_1_5 | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | null | false |
CommRingCat.casesOn | Mathlib.Algebra.Category.Ring.Basic | {motive : CommRingCat → Sort u_1} →
(t : CommRingCat) → ((carrier : Type u) → [commRing : CommRing carrier] → motive ↧carrier) → motive t | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.