name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Aesop.instInhabitedRulePattern | Aesop.RulePattern | Inhabited Aesop.RulePattern | true |
Lean.Meta.getCoeFnInfo? | Lean.Meta.CoeAttr | Lean.Name → Lean.CoreM (Option Lean.Meta.CoeFnInfo) | true |
AddEquiv.symm_map_add | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_9} {N : Type u_10} [inst : Add M] [inst_1 : Add N] (h : M ≃+ N) (x y : N),
h.symm (x + y) = h.symm x + h.symm y | true |
MvPolynomial.instIsPushout | Mathlib.RingTheory.TensorProduct.MvPolynomial | ∀ {R : Type u} [inst : CommSemiring R] {σ : Type u_1} {S : Type u_3} [inst_1 : CommSemiring S] [inst_2 : Algebra R S],
Algebra.IsPushout R S (MvPolynomial σ R) (MvPolynomial σ S) | true |
Aesop.UnsafeRuleInfo.mk.injEq | Aesop.Rule | ∀ (successProbability successProbability_1 : Aesop.Percent),
({ successProbability := successProbability } = { successProbability := successProbability_1 }) =
(successProbability = successProbability_1) | true |
QuadraticAlgebra.mk_eq_add_smul_omega | Mathlib.Algebra.QuadraticAlgebra.Basic | ∀ {R : Type u_1} {a b : R} [inst : CommSemiring R] (x y : R),
{ re := x, im := y } = (algebraMap R (QuadraticAlgebra R a b)) x + y • QuadraticAlgebra.omega | true |
UniformFun.uniformCore.match_7 | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ (β : Type u_1) [inst : UniformSpace β] (w : Set (β × β)) (motive : (∃ t ∈ uniformity β, SetRel.comp t t ⊆ w) → Prop)
(x : ∃ t ∈ uniformity β, SetRel.comp t t ⊆ w),
(∀ (W : Set (β × β)) (hW : W ∈ uniformity β) (hWV : SetRel.comp W W ⊆ w), motive ⋯) → motive x | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getKey!_alter._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
tsum_geometric_two' | Mathlib.Analysis.SpecificLimits.Basic | ∀ (a : ℝ), ∑' (n : ℕ), a / 2 / 2 ^ n = a | true |
_private.Std.Data.DHashMap.Internal.Defs.0.Std.DHashMap.Internal.Raw₀.insert._proof_3 | Std.Data.DHashMap.Internal.Defs | ∀ {α : Type u_1} {β : α → Type u_2} (a : α) (b : β a) (size : ℕ)
(buckets : Array (Std.DHashMap.Internal.AssocList α β)),
0 < { size := size, buckets := buckets }.buckets.size →
∀ (i : USize) (h : i.toNat < buckets.size),
0 <
{ size := size + 1,
buckets := buckets.uset i (Std.DHashMap.Internal.AssocList.cons a b buckets[i]) h }.buckets.size | false |
Lean.instReprDefinitionSafety | Lean.Declaration | Repr Lean.DefinitionSafety | true |
Aesop.Script.StaticStructureM.Context._sizeOf_1 | Aesop.Script.StructureStatic | Aesop.Script.StaticStructureM.Context → ℕ | false |
Lean.VersoModuleDocs.isEmpty | Lean.DocString.Extension | Lean.VersoModuleDocs → Bool | true |
Set.Finite.encard_biUnion_le | Mathlib.Data.Set.Card.Arithmetic | ∀ {α : Type u_1} {ι : Type u_2} {t : Set ι},
t.Finite → ∀ (s : ι → Set α), (⋃ i ∈ t, s i).encard ≤ ∑ᶠ (i : ι) (_ : i ∈ t), (s i).encard | true |
Pi.counit_single | Mathlib.RingTheory.Coalgebra.Basic | ∀ {R : Type u_1} {n : Type u_2} [inst : CommSemiring R] [inst_1 : Fintype n] [inst_2 : DecidableEq n] {A : n → Type u_3}
[inst_3 : (i : n) → AddCommMonoid (A i)] [inst_4 : (i : n) → Module R (A i)]
[inst_5 : (i : n) → CoalgebraStruct R (A i)] (i : n) (a : A i),
CoalgebraStruct.counit (Pi.single i a) = CoalgebraStruct.counit a | true |
Set.prod_add_prod_comm | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Add α] [inst_1 : Add β] (s₁ s₂ : Set α) (t₁ t₂ : Set β),
s₁ ×ˢ t₁ + s₂ ×ˢ t₂ = (s₁ + s₂) ×ˢ (t₁ + t₂) | true |
SpectrumRestricts.compactSpace | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Restrict | ∀ {R : Type u_1} {S : Type u_2} {A : Type u_3} [inst : Semifield R] [inst_1 : Semifield S] [inst_2 : Ring A]
[inst_3 : Algebra R S] [inst_4 : Algebra R A] [inst_5 : Algebra S A] [IsScalarTower R S A]
[inst_7 : TopologicalSpace R] [inst_8 : TopologicalSpace S] {a : A} (f : C(S, R)),
SpectrumRestricts a ⇑f → ∀ [h_cpct : CompactSpace ↑(spectrum S a)], CompactSpace ↑(spectrum R a) | true |
Lean.Parser.Term.num.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | true |
AddSubgroup.addCommutator_eq_bot_iff_le_centralizer | Mathlib.GroupTheory.Commutator.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {H₁ H₂ : AddSubgroup G}, ⁅H₁, H₂⁆ = ⊥ ↔ H₁ ≤ AddSubgroup.centralizer ↑H₂ | true |
Subsemigroup.centerToMulOpposite._proof_2 | Mathlib.GroupTheory.Submonoid.Center | ∀ {M : Type u_1} [inst : Mul M],
Function.RightInverse (fun r => ⟨MulOpposite.unop ↑r, ⋯⟩) fun r => ⟨MulOpposite.op ↑r, ⋯⟩ | false |
_private.Lean.Elab.DeclModifiers.0.Lean.Elab.Visibility.isPublic._sparseCasesOn_1 | Lean.Elab.DeclModifiers | {motive : Lean.Elab.Visibility → Sort u} →
(t : Lean.Elab.Visibility) → motive Lean.Elab.Visibility.public → (Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | false |
CategoryTheory.LocalizerMorphism.homMap_comp | Mathlib.CategoryTheory.Localization.HomEquiv | ∀ {C₁ : Type u_2} {C₂ : Type u_3} {D₁ : Type u_5} {D₂ : Type u_6} [inst : CategoryTheory.Category.{v_2, u_2} C₁]
[inst_1 : CategoryTheory.Category.{v_3, u_3} C₂] [inst_2 : CategoryTheory.Category.{v_5, u_5} D₁]
[inst_3 : CategoryTheory.Category.{v_6, u_6} D₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} (Φ : CategoryTheory.LocalizerMorphism W₁ W₂)
(L₁ : CategoryTheory.Functor C₁ D₁) [inst_4 : L₁.IsLocalization W₁] (L₂ : CategoryTheory.Functor C₂ D₂)
[inst_5 : L₂.IsLocalization W₂] {X Y Z : C₁} (f : L₁.obj X ⟶ L₁.obj Y) (g : L₁.obj Y ⟶ L₁.obj Z),
Φ.homMap L₁ L₂ (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (Φ.homMap L₁ L₂ f) (Φ.homMap L₁ L₂ g) | true |
CochainComplex.HomComplex.Cochain.ofHom_v | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{F G : CochainComplex C ℤ} (φ : F ⟶ G) (p : ℤ), (CochainComplex.HomComplex.Cochain.ofHom φ).v p p ⋯ = φ.f p | true |
_private.Mathlib.Data.Nat.Log.0.Nat.log.go_spec._simp_1_4 | Mathlib.Data.Nat.Log | ∀ {n : ℕ}, (1 ≤ n) = (n ≠ 0) | false |
RootPairing.EmbeddedG2.mem_span_of_mem_allRoots | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N)
[inst_5 : P.EmbeddedG2] [Finite ι] [CharZero R] [IsDomain R] {x : M},
x ∈ RootPairing.EmbeddedG2.allRoots P →
x ∈ Submodule.span ℤ {RootPairing.EmbeddedG2.longRoot P, RootPairing.EmbeddedG2.shortRoot P} | true |
Batteries.RBNode.Balanced.below.casesOn | Batteries.Data.RBMap.Basic | ∀ {α : Type u_1} {motive : (a : Batteries.RBNode α) → (a_1 : Batteries.RBColor) → (a_2 : ℕ) → a.Balanced a_1 a_2 → Prop}
{motive_1 :
{a : Batteries.RBNode α} →
{a_1 : Batteries.RBColor} → {a_2 : ℕ} → (t : a.Balanced a_1 a_2) → Batteries.RBNode.Balanced.below t → Prop}
{a : Batteries.RBNode α} {a_1 : Batteries.RBColor} {a_2 : ℕ} {t : a.Balanced a_1 a_2}
(t_1 : Batteries.RBNode.Balanced.below t),
motive_1 ⋯ ⋯ →
(∀ {x : Batteries.RBNode α} {n : ℕ} {y : Batteries.RBNode α} {v : α} (a : x.Balanced Batteries.RBColor.black n)
(a_3 : y.Balanced Batteries.RBColor.black n) (ih : Batteries.RBNode.Balanced.below a)
(a_ih : motive x Batteries.RBColor.black n a) (ih_1 : Batteries.RBNode.Balanced.below a_3)
(a_ih_1 : motive y Batteries.RBColor.black n a_3), motive_1 ⋯ ⋯) →
(∀ {x : Batteries.RBNode α} {c₁ : Batteries.RBColor} {n : ℕ} {y : Batteries.RBNode α} {c₂ : Batteries.RBColor}
{v : α} (a : x.Balanced c₁ n) (a_3 : y.Balanced c₂ n) (ih : Batteries.RBNode.Balanced.below a)
(a_ih : motive x c₁ n a) (ih_1 : Batteries.RBNode.Balanced.below a_3) (a_ih_1 : motive y c₂ n a_3),
motive_1 ⋯ ⋯) →
motive_1 t t_1 | false |
CategoryTheory.ProjectiveResolution.ofComplex._proof_3 | Mathlib.CategoryTheory.Abelian.Projective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {X₀ X₁ : C}
(f : X₁ ⟶ X₀), CategoryTheory.Limits.HasKernel f | false |
Algebra.Etale.comp | Mathlib.RingTheory.Etale.Basic | ∀ (R : Type u) (A : Type v) (B : Type u_1) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : CommRing B] [inst_4 : Algebra R B] [inst_5 : Algebra A B] [IsScalarTower R A B] [Algebra.Etale R A]
[Algebra.Etale A B], Algebra.Etale R B | true |
EuclideanGeometry.eq_of_dist_eq_of_dist_eq_of_finrank_eq_two | Mathlib.Geometry.Euclidean.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[NormedAddTorsor V P] [FiniteDimensional ℝ V],
Module.finrank ℝ V = 2 →
∀ {c₁ c₂ p₁ p₂ p : P} {r₁ r₂ : ℝ},
c₁ ≠ c₂ →
p₁ ≠ p₂ →
dist p₁ c₁ = r₁ →
dist p₂ c₁ = r₁ → dist p c₁ = r₁ → dist p₁ c₂ = r₂ → dist p₂ c₂ = r₂ → dist p c₂ = r₂ → p = p₁ ∨ p = p₂ | true |
Lean.Doc.Parser.InList.mk._flat_ctor | Lean.DocString.Parser | ℕ → Lean.Doc.Parser.OrderedListType ⊕ Lean.Doc.Parser.UnorderedListType → Lean.Doc.Parser.InList | false |
AddCircle.liftIoc_zero_continuous | Mathlib.Topology.Instances.AddCircle.Defs | ∀ {𝕜 : Type u_1} {B : Type u_2} [inst : AddCommGroup 𝕜] [inst_1 : LinearOrder 𝕜] [inst_2 : IsOrderedAddMonoid 𝕜] {p : 𝕜}
[hp : Fact (0 < p)] [inst_3 : Archimedean 𝕜] [inst_4 : TopologicalSpace 𝕜] [OrderTopology 𝕜]
[inst_6 : TopologicalSpace B] {f : 𝕜 → B},
f 0 = f p → ContinuousOn f (Set.Icc 0 p) → Continuous (AddCircle.liftIoc p 0 f) | true |
List.mem_attach | Init.Data.List.Attach | ∀ {α : Type u_1} (l : List α) (x : { x // x ∈ l }), x ∈ l.attach | true |
ODE.FunSpace.mk.congr_simp | Mathlib.Analysis.ODE.PicardLindelof | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] {tmin tmax : ℝ} {t₀ : ↑(Set.Icc tmin tmax)} {x₀ : E} {r L : NNReal}
(toFun toFun_1 : ↑(Set.Icc tmin tmax) → E) (e_toFun : toFun = toFun_1) (lipschitzWith : LipschitzWith L toFun)
(mem_closedBall₀ : toFun t₀ ∈ Metric.closedBall x₀ ↑r),
{ toFun := toFun, lipschitzWith := lipschitzWith, mem_closedBall₀ := mem_closedBall₀ } =
{ toFun := toFun_1, lipschitzWith := ⋯, mem_closedBall₀ := ⋯ } | true |
RingHom.codomain_trivial_iff_range_trivial | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_2} {β : Type u_3} {x : NonAssocSemiring α} {x_1 : NonAssocSemiring β} (f : α →+* β),
0 = 1 ↔ ∀ (x_2 : α), f x_2 = 0 | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastMul._proof_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul | ∀ {w : ℕ}, ¬w = 0 → ¬0 < w → False | false |
CategoryTheory.Limits.CatCospanTransformMorphism.left_coherence_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {A' : Type u₄} {B' : Type u₅} {C' : Type u₆}
[inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B}
[inst_3 : CategoryTheory.Category.{v₄, u₄} A'] [inst_4 : CategoryTheory.Category.{v₅, u₅} B']
[inst_5 : CategoryTheory.Category.{v₆, u₆} C'] {F' : CategoryTheory.Functor A' B'} {G' : CategoryTheory.Functor C' B'}
{ψ ψ' : CategoryTheory.Limits.CatCospanTransform F G F' G'}
(self : CategoryTheory.Limits.CatCospanTransformMorphism ψ ψ') {Z : CategoryTheory.Functor A B'}
(h : ψ'.left.comp F' ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CatCommSq.iso F ψ.left ψ.base F').hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.whiskerRight self.left F') h) =
CategoryTheory.CategoryStruct.comp (F.whiskerLeft self.base)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.CatCommSq.iso F ψ'.left ψ'.base F').hom h) | true |
_private.Lean.Meta.Tactic.Grind.Action.0.Lean.Meta.Grind.Action.orElse.eq_1 | Lean.Meta.Tactic.Grind.Action | ∀ (x y : Lean.Meta.Grind.Action) (goal : Lean.Meta.Grind.Goal) (kna kp : Lean.Meta.Grind.ActionCont),
x.orElse y goal kna kp = x goal (fun goal => y goal kna kp) kp | true |
FinTopCat.of | Mathlib.Topology.Category.FinTopCat | (X : Type u) → [Fintype X] → [TopologicalSpace X] → FinTopCat | true |
Real.le_arcsin_iff_sin_le | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ∀ {x y : ℝ}, x ∈ Set.Icc (-(Real.pi / 2)) (Real.pi / 2) → y ∈ Set.Icc (-1) 1 → (x ≤ Real.arcsin y ↔ Real.sin x ≤ y) | true |
CategoryTheory.Square.Hom | Mathlib.CategoryTheory.Square | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.Square C → CategoryTheory.Square C → Type v | true |
_private.Mathlib.GroupTheory.ResiduallyFinite.0.Group.residuallyFinite_iff_forall_finiteIndexNormalSubgroup._simp_1_1 | Mathlib.GroupTheory.ResiduallyFinite | ∀ {G : Type u_1} [inst : Group G], Group.ResiduallyFinite G = (⨅ H, H.toSubgroup = ⊥) | false |
CentroidHom.centerToCentroidCenter._proof_6 | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_1} [inst : NonUnitalNonAssocSemiring α] (z : ↥(NonUnitalSubsemiring.center α)) (b c : α),
↑z * (b * c) = ↑z * b * c | false |
Nat.Partition.mk | Mathlib.Combinatorics.Enumerative.Partition.Basic | {n : ℕ} → (parts : Multiset ℕ) → (∀ {i : ℕ}, i ∈ parts → 0 < i) → parts.sum = n → n.Partition | true |
Lean.Meta.Grind.AC.ACM.Context.mk.inj | Lean.Meta.Tactic.Grind.AC.Util | ∀ {opId opId_1 : ℕ}, { opId := opId } = { opId := opId_1 } → opId = opId_1 | true |
AlgebraicGeometry.Spec.fiberToSpecResidueFieldIso._proof_3 | Mathlib.AlgebraicGeometry.Fiber | ∀ (R : Type u_1) [inst : CommRing R] (p : PrimeSpectrum R), p.asIdeal.IsPrime | false |
spectrum.inv₀_mem | Mathlib.Algebra.Algebra.Spectrum.Basic | ∀ {R : Type u} {A : Type v} [inst : Semifield R] [inst_1 : Ring A] [inst_2 : Algebra R A] {r : R} {a : Aˣ},
r ∈ spectrum R ↑a⁻¹ → r⁻¹ ∈ spectrum R ↑a | true |
DirectLimit.instDivisionRing._proof_5 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (i : ι) → DivisionRing (G i)] [inst_6 : ∀ (i j : ι) (h : i ≤ j), RingHomClass (T h) (G i) (G j)]
(a : DirectLimit G f), Ring.zsmul 0 a = 0 | false |
SemidirectProduct.inl._proof_1 | Mathlib.GroupTheory.SemidirectProduct | ∀ {N : Type u_1} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {φ : G →* MulAut N} (x y : N),
⟨x * y, 1⟩ = ⟨x, 1⟩ * ⟨y, 1⟩ | false |
Std.Iterators.Types.ULiftIterator.ctorIdx | Init.Data.Iterators.Combinators.Monadic.ULift | {α : Type u} →
{m : Type u → Type u'} →
{n : Type (max u v) → Type v'} →
{β : Type u} →
{lift : ⦃γ : Type u⦄ → m γ → Std.Iterators.ULiftT n γ} → Std.Iterators.Types.ULiftIterator α m n β lift → ℕ | false |
intervalIntegral.integral_mono_on | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {f g : ℝ → ℝ} {a b : ℝ} {μ : MeasureTheory.Measure ℝ},
a ≤ b →
IntervalIntegrable f μ a b →
IntervalIntegrable g μ a b →
(∀ x ∈ Set.Icc a b, f x ≤ g x) → ∫ (u : ℝ) in a..b, f u ∂μ ≤ ∫ (u : ℝ) in a..b, g u ∂μ | true |
Filter.comap_cofinite_le | Mathlib.Order.Filter.Cofinite | ∀ {α : Type u_2} {β : Type u_3} (f : α → β), Filter.comap f Filter.cofinite ≤ Filter.cofinite | true |
Lean.Parser.Command.eoi._regBuiltin.Lean.Parser.Command.eoi.parenthesizer_7 | Lean.Parser.Command | IO Unit | false |
List.isEqv.match_1 | Init.Data.List.Basic | {α : Type u_1} →
(motive : List α → List α → (α → α → Bool) → Sort u_2) →
(x x_1 : List α) →
(x_2 : α → α → Bool) →
((x : α → α → Bool) → motive [] [] x) →
((a : α) → (as : List α) → (b : α) → (bs : List α) → (eqv : α → α → Bool) → motive (a :: as) (b :: bs) eqv) →
((x x_3 : List α) → (x_4 : α → α → Bool) → motive x x_3 x_4) → motive x x_1 x_2 | false |
Geometry.SimplicialComplex.faces_bot | Mathlib.Analysis.Convex.SimplicialComplex.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Ring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E], ⊥.faces = ∅ | true |
Subring.instInfSet | Mathlib.Algebra.Ring.Subring.Basic | {R : Type u} → [inst : NonAssocRing R] → InfSet (Subring R) | true |
ComputeAsymptotics.MultiseriesExpansion.Multiseries.cons_eq_cons._simp_1 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Defs | ∀ {basis_hd : ℝ → ℝ} {basis_tl : ComputeAsymptotics.Basis} {exp1 exp2 : ℝ}
{coef1 coef2 : ComputeAsymptotics.MultiseriesExpansion basis_tl}
{tl1 tl2 : ComputeAsymptotics.MultiseriesExpansion.Multiseries basis_hd basis_tl},
(ComputeAsymptotics.MultiseriesExpansion.Multiseries.cons exp1 coef1 tl1 =
ComputeAsymptotics.MultiseriesExpansion.Multiseries.cons exp2 coef2 tl2) =
(exp1 = exp2 ∧ coef1 = coef2 ∧ tl1 = tl2) | false |
CategoryTheory.Functor.OneHypercoverDenseData.SieveStruct.i₀ | 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} →
{J₀ : CategoryTheory.GrothendieckTopology C₀} →
{J : CategoryTheory.GrothendieckTopology C} →
{X : C} →
{data : F.OneHypercoverDenseData J₀ J X} →
{X₀ : C₀} → {f : F.obj X₀ ⟶ X} → {Y₀ : C₀} → {g : Y₀ ⟶ X₀} → data.SieveStruct f g → data.I₀ | true |
Lean.Lsp.instFromJsonLocation.fromJson | Lean.Data.Lsp.Basic | Lean.Json → Except String Lean.Lsp.Location | true |
Aesop.ForwardRuleMatch.foldHypsM | Aesop.Forward.Match | {M : Type u_1 → Type u_2} → {σ : Type u_1} → [Monad M] → (σ → Lean.FVarId → M σ) → σ → Aesop.ForwardRuleMatch → M σ | true |
Lean.Meta.LazyDiscrTree.ImportData.casesOn | Lean.Meta.LazyDiscrTree | {motive : Lean.Meta.LazyDiscrTree.ImportData → Sort u} →
(t : Lean.Meta.LazyDiscrTree.ImportData) →
((errors : IO.Ref (Array Lean.Meta.LazyDiscrTree.ImportFailure)) → motive { errors := errors }) → motive t | false |
_private.Mathlib.Data.Option.NAry.0.Option.map_map₂_distrib_right._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' a (g' b)) → Option.map g (Option.map₂ f a b) = Option.map₂ f' a (Option.map g' b) | false |
TemperedDistribution.fourierMultiplierCLM_toTemperedDistributionCLM_eq | Mathlib.Analysis.Distribution.FourierMultiplier | ∀ {E : Type u_3} {F : Type u_4} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F]
[inst_2 : InnerProductSpace ℝ E] [inst_3 : NormedSpace ℂ F] [inst_4 : FiniteDimensional ℝ E]
[inst_5 : MeasurableSpace E] [inst_6 : BorelSpace E] [CompleteSpace F] {g : E → ℂ},
Function.HasTemperateGrowth g →
∀ (f : SchwartzMap E F),
(TemperedDistribution.fourierMultiplierCLM F g)
((SchwartzMap.toTemperedDistributionCLM E F MeasureTheory.volume) f) =
(SchwartzMap.toTemperedDistributionCLM E F MeasureTheory.volume) ((SchwartzMap.fourierMultiplierCLM F g) f) | true |
Lean.Meta.Grind.Arith.Cutsat.DvdSolution.mk | Lean.Meta.Tactic.Grind.Arith.Cutsat.Search | ℤ → ℤ → Lean.Meta.Grind.Arith.Cutsat.DvdSolution | true |
addCommutator_centralizer_addCommutator_le_center | Mathlib.GroupTheory.Commutator.Basic | ∀ (G : Type u_1) [inst : AddGroup G],
⁅AddSubgroup.centralizer ↑(addCommutator G), AddSubgroup.centralizer ↑(addCommutator G)⁆ ≤ AddSubgroup.center G | true |
AlgEquiv.ofBijective_symm_apply_apply | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Semiring A₂]
[inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] (f : A₁ →ₐ[R] A₂) (hf : Function.Bijective ⇑f) (x : A₁),
(AlgEquiv.ofBijective f hf).symm (f x) = x | true |
String.Pos.prev_toSlice._proof_2 | Init.Data.String.Lemmas.FindPos | ∀ {s : String} {p : s.Pos} {h : p.toSlice ≠ s.toSlice.startPos}, p ≠ s.startPos | false |
Vector.emptyWithCapacity._proof_1 | Init.Data.Vector.Basic | ∀ {α : Type u_1} (capacity : ℕ), (Array.emptyWithCapacity capacity).size = 0 | false |
Set.Nonempty.pow | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Monoid α] {s : Set α}, s.Nonempty → ∀ {n : ℕ}, (s ^ n).Nonempty | true |
Finsupp.mapRange.addMonoidHom_apply | Mathlib.Algebra.Group.Finsupp | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N] (f : M →+ N)
(g : ι →₀ M), (Finsupp.mapRange.addMonoidHom f) g = Finsupp.mapRange ⇑f ⋯ g | true |
Int.map_add_toList_rcc' | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n k : ℤ}, List.map (fun x => k + x) (m...=n).toList = ((k + m)...=k + n).toList | true |
NonUnitalNonAssocCommSemiring.toNonUnitalNonAssocSemiring | Mathlib.Algebra.Ring.Defs | {α : Type u} → [self : NonUnitalNonAssocCommSemiring α] → NonUnitalNonAssocSemiring α | true |
Lean.Elab.DefKind.example.sizeOf_spec | Lean.Elab.DefView | sizeOf Lean.Elab.DefKind.example = 1 | true |
_private.Mathlib.Computability.TuringMachine.ToPartrec.0.Turing.PartrecToTM2.trList.match_1.eq_2 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (motive : List ℕ → Sort u_1) (n : ℕ) (ns : List ℕ) (h_1 : Unit → motive [])
(h_2 : (n : ℕ) → (ns : List ℕ) → motive (n :: ns)),
(match n :: ns with
| [] => h_1 ()
| n :: ns => h_2 n ns) =
h_2 n ns | true |
Lean.Grind.OrderedRing.pos_intCast_of_pos | Init.Grind.Ordered.Ring | ∀ {R : Type u} [inst : Lean.Grind.Ring R] [inst_1 : LE R] [inst_2 : LT R] [Std.LawfulOrderLT R]
[inst_4 : Std.IsPreorder R] [Lean.Grind.OrderedRing R] (a : ℤ), 0 < a → 0 < ↑a | true |
ZeroAtInftyContinuousMap.instNonUnitalNonAssocSemiring._proof_1 | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : NonUnitalNonAssocSemiring β], Function.Injective fun f => ⇑f | false |
PUnit.lcm_eq | Mathlib.Algebra.GCDMonoid.PUnit | ∀ {x y : PUnit.{u_1 + 1}}, lcm x y = PUnit.unit | true |
Metric.thickening_subset_cthickening_of_le | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {δ₁ δ₂ : ℝ},
δ₁ ≤ δ₂ → ∀ (E : Set α), Metric.thickening δ₁ E ⊆ Metric.cthickening δ₂ E | true |
Equiv.Perm.IsCycle.sameCycle | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} {f : Equiv.Perm α} {x y : α}, f.IsCycle → f x ≠ x → f y ≠ y → f.SameCycle x y | true |
IsAdicComplete.StrictMono.liftRingHom._proof_4 | Mathlib.RingTheory.AdicCompletion.RingHom | ∀ {a : ℕ → ℕ}, StrictMono a → ∀ {m : ℕ}, a m ≤ a (m + 1) | false |
MeasureTheory.SimpleFunc.instRing | Mathlib.MeasureTheory.Function.SimpleFunc | {α : Type u_1} → {β : Type u_2} → [inst : MeasurableSpace α] → [Ring β] → Ring (MeasureTheory.SimpleFunc α β) | true |
Rep.FiniteCyclicGroup.moduleCatChainComplex._proof_1 | Mathlib.RepresentationTheory.Homological.FiniteCyclic | ∀ {k G : Type u_2} [inst : CommRing k] [inst_1 : CommGroup G] [inst_2 : Fintype G] (A : Rep.{u_1, u_2, u_2} k G)
(g : G),
CategoryTheory.CategoryStruct.comp (ModuleCat.ofHom (Rep.Hom.hom A.norm).toLinearMap)
(ModuleCat.ofHom (Rep.Hom.hom (A.applyAsHom g - CategoryTheory.CategoryStruct.id A)).toLinearMap) =
0 | false |
_private.Mathlib.NumberTheory.JacobiSum.Basic.0.jacobiSum_trivial_trivial._simp_1_1 | Mathlib.NumberTheory.JacobiSum.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (a ∈ s \ t) = (a ∈ s ∧ a ∉ t) | false |
_private.Mathlib.MeasureTheory.Measure.CharacteristicFunction.TaylorExpansion.0.MeasureTheory.iteratedFDeriv_charFun._simp_1_7 | Mathlib.MeasureTheory.Measure.CharacteristicFunction.TaylorExpansion | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | false |
SymAlg.unsym_ne_zero_iff | Mathlib.Algebra.Symmetrized | ∀ {α : Type u_1} [inst : Zero α] (a : αˢʸᵐ), SymAlg.unsym a ≠ 0 ↔ a ≠ 0 | true |
UnitAddTorus.coe_symm_measurableEquivPiIoc_apply | Mathlib.Analysis.Fourier.AddCircleMulti | ∀ {ι : Type u_2} (b : ι → ℝ) (y : { x // ∀ (i : ι), x i ∈ Set.Ioc (b i) (b i + 1) }),
(UnitAddTorus.measurableEquivPiIoc b).symm y = fun i => ↑(↑y i) | true |
IsCoveringMap.monodromy | Mathlib.Topology.Homotopy.Lifting | {E : Type u_1} →
{X : Type u_2} →
[inst : TopologicalSpace E] →
[inst_1 : TopologicalSpace X] →
{p : E → X} → IsCoveringMap p → {x y : X} → Path.Homotopic.Quotient x y → ↑(p ⁻¹' {x}) → ↑(p ⁻¹' {y}) | true |
Std.IterM.empty | Std.Data.Iterators.Producers.Monadic.Empty | (m : Type w → Type w') → (β : Type w) → Std.IterM m β | true |
_private.Lean.Meta.Tactic.Simp.Main.0.Lean.Meta.Simp.mainCore.match_1 | Lean.Meta.Tactic.Simp.Main | (motive : Lean.Meta.Simp.Result × Lean.Meta.Simp.State → Sort u_1) →
(__discr : Lean.Meta.Simp.Result × Lean.Meta.Simp.State) →
((r : Lean.Meta.Simp.Result) → (s : Lean.Meta.Simp.State) → motive (r, s)) → motive __discr | false |
_private.Lean.Server.Logging.0.Lean.Server.Logging.LogEntry.mk | Lean.Server.Logging | Std.Time.ZonedDateTime →
Lean.JsonRpc.MessageDirection → Lean.JsonRpc.MessageKind → Lean.JsonRpc.Message → Lean.Server.Logging.LogEntry✝ | true |
LieModule.maxTrivLinearMapEquivLieModuleHom._proof_7 | Mathlib.Algebra.Lie.Abelian | ∀ {R : Type u_1} [inst : CommRing R], RingHomInvPair (RingHom.id R) (RingHom.id R) | false |
BitVec.getMsbD_srem | Init.Data.BitVec.Bitblast | ∀ {w i : ℕ} {x y : BitVec w},
(x.srem y).getMsbD i =
match x.msb, y.msb with
| false, false => (x % y).getMsbD i
| false, true => (x % -y).getMsbD i
| true, false => (-(-x % y)).getMsbD i
| true, true => (-(-x % -y)).getMsbD i | true |
LinearMap.proj_surjective | Mathlib.LinearAlgebra.Pi | ∀ {R : Type u} {ι : Type x} [inst : Semiring R] {φ : ι → Type i} [inst_1 : (i : ι) → AddCommMonoid (φ i)]
[inst_2 : (i : ι) → Module R (φ i)] (i : ι), Function.Surjective ⇑(LinearMap.proj i) | true |
_private.Mathlib.Analysis.Meromorphic.NormalForm.0.MeromorphicOn.toMeromorphicNFOn_eq_self_on_nhdsNE._simp_1_2 | Mathlib.Analysis.Meromorphic.NormalForm | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) | false |
FirstOrder.Language.ElementaryEmbedding.comp_apply | Mathlib.ModelTheory.ElementaryMaps | ∀ {L : FirstOrder.Language} {M : Type u_1} {N : Type u_2} {P : Type u_3} [inst : L.Structure M] [inst_1 : L.Structure N]
[inst_2 : L.Structure P] (g : L.ElementaryEmbedding N P) (f : L.ElementaryEmbedding M N) (x : M),
(g.comp f) x = g (f x) | true |
sizeOf_default | Init.SizeOf | ∀ {α : Sort u_1} (n : α), sizeOf n = 0 | true |
_private.Mathlib.NumberTheory.ModularForms.CongruenceSubgroups.0.CongruenceSubgroup.exists_Gamma_le_conj._simp_1_6 | Mathlib.NumberTheory.ModularForms.CongruenceSubgroups | ∀ {n : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] (M : Matrix n n ℤ),
(M.map fun x => ↑x).det = ↑M.det | false |
_private.Mathlib.Order.Filter.Tendsto.0.Filter.Tendsto.if._simp_1_1 | Mathlib.Order.Filter.Tendsto | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l₁ : Filter α} {l₂ : Filter β},
Filter.Tendsto f l₁ l₂ = ∀ s ∈ l₂, f ⁻¹' s ∈ l₁ | false |
Lean.Widget.MsgEmbed.brecOn_3.eq | Lean.Widget.InteractiveDiagnostic | ∀ {motive_1 : Lean.Widget.MsgEmbed → Sort u} {motive_2 : Lean.Widget.TaggedText Lean.Widget.MsgEmbed → Sort u}
{motive_3 :
Lean.Widget.StrictOrLazy (Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed))
(Lean.Server.WithRpcRef Lean.Widget.LazyTraceChildren) →
Sort u}
{motive_4 : Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed) → Sort u}
{motive_5 : List (Lean.Widget.TaggedText Lean.Widget.MsgEmbed) → Sort u}
(t : Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed)) (F_1 : (t : Lean.Widget.MsgEmbed) → t.below → motive_1 t)
(F_2 : (t : Lean.Widget.TaggedText Lean.Widget.MsgEmbed) → Lean.Widget.MsgEmbed.below_1 t → motive_2 t)
(F_3 :
(t :
Lean.Widget.StrictOrLazy (Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed))
(Lean.Server.WithRpcRef Lean.Widget.LazyTraceChildren)) →
Lean.Widget.MsgEmbed.below_2 t → motive_3 t)
(F_4 : (t : Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed)) → Lean.Widget.MsgEmbed.below_3 t → motive_4 t)
(F_5 : (t : List (Lean.Widget.TaggedText Lean.Widget.MsgEmbed)) → Lean.Widget.MsgEmbed.below_4 t → motive_5 t),
Lean.Widget.MsgEmbed.brecOn_3 t F_1 F_2 F_3 F_4 F_5 = F_4 t (Lean.Widget.MsgEmbed.brecOn_3.go t F_1 F_2 F_3 F_4 F_5).2 | true |
ProbabilityTheory.Kernel.instIsFiniteKernelWithDensityRnDeriv | Mathlib.Probability.Kernel.RadonNikodym | ∀ {α : Type u_1} {γ : Type u_2} {mα : MeasurableSpace α} {mγ : MeasurableSpace γ} {κ η : ProbabilityTheory.Kernel α γ}
[hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ] [hκ : ProbabilityTheory.IsFiniteKernel κ]
[inst : ProbabilityTheory.IsFiniteKernel η], ProbabilityTheory.IsFiniteKernel (η.withDensity (κ.rnDeriv η)) | true |
contDiffAt_fun_id | Mathlib.Analysis.Calculus.ContDiff.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {n : WithTop ℕ∞} {x : E}, ContDiffAt 𝕜 n (fun x => x) x | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.