name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.MeasureTheory.Function.AbsolutelyContinuous.0.AbsolutelyContinuousOnInterval.hasBasis_totalLengthFilter._simp_1_3 | Mathlib.MeasureTheory.Function.AbsolutelyContinuous | ∀ {p q : Prop}, (p ↔ q ∧ p) = (p → q) | false |
Std.HashMap.Raw.mem_of_mem_insertMany_list | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α],
m.WF → ∀ {l : List (α × β)} {k : α}, k ∈ m.insertMany l → (List.map Prod.fst l).contains k = false → k ∈ m | true |
instZeroEuclideanQuadrant | Mathlib.Geometry.Manifold.Instances.Real | {n : ℕ} → Zero (EuclideanQuadrant n) | true |
HomologicalComplex.restrictionHomologyIso_hom_homologyι_assoc | Mathlib.Algebra.Homology.Embedding.RestrictionHomology | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(K : HomologicalComplex C c') (e : c.Embedding c') [inst_2 : e.IsRelIff] (i j k : ι) (hi : c.prev j = i)
(hk : c.next j = k)... | true |
LocallyConstant.charFn | Mathlib.Topology.LocallyConstant.Algebra | {X : Type u_1} →
(Y : Type u_2) → [inst : TopologicalSpace X] → [MulZeroOneClass Y] → {U : Set X} → IsClopen U → LocallyConstant X Y | true |
WithLp.ctorIdx | Mathlib.Analysis.Normed.Lp.WithLp | {p : ENNReal} → {V : Type u_1} → WithLp p V → ℕ | false |
Bool.sizeOf_eq_one | Init.SizeOf | ∀ (b : Bool), sizeOf b = 1 | true |
Filter.isBoundedUnder_ge_inf._simp_1 | Mathlib.Order.Filter.IsBounded | ∀ {α : Type u_1} {β : Type u_2} [inst : SemilatticeInf α] {f : Filter β} {u v : β → α},
(Filter.IsBoundedUnder (fun x1 x2 => x1 ≥ x2) f fun a => u a ⊓ v a) =
(Filter.IsBoundedUnder (fun x1 x2 => x1 ≥ x2) f u ∧ Filter.IsBoundedUnder (fun x1 x2 => x1 ≥ x2) f v) | false |
MvPolynomial.support_sum | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {α : Type u_2} [inst_1 : DecidableEq σ] {s : Finset α}
{f : α → MvPolynomial σ R}, (∑ x ∈ s, f x).support ⊆ s.biUnion fun x => (f x).support | true |
Set.mulIndicator_one | Mathlib.Algebra.Notation.Indicator | ∀ {α : Type u_1} (M : Type u_3) [inst : One M] (s : Set α), (s.mulIndicator fun x => 1) = fun x => 1 | true |
CategoryTheory.Limits.pushout.map._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {W X Y Z S T : C} (f₁ : S ⟶ W) (f₂ : S ⟶ X) (g₁ : T ⟶ Y)
(g₂ : T ⟶ Z) [inst_1 : CategoryTheory.Limits.HasPushout g₁ g₂] (i₁ : W ⟶ Y) (i₂ : X ⟶ Z) (i₃ : S ⟶ T),
CategoryTheory.CategoryStruct.comp f₁ i₁ = CategoryTheory.CategoryStruct.comp i₃ g₁ →
Cat... | false |
Lean.Meta.Grind.checkMaxEmatchExceeded | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.GoalM Bool | true |
Batteries.AssocList.isEmpty.eq_1 | Batteries.Data.AssocList | ∀ {α : Type u_1} {β : Type u_2}, Batteries.AssocList.nil.isEmpty = true | true |
Aesop.RuleTacDescr.constructors | Aesop.RuleTac.Descr | Array Lean.Name → Lean.Meta.TransparencyMode → Aesop.RuleTacDescr | true |
div_lt_div_iff' | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : CommGroup α] [inst_1 : LT α] [MulLeftStrictMono α] {a b c d : α}, a / b < c / d ↔ a * d < c * b | true |
Module.Basis.empty.congr_simp | Mathlib.RingTheory.Smooth.StandardSmoothOfFree | ∀ {ι : Type u_1} {R : Type u_3} (M : Type u_5) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Subsingleton M] [inst_4 : IsEmpty ι], Module.Basis.empty M = Module.Basis.empty M | true |
SNum.lt | Mathlib.Data.Num.Lemmas | LT SNum | true |
Std.DTreeMap.Internal.Impl.mem_of_mem_erase! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF → ∀ {k a : α}, a ∈ Std.DTreeMap.Internal.Impl.erase! k t → a ∈ t | true |
String.Slice.Pos.prevAux.go.eq_def | Init.Data.String.Basic | ∀ {s : String.Slice} (off : ℕ) (h₁ : off < s.utf8ByteSize),
String.Slice.Pos.prevAux.go off h₁ =
if hbyte : (s.getUTF8Byte { byteIdx := off } h₁).IsUTF8FirstByte then { byteIdx := off }
else
have this := ⋯;
match off, h₁, hbyte, this with
| 0, h₁, hbyte, this => ⋯.elim
| off.succ, h₁, ... | true |
CategoryTheory.WithTerminal.starIsoTerminal_inv | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C],
CategoryTheory.WithTerminal.starIsoTerminal.inv =
CategoryTheory.WithTerminal.starTerminal.from (⊤_ CategoryTheory.WithTerminal C) | true |
Homeomorph.setCongr._proof_2 | Mathlib.Topology.Homeomorph.Lemmas | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s t : Set X} (h : s = t), Continuous (Set.inclusion ⋯) | false |
uniformity_pseudoedist | Mathlib.Topology.EMetricSpace.Defs | ∀ {α : Type u} [inst : PseudoEMetricSpace α],
uniformity α = ⨅ ε, ⨅ (_ : ε > 0), Filter.principal {p | edist p.1 p.2 < ε} | true |
RootPairing.PolarizationEquiv._proof_5 | Mathlib.LinearAlgebra.RootSystem.Finite.Nondegenerate | ∀ {R : Type u_1} [inst : Field R], RingHomInvPair (RingHom.id R) (RingHom.id R) | false |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.instBEqSplitStatus.beq._sparseCasesOn_3 | Lean.Meta.Tactic.Grind.Split | {motive : Lean.Meta.Grind.SplitStatus → Sort u} →
(t : Lean.Meta.Grind.SplitStatus) →
((numCases : ℕ) →
(isRec tryPostpone : Bool) → motive (Lean.Meta.Grind.SplitStatus.ready numCases isRec tryPostpone)) →
(Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | false |
Orientation.eq_rotation_self_iff | Mathlib.Geometry.Euclidean.Angle.Oriented.Rotation | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (x : V) (θ : Real.Angle), x = (o.rotation θ) x ↔ x = 0 ∨ θ = 0 | true |
Applicative.mk.noConfusion | Init.Prelude | {f : Type u → Type v} →
{P : Sort u_1} →
{toFunctor : Functor f} →
{toPure : Pure f} →
{toSeq : Seq f} →
{toSeqLeft : SeqLeft f} →
{toSeqRight : SeqRight f} →
{toFunctor' : Functor f} →
{toPure' : Pure f} →
{toSeq' : Seq f} →
... | false |
AlgebraicGeometry.Scheme.ProEt.instFullOverForget | Mathlib.AlgebraicGeometry.Sites.Proetale | ∀ (S : AlgebraicGeometry.Scheme), (AlgebraicGeometry.Scheme.ProEt.forget S).Full | true |
Std.Stream.noConfusion | Init.Data.Stream | {P : Sort u_1} →
{stream : Type u} →
{value : Type v} →
{t : Std.Stream stream value} →
{stream' : Type u} →
{value' : Type v} →
{t' : Std.Stream stream' value'} →
stream = stream' → value = value' → t ≍ t' → Std.Stream.noConfusionType P t t' | false |
Complex.differentiable_sinh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | Differentiable ℂ Complex.sinh | true |
ONote.fundamentalSequenceProp_inl_some | Mathlib.SetTheory.Ordinal.Notation | ∀ (o a : ONote), o.FundamentalSequenceProp (Sum.inl (some a)) ↔ o.repr = Order.succ a.repr ∧ (o.NF → a.NF) | true |
AddMonoidAlgebra.symm_mapAddEquiv | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {S : Type u_4} {M : Type u_6} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : Add M] (e : R ≃+ S),
(AddMonoidAlgebra.mapAddEquiv M e).symm = AddMonoidAlgebra.mapAddEquiv M e.symm | true |
LocallyConstant.instMul.eq_1 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : Mul Y],
LocallyConstant.instMul = { mul := fun f g => { toFun := ⇑f * ⇑g, isLocallyConstant := ⋯ } } | true |
Lean.Parser.withOpenDeclFn | Lean.Parser.Extension | Lean.Parser.ParserFn → Lean.Parser.ParserFn | true |
ValuativeRel.ValueGroupWithZero.mk_one_one | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R], ValuativeRel.ValueGroupWithZero.mk 1 1 = 1 | true |
Module.Basis.algebraMapCoeffs_apply | Mathlib.RingTheory.AlgebraTower | ∀ {R : Type u_1} (A : Type u_3) {ι : Type u_5} {M : Type u_6} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : AddCommMonoid M] [inst_3 : Algebra R A] [inst_4 : Module A M] [inst_5 : Module R M]
[inst_6 : IsScalarTower R A M] (b : Module.Basis ι R M) (h : Function.Bijective ⇑(algebraMap R A)) (i : ι),
(Mod... | true |
ContinuousLinearMap.mfderiv_eq | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {E' : Type u_5} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E']
(f : E →L[𝕜] E') {x : E}, mfderiv% ⇑f x = f | true |
OrderIso.isBoundedUnder_le_comp | Mathlib.Order.Filter.IsBounded | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : LE α] [inst_1 : LE β] (e : α ≃o β) {l : Filter γ} {u : γ → α},
(Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) l fun x => e (u x)) ↔ Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) l u | true |
Left.nsmul_nonpos | Mathlib.Algebra.Order.Monoid.Unbundled.Pow | ∀ {M : Type u_3} [inst : AddMonoid M] [inst_1 : Preorder M] [AddLeftMono M] {a : M}, a ≤ 0 → ∀ (n : ℕ), n • a ≤ 0 | true |
Lean.Elab.Tactic.GuardMsgs.GuardMsgsSpec._sizeOf_1 | Lean.Elab.GuardMsgs | Lean.Elab.Tactic.GuardMsgs.GuardMsgsSpec → ℕ | false |
_private.Mathlib.LinearAlgebra.LinearIndependent.Defs.0.not_linearIndependent_iffₛ._simp_1_2 | Mathlib.LinearAlgebra.LinearIndependent.Defs | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | false |
_private.Mathlib.Topology.Instances.ENNReal.Lemmas.0.ENNReal.continuous_pow._simp_1_1 | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {y : Y},
(Continuous fun x => y) = True | false |
Int.natAbs_one | Init.Data.Int.Order | Int.natAbs 1 = 1 | true |
RingAut.toAddAut._proof_1 | Mathlib.Algebra.Ring.Aut | ∀ (R : Type u_1) [inst : Mul R] [inst_1 : Add R], RingEquiv.toAddEquiv 1 = RingEquiv.toAddEquiv 1 | false |
Matrix.submatrixEquivInvertible._proof_1 | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {m : Type u_3} {n : Type u_1} {α : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α]
[inst_3 : Fintype m] [inst_4 : DecidableEq m] (A : Matrix m m α) (e₁ e₂ : n ≃ m) [inst_5 : Invertible A],
A.submatrix ⇑e₁ ⇑e₂ * (⅟A).submatrix ⇑e₂ ⇑e₁ = 1 | false |
NormedAddGroupHom.inhabited | Mathlib.Analysis.Normed.Group.Hom | {V₁ : Type u_2} →
{V₂ : Type u_3} →
[inst : SeminormedAddCommGroup V₁] → [inst_1 : SeminormedAddCommGroup V₂] → Inhabited (NormedAddGroupHom V₁ V₂) | true |
MulArchimedeanClass.liftOrderHom.eq_1 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : CommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedMonoid M] {α : Type u_2}
[inst_3 : PartialOrder α] (f : M → α)
(h : ∀ (a b : M), MulArchimedeanClass.mk a ≤ MulArchimedeanClass.mk b → f a ≤ f b),
MulArchimedeanClass.liftOrderHom f h = { toFun := MulArchimedeanClass.lift f ⋯, monot... | true |
LieAlgebra.Orthogonal.soIndefiniteEquiv._proof_1 | Mathlib.Algebra.Lie.Classical | ∀ (p : Type u_1) (q : Type u_2) (R : Type u_3) [inst : DecidableEq p] [inst_1 : DecidableEq q] [inst_2 : CommRing R]
[inst_3 : Fintype p] [inst_4 : Fintype q] {i : R},
i * i = -1 →
↑(skewAdjointMatricesLieSubalgebra
((LieAlgebra.Orthogonal.Pso p q R i).transpose * LieAlgebra.Orthogonal.indefiniteDiago... | false |
AbstractCompletion.extend_unique | Mathlib.Topology.UniformSpace.AbstractCompletion | ∀ {α : Type uα} [inst : UniformSpace α] (pkg : AbstractCompletion.{vα, uα} α) {β : Type uβ} [inst_1 : UniformSpace β]
{f : α → β} [CompleteSpace β] [T0Space β],
UniformContinuous f → ∀ {g : pkg.space → β}, UniformContinuous g → (∀ (a : α), f a = g (pkg.coe a)) → pkg.extend f = g | true |
Set.mem_cIcc | Mathlib.Order.Circular | ∀ {α : Type u_1} [inst : CircularPreorder α] {a b x : α}, x ∈ Set.cIcc a b ↔ btw a x b | true |
Asymptotics.IsBigOTVS.add | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommGroup F]
[inst_5 : TopologicalSpace F] [inst_6 : Module 𝕜 F] [ContinuousAdd E] [ContinuousSMul 𝕜 E] {f₁ f₂ : α → E} {g ... | true |
OrderMonoidIso.unitsCongr | Mathlib.Algebra.Order.Hom.Units | {α : Type u_1} →
{β : Type u_2} →
[inst : Preorder α] → [inst_1 : Monoid α] → [inst_2 : Preorder β] → [inst_3 : Monoid β] → (α ≃*o β) → αˣ ≃*o βˣ | true |
thickenedIndicatorAux.eq_1 | Mathlib.Topology.MetricSpace.ThickenedIndicator | ∀ {α : Type u_1} [inst : PseudoEMetricSpace α] (δ : ℝ) (E : Set α) (x : α),
thickenedIndicatorAux δ E x = 1 - Metric.infEDist x E / ENNReal.ofReal δ | true |
ValuationSubring.primeSpectrumEquiv_apply | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u} [inst : Field K] (A : ValuationSubring K) (P : PrimeSpectrum ↥A),
A.primeSpectrumEquiv P = ⟨A.ofPrime P.asIdeal, ⋯⟩ | true |
Std.DTreeMap.Raw.ordered_keys | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → List.Pairwise (fun a b => cmp a b = Ordering.lt) t.keys | true |
_private.Mathlib.CategoryTheory.Subfunctor.Basic.0.CategoryTheory.instCompleteLatticeSubfunctor._simp_5 | Mathlib.CategoryTheory.Subfunctor.Basic | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | false |
Metric.sphere_subset_closedBall | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ}, Metric.sphere x ε ⊆ Metric.closedBall x ε | true |
Complex.tsum_exp_neg_quadratic | Mathlib.Analysis.SpecialFunctions.Gaussian.PoissonSummation | ∀ {a : ℂ},
0 < a.re →
∀ (b : ℂ),
∑' (n : ℤ), Complex.exp (-↑Real.pi * a * ↑n ^ 2 + 2 * ↑Real.pi * b * ↑n) =
1 / a ^ (1 / 2) * ∑' (n : ℤ), Complex.exp (-↑Real.pi / a * (↑n + Complex.I * b) ^ 2) | true |
exists_isClopen_upper_or_lower_of_ne | Mathlib.Topology.Order.Priestley | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : PartialOrder α] [PriestleySpace α] {x y : α},
x ≠ y → ∃ U, IsClopen U ∧ (IsUpperSet U ∨ IsLowerSet U) ∧ x ∈ U ∧ y ∉ U | true |
DFinsupp.coe_sup | Mathlib.Data.DFinsupp.Order | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Zero (α i)] [inst_1 : (i : ι) → SemilatticeSup (α i)]
(f g : Π₀ (i : ι), α i), ⇑(f ⊔ g) = ⇑f ⊔ ⇑g | true |
CategoryTheory.op_add | Mathlib.CategoryTheory.Preadditive.Opposite | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
(f g : X ⟶ Y), (f + g).op = f.op + g.op | true |
Std.DHashMap.Internal.Raw₀.replaceₘ._proof_1 | Std.Data.DHashMap.Internal.Model | ∀ {α : Type u_1} {β : α → Type u_2} [inst : BEq α] [inst_1 : Hashable α] (m : Std.DHashMap.Internal.Raw₀ α β) (a : α)
(b : β a),
0 <
{ size := (↑m).size,
buckets :=
Std.DHashMap.Internal.updateBucket (↑m).buckets ⋯ a fun l =>
Std.DHashMap.Internal.AssocList.replace a b l }.bu... | false |
RCLike.continuous_im | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], Continuous ⇑RCLike.im | true |
Std.Iterators.Types.Flatten.IsPlausibleStep.outerDone_flatMap | Init.Data.Iterators.Lemmas.Combinators.Monadic.FlatMap | ∀ {α β α₂ γ : Type w} {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] [inst_2 : Std.Iterator α m β]
[inst_3 : Std.Iterator α₂ m γ] {f : β → Std.IterM m γ} {it₁ : Std.IterM m β},
it₁.IsPlausibleStep Std.IterStep.done → (Std.IterM.flatMapAfter f it₁ none).IsPlausibleStep Std.IterStep.done | true |
Submodule.mem_span_image_finset_iff_exists_fun | Mathlib.LinearAlgebra.Finsupp.LinearCombination | ∀ {α : Type u_1} {M : Type u_2} (R : Type u_3) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{v : α → M} {x : M} {s : Finset α}, x ∈ Submodule.span R (v '' ↑s) ↔ ∃ c, ∑ i, c i • v ↑i = x | true |
_private.Mathlib.Algebra.Homology.Augment.0.ChainComplex.augment.match_3.splitter | Mathlib.Algebra.Homology.Augment | (motive : ℕ → ℕ → Sort u_1) →
(x x_1 : ℕ) →
(Unit → motive 1 0) →
((i j : ℕ) → motive i.succ j.succ) →
((x x_2 : ℕ) → (x = 1 → x_2 = 0 → False) → (∀ (i j : ℕ), x = i.succ → x_2 = j.succ → False) → motive x x_2) →
motive x x_1 | true |
MonoidAlgebra.liftMagma._proof_2 | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ (R : Type u_3) {A : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : Mul M]
[inst_2 : NonUnitalNonAssocSemiring A] [inst_3 : Module R A] [IsScalarTower R A A] [SMulCommClass R A A] (f : M →ₙ* A)
(a₁ a₂ : MonoidAlgebra R M),
(Finsupp.sum (a₁ * a₂) fun m t => t • f m) = (Finsupp.sum a₁ fun m t => t • f m) *... | false |
_private.Lean.Elab.Tactic.NormCast.0.Lean.Elab.Tactic.NormCast.splittingProcedure.match_1 | Lean.Elab.Tactic.NormCast | (motive : Option Lean.Meta.Simp.Result → Sort u_1) →
(__discr : Option Lean.Meta.Simp.Result) →
((x_x2 : Lean.Meta.Simp.Result) → motive (some x_x2)) →
((x : Option Lean.Meta.Simp.Result) → motive x) → motive __discr | false |
Functor.map_comp_map | Mathlib.Control.Functor | ∀ {F : Type u → Type v} {α β γ : Type u} [inst : Functor F] [LawfulFunctor F] (f : α → β) (g : β → γ),
((fun x => g <$> x) ∘ fun x => f <$> x) = fun x => (g ∘ f) <$> x | true |
CategoryTheory.ComposableArrows.threeδ₁Toδ₀_app_zero | Mathlib.CategoryTheory.ComposableArrows.Three | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {i j k l : C} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l)
(f₁₂ : i ⟶ k) (h₁₂ : CategoryTheory.CategoryStruct.comp f₁ f₂ = f₁₂),
(CategoryTheory.ComposableArrows.threeδ₁Toδ₀ f₁ f₂ f₃ f₁₂ h₁₂).app 0 = f₁ | true |
CategoryTheory.Oplax.StrongTrans.Modification.ext_iff | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | ∀ {B : Type u₁} {inst : CategoryTheory.Bicategory B} {C : Type u₂} {inst_1 : CategoryTheory.Bicategory C}
{F G : CategoryTheory.OplaxFunctor B C} {η θ : F ⟶ G} {x y : CategoryTheory.Oplax.StrongTrans.Modification η θ},
x = y ↔ x.app = y.app | true |
Polynomial.reflect_mul_induction | Mathlib.Algebra.Polynomial.Reverse | ∀ {R : Type u_1} [inst : Semiring R] (cf cg N O : ℕ) (f g : Polynomial R),
f.support.card ≤ cf.succ →
g.support.card ≤ cg.succ →
f.natDegree ≤ N →
g.natDegree ≤ O → Polynomial.reflect (N + O) (f * g) = Polynomial.reflect N f * Polynomial.reflect O g | true |
CategoryTheory.typeEquiv_unitIso_inv_app | Mathlib.CategoryTheory.Sites.Types | ∀ (X : Type u)
(a :
(CategoryTheory.yoneda'.comp
((CategoryTheory.sheafToPresheaf CategoryTheory.typesGrothendieckTopology (Type u)).comp
((CategoryTheory.evaluation Type uᵒᵖ (Type u)).obj (Opposite.op PUnit.{u + 1})))).obj
X),
CategoryTheory.typeEquiv.unitIso.inv.app X a = a PUnit.u... | true |
_private.Lean.Server.FileWorker.0.Lean.Server.FileWorker.handlePreRequestSpecialCases?.match_3 | Lean.Server.FileWorker | (motive : String → Sort u_1) →
(method : String) →
(Unit → motive "$/lean/rpc/call") → (Unit → motive "codeAction/resolve") → ((x : String) → motive x) → motive method | false |
CategoryTheory.Limits.Cone.functoriality_obj_pt | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{D : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} D] (F : CategoryTheory.Functor J C)
(G : CategoryTheory.Functor C D) (A : CategoryTheory.Limits.Cone F),
((CategoryTheory.Limits.Cone.fun... | true |
_private.Mathlib.Logic.Equiv.Defs.0.Equiv.permCongr_trans._proof_1_1 | Mathlib.Logic.Equiv.Defs | ∀ {α' : Type u_2} {β' : Type u_1} (e : α' ≃ β') (p p' : Equiv.Perm α'),
(e.permCongr p).trans (e.permCongr p') = e.permCongr (Equiv.trans p p') | false |
Int.gcd_comm | Init.Data.Int.Gcd | ∀ (a b : ℤ), a.gcd b = b.gcd a | true |
Algebra.Extension.tensorCotangentSpaceOfFormallyEtale._proof_7 | Mathlib.RingTheory.Etale.Kaehler | ∀ {R : Type u_4} {S : Type u_1} {T : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R T] [inst_4 : Algebra S T] {Q : Algebra.Extension R T}, SMulCommClass S Q.Ring T | false |
Std.Sat.AIG.Fanin.flip | Std.Sat.AIG.Basic | Std.Sat.AIG.Fanin → Bool → Std.Sat.AIG.Fanin | true |
Bornology.ofDist._proof_4 | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u_1} (dist : α → α → ℝ) (z : α), ∃ C, ∀ ⦃x : α⦄, x ∈ {z} → ∀ ⦃y : α⦄, y ∈ {z} → dist x y ≤ C | false |
_private.Aesop.Forward.State.0.Aesop.ForwardState.enqueuePatSubsts.match_1 | Aesop.Forward.State | (motive : Aesop.ForwardRule × Aesop.Substitution → Sort u_1) →
(x : Aesop.ForwardRule × Aesop.Substitution) →
((r : Aesop.ForwardRule) → (patSubst : Aesop.Substitution) → motive (r, patSubst)) → motive x | false |
MeasurableSpace.generateMeasurable_eq_rec | Mathlib.MeasureTheory.MeasurableSpace.Card | ∀ {α : Type u} (s : Set (Set α)),
{t | MeasurableSpace.GenerateMeasurable s t} = MeasurableSpace.generateMeasurableRec s (Ordinal.omega 1) | true |
Aesop.ScriptGenerated.Method.rec | Aesop.Stats.Basic | {motive : Aesop.ScriptGenerated.Method → Sort u} →
motive Aesop.ScriptGenerated.Method.static →
motive Aesop.ScriptGenerated.Method.dynamic → (t : Aesop.ScriptGenerated.Method) → motive t | false |
List.infix_append'._simp_1 | Init.Data.List.Sublist | ∀ {α : Type u_1} (l₁ l₂ l₃ : List α), (l₂ <:+: l₁ ++ (l₂ ++ l₃)) = True | false |
IsStrictOrderedRing.toContinuousInv₀ | Mathlib.Topology.Algebra.Order.Field | ∀ {𝕜 : Type u_1} [inst : Semifield 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [inst_3 : TopologicalSpace 𝕜]
[OrderTopology 𝕜] [ContinuousMul 𝕜], ContinuousInv₀ 𝕜 | true |
ProfiniteAddGrp.limitConePtAux._proof_3 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {J : Type u_2} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J ProfiniteAddGrp.{max u_2 u_1})
{x : (j : J) → ↑(F.obj j).toProfinite.toTop},
x ∈ {x | ∀ ⦃i j : J⦄ (π : i ⟶ j), (ProfiniteAddGrp.Hom.hom (F.map π)) (x i) = x j} →
∀ (x_1 x_2 : J) (π : x_1 ⟶ x_2), (ProfiniteAddGrp.Hom.hom (F.ma... | false |
CategoryTheory.SimplicialThickening.mk.sizeOf_spec | Mathlib.AlgebraicTopology.SimplicialNerve | ∀ {J : Type u_1} [inst : LinearOrder J] [inst_1 : SizeOf J] (as : J), sizeOf { as := as } = 1 + sizeOf as | true |
IsClosed.upperSemicontinuousAt_indicator | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] {s : Set α} {x : α} {y : β} [inst_1 : Zero β]
[inst_2 : Preorder β], IsClosed s → 0 ≤ y → UpperSemicontinuousAt (s.indicator fun _x => y) x | true |
_private.Init.Data.Vector.Lemmas.0.Vector.mem_of_getElem?.match_1_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i : ℕ} {a : α} (motive : (∃ (h : i < n), xs[i] = a) → Prop)
(x : ∃ (h : i < n), xs[i] = a), (∀ (w : i < n) (e : xs[i] = a), motive ⋯) → motive x | false |
Lean.Server.Test.Runner.Client.instFromJsonInfoPopup.fromJson | Lean.Server.Test.Runner | Lean.Json → Except String Lean.Server.Test.Runner.Client.InfoPopup | true |
ContinuousMultilinearMap.sum_apply | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] [inst_5 : (i : ι) → TopologicalSpace (M₁ i)] [inst_6 : TopologicalSpace M₂]
[inst_7 : ContinuousAdd M₂... | true |
IO.FS.Metadata.numLinks | Init.System.IO | IO.FS.Metadata → UInt64 | true |
FintypeCat.equivEquivIso_symm_apply_apply | Mathlib.CategoryTheory.FintypeCat | ∀ {A B : FintypeCat} (i : A ≅ B) (a : A.obj),
(FintypeCat.equivEquivIso.symm i) a = (CategoryTheory.ConcreteCategory.hom i.hom) a | true |
CategoryTheory.Lax.LaxTrans.homCategory.ext_iff | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.LaxFunctor B C} {η θ : F ⟶ G} {Γ Δ : η ⟶ θ}, Γ = Δ ↔ ∀ (a : B), Γ.as.app a = Δ.as.app a | true |
Lean.SourceInfo.none.sizeOf_spec | Init.SizeOf | sizeOf Lean.SourceInfo.none = 1 | true |
ContinuousMultilinearMap.mk.inj | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} {inst : Semiring R}
{inst_1 : (i : ι) → AddCommMonoid (M₁ i)} {inst_2 : AddCommMonoid M₂} {inst_3 : (i : ι) → Module R (M₁ i)}
{inst_4 : Module R M₂} {inst_5 : (i : ι) → TopologicalSpace (M₁ i)} {inst_6 : TopologicalSpace M₂}
{toMultilinearMap : Multil... | true |
CategoryTheory.Limits.cokernel.condition_apply | Mathlib.CategoryTheory.ConcreteCategory.Elementwise | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
(f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasCokernel f] {F : C → C → Type uF} {carrier : C → Type w}
{instFunLike : (X Y : C) → FunLike (F X Y) (carrier X) (carrier Y)} [inst_3 : CategoryTheory.... | true |
UniformContinuous.nndist | Mathlib.Topology.MetricSpace.Pseudo.Constructions | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoMetricSpace α] [inst_1 : UniformSpace β] {f g : β → α},
UniformContinuous f → UniformContinuous g → UniformContinuous fun b => nndist (f b) (g b) | true |
ComplexShape.σ_def | Mathlib.Algebra.Homology.ComplexShapeSigns | ∀ (p q : ℤ),
TotalComplexShapeSymmetry.σ (ComplexShape.up ℤ) (ComplexShape.up ℤ) (ComplexShape.up ℤ) p q = (p * q).negOnePow | true |
Submodule.adjoint._proof_3 | Mathlib.Analysis.InnerProductSpace.LinearPMap | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜], RingHomInvPair (RingHom.id 𝕜) (RingHom.id 𝕜) | false |
Valued.instFaithfulSMulCompletionOfUniformContinuousConstSMul | Mathlib.Topology.Algebra.Valued.ValuedField | ∀ {K : Type u_1} [inst : Field K] {Γ₀ : Type u_2} [inst_1 : LinearOrderedCommGroupWithZero Γ₀] [hv : Valued K Γ₀]
{R : Type u_3} [inst_2 : CommSemiring R] [inst_3 : Algebra R K] [UniformContinuousConstSMul R K] [FaithfulSMul R K],
FaithfulSMul R (UniformSpace.Completion K) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.