name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
ContDiffMapSupportedIn.toFun | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | {E : Type u_2} →
{F : Type u_3} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
[inst_2 : NormedAddCommGroup F] →
[inst_3 : NormedSpace ℝ F] →
{n : ℕ∞} → {K : TopologicalSpace.Compacts E} → ContDiffMapSupportedIn E F n K → E → F | true |
Int.«_aux_Mathlib_Algebra_Order_Floor_Defs___macroRules_Int_term⌈_⌉_1» | Mathlib.Algebra.Order.Floor.Defs | Lean.Macro | false |
UniqueFactorizationMonoid.recOn | Mathlib.RingTheory.UniqueFactorizationDomain.Defs | {α : Type u_2} →
[inst : CommMonoidWithZero α] →
{motive : UniqueFactorizationMonoid α → Sort u} →
(t : UniqueFactorizationMonoid α) →
([toIsCancelMulZero : IsCancelMulZero α] →
[toIsWellFounded : IsWellFounded α DvdNotUnit] →
(irreducible_iff_prime : ∀ {a : α}, Irreducible a ↔ Prime a) → motive ⋯) →
motive t | false |
Polynomial.Bivariate.equivMvPolynomial_symm_X_0 | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u_1} [inst : CommSemiring R],
(Polynomial.Bivariate.equivMvPolynomial R).symm (MvPolynomial.X 0) = Polynomial.C Polynomial.X | true |
Lean.AssocList.brecOn.eq | Lean.Data.AssocList | ∀ {α : Type u} {β : Type v} {motive : Lean.AssocList α β → Sort u_1} (t : Lean.AssocList α β)
(F_1 : (t : Lean.AssocList α β) → Lean.AssocList.below t → motive t),
Lean.AssocList.brecOn t F_1 = F_1 t (Lean.AssocList.brecOn.go t F_1).2 | true |
CategoryTheory.Bicategory.associator_naturality_middle | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : B} (f : a ⟶ b) {g g' : b ⟶ c} (η : g ⟶ g') (h : c ⟶ d),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (CategoryTheory.Bicategory.whiskerLeft f η) h)
(CategoryTheory.Bicategory.associator f g' h).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator f g h).hom
(CategoryTheory.Bicategory.whiskerLeft f (CategoryTheory.Bicategory.whiskerRight η h)) | true |
Std.DTreeMap.Internal.Impl.maxEntry.induct_unfolding | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v}
(motive : (t : Std.DTreeMap.Internal.Impl α β) → t.isEmpty = false → (a : α) × β a → Prop),
(∀ (size : ℕ) (k : α) (v : β k) (l : Std.DTreeMap.Internal.Impl α β)
(x : (Std.DTreeMap.Internal.Impl.inner size k v l Std.DTreeMap.Internal.Impl.leaf).isEmpty = false),
(Std.DTreeMap.Internal.Impl.inner size k v l Std.DTreeMap.Internal.Impl.leaf).isEmpty = false →
motive (Std.DTreeMap.Internal.Impl.inner size k v l Std.DTreeMap.Internal.Impl.leaf) x ⟨k, v⟩) →
(∀ (size : ℕ) (k : α) (v : β k) (l : Std.DTreeMap.Internal.Impl α β) (size_1 : ℕ) (k_1 : α) (v_1 : β k_1)
(l_1 r : Std.DTreeMap.Internal.Impl α β)
(h :
(Std.DTreeMap.Internal.Impl.inner size k v l
(Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r)).isEmpty =
false),
(Std.DTreeMap.Internal.Impl.inner size k v l (Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r)).isEmpty =
false →
motive (Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r) ⋯
((Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r).maxEntry ⋯) →
motive (Std.DTreeMap.Internal.Impl.inner size k v l (Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r))
h ((Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r).maxEntry ⋯)) →
∀ (t : Std.DTreeMap.Internal.Impl α β) (h : t.isEmpty = false), motive t h (t.maxEntry h) | true |
ProbabilityTheory.Kernel.measurable_rnDeriv_right | Mathlib.Probability.Kernel.RadonNikodym | ∀ {α : Type u_1} {γ : Type u_2} {mα : MeasurableSpace α} {mγ : MeasurableSpace γ}
[hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ] (κ η : ProbabilityTheory.Kernel α γ) (a : α),
Measurable fun x => κ.rnDeriv η a x | true |
_private.Lean.Elab.Tactic.Grind.ShowState.0.Lean.Elab.Tactic.Grind.evalShowState | Lean.Elab.Tactic.Grind.ShowState | Lean.Elab.Tactic.Grind.GrindTactic | true |
_private.Mathlib.Order.Filter.ENNReal.0.NNReal.isCoboundedUnder_ge_toReal._simp_1_2 | Mathlib.Order.Filter.ENNReal | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {m : α → β} {P : β → Prop},
(∀ᶠ (b : β) in Filter.map m f, P b) = ∀ᶠ (a : α) in f, P (m a) | false |
CategoryTheory.Limits.PullbackCone.pasteHoriz.congr_simp | Mathlib.CategoryTheory.MorphismProperty.Representable | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X₃ Y₁ Y₂ Y₃ : C} {g₁ : Y₁ ⟶ Y₂} {g₂ : Y₂ ⟶ Y₃} {i₃ : X₃ ⟶ Y₃}
(t₂ : CategoryTheory.Limits.PullbackCone g₂ i₃) {i₂ : t₂.pt ⟶ Y₂}
(t₁ t₁_1 : CategoryTheory.Limits.PullbackCone g₁ i₂),
t₁ = t₁_1 → ∀ (hi₂ : i₂ = t₂.fst), t₂.pasteHoriz t₁ hi₂ = t₂.pasteHoriz t₁_1 hi₂ | true |
_private.Mathlib.CategoryTheory.Sites.LocallyBijective.0.CategoryTheory.Sheaf.isLocallyBijective_iff_isIso'._simp_1_1 | Mathlib.CategoryTheory.Sites.LocallyBijective | ∀ {C : Type u₁} [inst : CategoryTheory.CategoryStruct.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.CategoryStruct.comp g.op f.op = (CategoryTheory.CategoryStruct.comp f g).op | false |
IsOpen.continuousOn_iff | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {s : Set α},
IsOpen s → (ContinuousOn f s ↔ ∀ ⦃a : α⦄, a ∈ s → ContinuousAt f a) | true |
totallyBounded_insert._simp_1 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} [uniformSpace : UniformSpace α] (a : α) {s : Set α}, TotallyBounded (insert a s) = TotallyBounded s | false |
_private.Mathlib.Analysis.Meromorphic.FactorizedRational.0.Function.FactorizedRational.meromorphicOrderAt_eq._simp_1_2 | Mathlib.Analysis.Meromorphic.FactorizedRational | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {d : 𝕜 → ℤ} {x : 𝕜},
0 ≤ d x → AnalyticAt 𝕜 (∏ᶠ (u : 𝕜), (fun x => x - u) ^ d u) x = True | false |
_private.Init.Data.Array.Erase.0.Array.exists_or_eq_self_of_eraseP.match_1_1 | Init.Data.Array.Erase | ∀ {α : Type u_1} (p : α → Bool) (xs : Array α) (motive : (∃ a ∈ xs, p a = true) → Prop) (h : ∃ a ∈ xs, p a = true),
(∀ (w : α) (ha : w ∈ xs) (pa : p w = true), motive ⋯) → motive h | false |
_private.Mathlib.RingTheory.LocalProperties.Basic.0.RingHom.HoldsForLocalization.isLocalizationMap._simp_1_2 | Mathlib.RingTheory.LocalProperties.Basic | ∀ (R : Type u) (S : Type v) (A : Type w) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
[inst_3 : Algebra R S] [inst_4 : Algebra S A] [inst_5 : Algebra R A] [IsScalarTower R S A] (x : R),
(algebraMap S A) ((algebraMap R S) x) = (algebraMap R A) x | false |
unitInterval.symm | Mathlib.Topology.UnitInterval | ↑unitInterval → ↑unitInterval | true |
Lean.Parser.Attr.recursor._regBuiltin.Lean.Parser.Attr.recursor.formatter_7 | Lean.Parser.Attr | IO Unit | false |
Lean.Meta.Grind.Context.reportMVarIssue._default | Lean.Meta.Tactic.Grind.Types | Bool | false |
inf_sq_eq_mul_div_mabs_div | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : CommGroup α] [MulLeftMono α] (a b : α), (a ⊓ b) ^ 2 = a * b / |b / a|ₘ | true |
MeasureTheory.JordanDecomposition.real_smul_def | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | ∀ {α : Type u_1} [inst : MeasurableSpace α] (r : ℝ) (j : MeasureTheory.JordanDecomposition α),
r • j = if 0 ≤ r then r.toNNReal • j else -((-r).toNNReal • j) | true |
HahnModule.instBaseSMul | Mathlib.RingTheory.HahnSeries.Multiplication | {Γ : Type u_1} →
{R : Type u_3} →
[inst : PartialOrder Γ] →
{V : Type u_6} →
[inst_1 : Monoid R] → [inst_2 : AddMonoid V] → [inst_3 : DistribMulAction R V] → SMul R (HahnModule Γ R V) | true |
IsStronglyTranscendental.transcendental | Mathlib.RingTheory.Algebraic.StronglyTranscendental | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {x : S},
IsStronglyTranscendental R x → ∀ [FaithfulSMul R S], Transcendental R x | true |
CategoryTheory.Triangulated.TStructure.eTruncLTι_naturality_assoc | Mathlib.CategoryTheory.Triangulated.TStructure.ETrunc | ∀ {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 : CategoryTheory.Triangulated.TStructure C) (i : EInt) {X Y : C} (f : X ⟶ Y) {Z : C} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp ((t.eTruncLT.obj i).map f)
(CategoryTheory.CategoryStruct.comp ((t.eTruncLTι i).app Y) h) =
CategoryTheory.CategoryStruct.comp ((t.eTruncLTι i).app X) (CategoryTheory.CategoryStruct.comp f h) | true |
List.any.eq_1 | Batteries.Data.List.Basic | ∀ {α : Type u} (x : α → Bool), [].any x = false | true |
CategoryTheory.Limits.ReflectsLimit.rec | Mathlib.CategoryTheory.Limits.Preserves.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : Type w} →
[inst_2 : CategoryTheory.Category.{w', w} J] →
{K : CategoryTheory.Functor J C} →
{F : CategoryTheory.Functor C D} →
{motive : CategoryTheory.Limits.ReflectsLimit K F → Sort u} →
((reflects :
∀ {c : CategoryTheory.Limits.Cone K} (hc : CategoryTheory.Limits.IsLimit (F.mapCone c)),
Nonempty (CategoryTheory.Limits.IsLimit c)) →
motive ⋯) →
(t : CategoryTheory.Limits.ReflectsLimit K F) → motive t | false |
Homeomorph.prodComm_symm | Mathlib.Topology.Constructions.SumProd | ∀ (X : Type u) (Y : Type v) [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
(Homeomorph.prodComm X Y).symm = Homeomorph.prodComm Y X | true |
AlternatingMap.domDomCongr_zero | Mathlib.LinearAlgebra.Alternating.Basic | ∀ {R : Type u_1} [inst : Semiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {ι : Type u_7} {ι' : Type u_8} (σ : ι ≃ ι'),
AlternatingMap.domDomCongr σ 0 = 0 | true |
_private.Mathlib.Algebra.Homology.SpectralObject.Homology.0.CategoryTheory.Abelian.SpectralObject.dCokernelSequence_exact._proof_9 | Mathlib.Algebra.Homology.SpectralObject.Homology | ∀ (n₁ n₂ : ℤ),
autoParam (n₁ + 1 = n₂) CategoryTheory.Abelian.SpectralObject.dCokernelSequence_exact._auto_3 → n₁ + 1 = n₂ | false |
PFun.mem_restrict | Mathlib.Data.PFun | ∀ {α : Type u_1} {β : Type u_2} {f : α →. β} {s : Set α} (h : s ⊆ f.Dom) (a : α) (b : β),
b ∈ f.restrict h a ↔ a ∈ s ∧ b ∈ f a | true |
measurableSet_closedBall | Mathlib.MeasureTheory.Constructions.BorelSpace.Metric | ∀ {α : Type u_1} [inst : PseudoMetricSpace α] [inst_1 : MeasurableSpace α] [OpensMeasurableSpace α] {x : α} {ε : ℝ},
MeasurableSet (Metric.closedBall x ε) | true |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.SafePoly.0.Lean.Meta.Grind.Arith.CommRing.addConst | Lean.Meta.Tactic.Grind.Arith.CommRing.SafePoly | Lean.Grind.CommRing.Poly → ℤ → Lean.Meta.Grind.Arith.CommRing.RingM Lean.Grind.CommRing.Poly | true |
_private.Lean.Elab.DocString.Builtin.Keywords.0.Lean.Doc.containsAtom'.attempt.match_1 | Lean.Elab.DocString.Builtin.Keywords | (motive : Option Lean.Expr → Sort u_1) →
(__do_lift : Option Lean.Expr) →
((r : Lean.Expr) → motive (some r)) → ((x : Option Lean.Expr) → motive x) → motive __do_lift | false |
Std.Time.OffsetX.hourMinute | Std.Time.Format.Basic | Std.Time.OffsetX | true |
_private.Init.Data.String.Basic.0.String.Slice.utf8ByteSize_copy_eq_sub._simp_1_2 | Init.Data.String.Basic | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ ≤ i₂) = (i₁.byteIdx ≤ i₂.byteIdx) | false |
differentiable_const_cpow_of_neZero | Mathlib.Analysis.SpecialFunctions.Pow.Deriv | ∀ (z : ℂ) [NeZero z], Differentiable ℂ fun s => z ^ s | true |
TopologicalSpace.isTopologicalBasis_of_subbasis_of_finiteInter | Mathlib.Topology.Bases | ∀ {α : Type u} [t : TopologicalSpace α] {s : Set (Set α)},
t = TopologicalSpace.generateFrom s → FiniteInter s → TopologicalSpace.IsTopologicalBasis s | true |
CategoryTheory.Idempotents.Karoubi.HomologicalComplex.p_comm_f | Mathlib.CategoryTheory.Idempotents.HomologicalComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_2}
{c : ComplexShape ι} {P Q : CategoryTheory.Idempotents.Karoubi (HomologicalComplex C c)} (f : P ⟶ Q) (n : ι),
CategoryTheory.CategoryStruct.comp (P.p.f n) (f.f.f n) = CategoryTheory.CategoryStruct.comp (f.f.f n) (Q.p.f n) | true |
SeparationQuotient.instNorm.eq_1 | Mathlib.Analysis.Normed.Group.Uniform | ∀ {E : Type u_2} [inst : SeminormedAddCommGroup E],
SeparationQuotient.instNorm = { norm := SeparationQuotient.lift norm ⋯ } | true |
TopModuleCat.isLimitKer._proof_5 | Mathlib.Algebra.Category.ModuleCat.Topology.Homology | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : TopologicalSpace R] {M N : TopModuleCat R} (φ : M ⟶ N)
(s : CategoryTheory.Limits.KernelFork φ),
CategoryTheory.CategoryStruct.comp
(TopModuleCat.ofHom
((TopModuleCat.Hom.hom (CategoryTheory.Limits.Fork.ι s)).codRestrict (↑(TopModuleCat.Hom.hom φ)).ker ⋯))
(CategoryTheory.Limits.Fork.ι (CategoryTheory.Limits.KernelFork.ofι (TopModuleCat.kerι φ) ⋯)) =
CategoryTheory.CategoryStruct.comp
(TopModuleCat.ofHom
((TopModuleCat.Hom.hom (CategoryTheory.Limits.Fork.ι s)).codRestrict (↑(TopModuleCat.Hom.hom φ)).ker ⋯))
(CategoryTheory.Limits.Fork.ι (CategoryTheory.Limits.KernelFork.ofι (TopModuleCat.kerι φ) ⋯)) | false |
CategoryTheory.Functor.OplaxMonoidal.η | Mathlib.CategoryTheory.Monoidal.Functor | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.MonoidalCategory C} →
{D : Type u₂} →
{inst_2 : CategoryTheory.Category.{v₂, u₂} D} →
{inst_3 : CategoryTheory.MonoidalCategory D} →
(F : CategoryTheory.Functor C D) →
[self : F.OplaxMonoidal] →
F.obj (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) ⟶
CategoryTheory.MonoidalCategoryStruct.tensorUnit D | true |
Stream'.iterate._unsafe_rec | Mathlib.Data.Stream.Defs | {α : Type u} → (α → α) → α → Stream' α | false |
Relation.SymmGen.of_lt | Mathlib.Order.Antisymmetrization | ∀ {α : Type u_1} {a b : α} [inst : Preorder α], a < b → Relation.SymmGen (fun x1 x2 => x1 ≤ x2) a b | true |
UniqueFactorizationMonoid.disjoint_primeFactors | Mathlib.RingTheory.Radical.Basic | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [inst_1 : NormalizationMonoid M] [inst_2 : UniqueFactorizationMonoid M]
{a b : M},
IsRelPrime a b → Disjoint (UniqueFactorizationMonoid.primeFactors a) (UniqueFactorizationMonoid.primeFactors b) | true |
_private.Lean.Meta.Sym.AlphaShareCommon.0.Lean.Meta.Sym.alphaEq._sparseCasesOn_7 | Lean.Meta.Sym.AlphaShareCommon | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
(Nat.hasNotBit 128 t.ctorIdx → motive t) → motive t | false |
Asymptotics.IsEquivalent.isTheta_symm | Mathlib.Analysis.Asymptotics.AsymptoticEquivalent | ∀ {α : Type u_1} {β : Type u_2} [inst : NormedAddCommGroup β] {u v : α → β} {l : Filter α},
Asymptotics.IsEquivalent l u v → v =Θ[l] u | true |
Aesop.instHashableSlot | Aesop.Forward.RuleInfo | Hashable Aesop.Slot | true |
BoundedContinuousFunction.instSemiring._proof_3 | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u_1} {R : Type u_2} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace R] [inst_2 : Semiring R]
[inst_3 : BoundedMul R] [inst_4 : ContinuousMul R] [inst_5 : BoundedAdd R] [inst_6 : ContinuousAdd R]
(a : BoundedContinuousFunction α R), 0 * a = 0 | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.size_alter._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
AlgEquiv.equivCongr_apply | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} {A₁' : Type uA₁'} {A₂' : Type uA₂'} [inst : CommSemiring R]
[inst_1 : Semiring A₁] [inst_2 : Semiring A₂] [inst_3 : Semiring A₁'] [inst_4 : Semiring A₂'] [inst_5 : Algebra R A₁]
[inst_6 : Algebra R A₂] [inst_7 : Algebra R A₁'] [inst_8 : Algebra R A₂'] (e : A₁ ≃ₐ[R] A₂) (e' : A₁' ≃ₐ[R] A₂')
(ψ : A₁ ≃ₐ[R] A₁'), (e.equivCongr e') ψ = e.symm.trans (ψ.trans e') | true |
SignType.instLinearOrder._proof_5 | Mathlib.Data.Sign.Defs | ∀ (a b : SignType), a ≤ b ∨ b ≤ a | false |
CategoryTheory.Triangulated.Octahedron.ofIso._proof_1 | Mathlib.CategoryTheory.Triangulated.Triangulated | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ] {X₁ X₂ X₃ Z₁₃ : C}
(u₁₂ : X₁ ⟶ X₂) (u₂₃ : X₂ ⟶ X₃) (u₁₃ : X₁ ⟶ X₃),
CategoryTheory.CategoryStruct.comp u₁₂ u₂₃ = u₁₃ →
∀ {v₁₃ : X₃ ⟶ Z₁₃} {w₁₃ : Z₁₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₁} {X₁' X₂' X₃' Z₁₃' : C} (u₁₂' : X₁' ⟶ X₂')
(u₂₃' : X₂' ⟶ X₃') (u₁₃' : X₁' ⟶ X₃'),
CategoryTheory.CategoryStruct.comp u₁₂' u₂₃' = u₁₃' →
∀ (e₁ : X₁ ≅ X₁') (e₂ : X₂ ≅ X₂') (e₃ : X₃ ≅ X₃'),
CategoryTheory.CategoryStruct.comp u₁₂ e₂.hom = CategoryTheory.CategoryStruct.comp e₁.hom u₁₂' →
CategoryTheory.CategoryStruct.comp u₂₃ e₃.hom = CategoryTheory.CategoryStruct.comp e₂.hom u₂₃' →
∀ (v₁₃' : X₃' ⟶ Z₁₃') (w₁₃' : Z₁₃' ⟶ (CategoryTheory.shiftFunctor C 1).obj X₁'),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Pretriangulated.Triangle.mk u₁₃ v₁₃ w₁₃).mor₁
e₃.hom =
CategoryTheory.CategoryStruct.comp e₁.hom
(CategoryTheory.Pretriangulated.Triangle.mk u₁₃' v₁₃' w₁₃').mor₁ | false |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.mkChainResult.go._unary._proof_1 | Lean.Elab.Tactic.Try | ∀ (tacss2 : Array (Array (Lean.TSyntax `tactic))) (i : ℕ) (acc : List (Lean.TSyntax `tactic)),
i < tacss2.size →
∀ (__do_lift : Lean.TSyntax `tactic),
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun i acc => tacss2.size - i) ⟨i + 1, __do_lift :: acc⟩
⟨i, acc⟩ | false |
EuclideanGeometry.dist_div_sin_angle_of_angle_eq_pi_div_two | Mathlib.Geometry.Euclidean.Angle.Unoriented.RightAngle | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {p₁ p₂ p₃ : P},
EuclideanGeometry.angle p₁ p₂ p₃ = Real.pi / 2 →
p₁ ≠ p₂ ∨ p₃ = p₂ → dist p₁ p₂ / Real.sin (EuclideanGeometry.angle p₂ p₃ p₁) = dist p₁ p₃ | true |
Finset.empty_pow | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Monoid α] {n : ℕ}, n ≠ 0 → ∅ ^ n = ∅ | true |
AlgHom.toOpposite._proof_4 | Mathlib.Algebra.Algebra.Opposite | ∀ {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B) (hf : ∀ (x y : A), Commute (f x) (f y)) (x y : A),
(↑↑(f.toOpposite hf)).toFun (x + y) = (↑↑(f.toOpposite hf)).toFun x + (↑↑(f.toOpposite hf)).toFun y | false |
AffineMap.prodMap._proof_1 | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ {k : Type u_8} {V1 : Type u_3} {P1 : Type u_1} {V2 : Type u_7} {P2 : Type u_5} {V3 : Type u_4} {P3 : Type u_2}
{V4 : Type u_9} {P4 : Type u_6} [inst : Ring k] [inst_1 : AddCommGroup V1] [inst_2 : Module k V1]
[inst_3 : AddTorsor V1 P1] [inst_4 : AddCommGroup V2] [inst_5 : Module k V2] [inst_6 : AddTorsor V2 P2]
[inst_7 : AddCommGroup V3] [inst_8 : Module k V3] [inst_9 : AddTorsor V3 P3] [inst_10 : AddCommGroup V4]
[inst_11 : Module k V4] [inst_12 : AddTorsor V4 P4] (f : P1 →ᵃ[k] P2) (g : P3 →ᵃ[k] P4) (p : P1 × P3) (v : V1 × V3),
Prod.map (⇑f) (⇑g) (v +ᵥ p) = (f.linear.prodMap g.linear) v +ᵥ Prod.map (⇑f) (⇑g) p | false |
Set.powersetCard.mem_range_ofFinEmbEquiv_symm_iff_mem | Mathlib.Order.Hom.PowersetCard | ∀ {n : ℕ} {I : Type u_1} [inst : LinearOrder I] (s : ↑(Set.powersetCard I n)) (i : I),
i ∈ Set.range ⇑(Set.powersetCard.ofFinEmbEquiv.symm s) ↔ i ∈ s | true |
Order.IsSuccLimit.nonempty_Iio | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a : α} [inst : Preorder α], Order.IsSuccLimit a → (Set.Iio a).Nonempty | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift.0.CochainComplex.HomComplex.Cochain.leftUnshift._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {n' a : ℤ} (n : ℤ), n + a = n' → ∀ (p q : ℤ), p + n = q → p - a + n' = q | false |
Ideal.radical | Mathlib.RingTheory.Ideal.Operations | {R : Type u} → [inst : CommSemiring R] → Ideal R → Ideal R | true |
Std.Format.prefixJoin | Init.Data.Format.Basic | {α : Type u} → [Std.ToFormat α] → Std.Format → List α → Std.Format | true |
RootPairing.instIsBalancedOfIsRootSystem | Mathlib.LinearAlgebra.RootSystem.BaseChange | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : AddCommGroup M] [inst_1 : AddCommGroup N]
[inst_2 : CommRing R] [inst_3 : Module R M] [inst_4 : Module R N] (P : RootPairing ι R M N) [P.IsRootSystem],
P.IsBalanced | true |
HomogeneousLocalization.deg | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | {ι : Type u_1} →
{A : Type u_2} →
{σ : Type u_3} →
[inst : CommRing A] → [inst_1 : SetLike σ A] → {𝒜 : ι → σ} → {x : Submonoid A} → HomogeneousLocalization 𝒜 x → ι | true |
irrational_sub_ratCast_iff._simp_1 | Mathlib.NumberTheory.Real.Irrational | ∀ {q : ℚ} {x : ℝ}, Irrational (x - ↑q) = Irrational x | false |
Bundle.ContMDiffRiemannianMetric.toContinuousRiemannianMetric._proof_10 | Mathlib.Geometry.Manifold.VectorBundle.Riemannian | SMulCommClass ℝ ℝ ℝ | false |
List.iterate._sunfold | Mathlib.Data.List.Defs | {α : Type u_1} → (α → α) → α → ℕ → List α | false |
_private.Lean.Meta.Basic.0.Lean.Meta.lambdaTelescopeImp.process._unsafe_rec | Lean.Meta.Basic | {α : Type} →
Bool →
Bool →
Option ℕ →
(Array Lean.Expr → Lean.Expr → Lean.MetaM α) →
Bool → Bool → Bool → Lean.LocalContext → Array Lean.Expr → Lean.Expr → Lean.MetaM α | false |
CategoryTheory.SpectralSequence.noConfusionType | Mathlib.Algebra.Homology.SpectralSequence.Basic | Sort u →
{C : Type u_1} →
[inst : CategoryTheory.Category.{u_3, u_1} C] →
[inst_1 : CategoryTheory.Abelian C] →
{κ : Type u_2} →
{c : ℤ → ComplexShape κ} →
{r₀ : ℤ} →
CategoryTheory.SpectralSequence C c r₀ →
{C' : Type u_1} →
[inst' : CategoryTheory.Category.{u_3, u_1} C'] →
[inst'_1 : CategoryTheory.Abelian C'] →
{κ' : Type u_2} →
{c' : ℤ → ComplexShape κ'} → {r₀' : ℤ} → CategoryTheory.SpectralSequence C' c' r₀' → Sort u | false |
ClopenUpperSet.mk._flat_ctor | Mathlib.Topology.Sets.Order | {α : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : LE α] → (carrier : Set α) → IsClopen carrier → IsUpperSet carrier → ClopenUpperSet α | false |
Lean.Parser.Tactic.withReducible | Init.Tactics | Lean.ParserDescr | true |
Std.DTreeMap.Raw.Const.getKey?_modify | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {β : Type v} {t : Std.DTreeMap.Raw α (fun x => β) cmp},
t.WF →
∀ {k k' : α} {f : β → β},
(Std.DTreeMap.Raw.Const.modify t k f).getKey? k' =
if cmp k k' = Ordering.eq then if k ∈ t then some k else none else t.getKey? k' | true |
Aesop.RuleTerm.ctorElimType | Aesop.RuleTac.RuleTerm | {motive : Aesop.RuleTerm → Sort u} → ℕ → Sort (max 1 u) | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastMul.go_denote_eq | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (curr : ℕ),
curr + 1 ≤ w →
∀ (acc lhs rhs : aig.RefVec w) (lexpr rexpr : BitVec w) (assign : α → Bool),
(∀ (idx : ℕ) (hidx : idx < w), ⟦assign, { aig := aig, ref := lhs.get idx hidx }⟧ = lexpr.getLsbD idx) →
(∀ (idx : ℕ) (hidx : idx < w), ⟦assign, { aig := aig, ref := rhs.get idx hidx }⟧ = rexpr.getLsbD idx) →
(∀ (idx : ℕ) (hidx : idx < w),
⟦assign, { aig := aig, ref := acc.get idx hidx }⟧ = (lexpr.mulRec rexpr curr).getLsbD idx) →
∀ (idx : ℕ) (hidx : idx < w),
⟦assign,
{ aig := (Std.Tactic.BVDecide.BVExpr.bitblast.blastMul.go aig lhs rhs (curr + 1) acc).aig,
ref :=
(Std.Tactic.BVDecide.BVExpr.bitblast.blastMul.go aig lhs rhs (curr + 1) acc).vec.get idx hidx }⟧ =
(lexpr.mulRec rexpr w).getLsbD idx | true |
Matrix.charpolyRev.congr_simp | Mathlib.LinearAlgebra.Matrix.Charpoly.Coeff | ∀ {R : Type u} [inst : CommRing R] {n : Type v} {inst_1 : DecidableEq n} [inst_2 : DecidableEq n] [inst_3 : Fintype n]
(M M_1 : Matrix n n R), M = M_1 → M.charpolyRev = M_1.charpolyRev | true |
ContinuousSemilinearEquivClass.mk | Mathlib.Topology.Algebra.Module.Equiv | ∀ {F : Type u_1} {R : outParam (Type u_2)} {S : outParam (Type u_3)} [inst : Semiring R] [inst_1 : Semiring S]
{σ : outParam (R →+* S)} {σ' : outParam (S →+* R)} [inst_2 : RingHomInvPair σ σ'] [inst_3 : RingHomInvPair σ' σ]
{M : outParam (Type u_4)} [inst_4 : TopologicalSpace M] [inst_5 : AddCommMonoid M] {M₂ : outParam (Type u_5)}
[inst_6 : TopologicalSpace M₂] [inst_7 : AddCommMonoid M₂] [inst_8 : Module R M] [inst_9 : Module S M₂]
[inst_10 : EquivLike F M M₂] [toSemilinearEquivClass : SemilinearEquivClass F σ M M₂],
autoParam (∀ (f : F), Continuous ⇑f) ContinuousSemilinearEquivClass.map_continuous._autoParam →
autoParam (∀ (f : F), Continuous (EquivLike.inv f)) ContinuousSemilinearEquivClass.inv_continuous._autoParam →
ContinuousSemilinearEquivClass F σ M M₂ | true |
MeasureTheory.LevyProkhorov.levyProkhorovDist_metricSpace_probabilityMeasure._proof_2 | Mathlib.MeasureTheory.Measure.LevyProkhorovMetric | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] [inst_1 : PseudoEMetricSpace Ω] [inst_2 : OpensMeasurableSpace Ω]
[BorelSpace Ω] {μ ν : MeasureTheory.LevyProkhorov (MeasureTheory.ProbabilityMeasure Ω)}, dist μ ν = 0 → μ = ν | false |
_private.Init.Data.Format.Basic.0.Std.Format.State.noConfusionType | Init.Data.Format.Basic | Sort u → Std.Format.State✝ → Std.Format.State✝ → Sort u | false |
AddUnits.neg_add_eq_iff_eq_add | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : AddMonoid α] (a : AddUnits α) {b c : α}, ↑(-a) + b = c ↔ b = ↑a + c | true |
TopologicalSpace.GenerateOpen.brecOn | Mathlib.Topology.Order | ∀ {α : Type u} {g : Set (Set α)} {motive : (a : Set α) → TopologicalSpace.GenerateOpen g a → Prop} {a : Set α}
(t : TopologicalSpace.GenerateOpen g a),
(∀ (a : Set α) (t : TopologicalSpace.GenerateOpen g a), TopologicalSpace.GenerateOpen.below t → motive a t) →
motive a t | true |
MeasureTheory.IsSetSemiring.empty_mem | Mathlib.MeasureTheory.SetSemiring | ∀ {α : Type u_1} {C : Set (Set α)}, MeasureTheory.IsSetSemiring C → ∅ ∈ C | true |
CategoryTheory.Abelian.Pseudoelement.mono_of_zero_of_map_zero | Mathlib.CategoryTheory.Abelian.Pseudoelements | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {P Q : C} (f : P ⟶ Q),
(∀ (a : CategoryTheory.Abelian.Pseudoelement P), CategoryTheory.Abelian.Pseudoelement.pseudoApply f a = 0 → a = 0) →
CategoryTheory.Mono f | true |
OrdinalApprox.lfpApprox._proof_2 | Mathlib.SetTheory.Ordinal.FixedPointApproximants | ∀ (a b : Ordinal.{u_1}), b < a → (invImage (fun x => x) Ordinal.wellFoundedRelation).1 b a | false |
_private.Mathlib.Order.SupIndep.0.iSupIndep_ne_bot._simp_1_1 | Mathlib.Order.SupIndep | ∀ {α : Type u_1} {ι : Type u_3} [inst : CompleteLattice α] {t : ι → α},
iSupIndep t = ∀ (i : ι), Disjoint (t i) (⨆ j, ⨆ (_ : j ≠ i), t j) | false |
_private.Batteries.Data.List.Lemmas.0.List.pos_iff_exists_findIdxNth._proof_1_5 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {i : ℕ} {p : α → Bool} {xs : List α} {h : i < xs.length} (w : ℕ),
List.findIdxNth p xs w = i → List.findIdxNth p xs w < xs.length | false |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Search.0.Lean.Meta.Grind.Arith.Linear.assignElimVars.go.match_1 | Lean.Meta.Tactic.Grind.Arith.Linear.Search | (motive : Option Lean.Meta.Grind.Arith.Linear.EqCnstr → Sort u_1) →
(x : Option Lean.Meta.Grind.Arith.Linear.EqCnstr) →
((c : Lean.Meta.Grind.Arith.Linear.EqCnstr) → motive (some c)) →
((x : Option Lean.Meta.Grind.Arith.Linear.EqCnstr) → motive x) → motive x | false |
Real.binEntropy_lt_log_two | Mathlib.Analysis.SpecialFunctions.BinaryEntropy | ∀ {p : ℝ}, Real.binEntropy p < Real.log 2 ↔ p ≠ 2⁻¹ | true |
MulEquiv.map_inv | Mathlib.Algebra.Group.Equiv.Defs | ∀ {G : Type u_7} {H : Type u_8} [inst : Group G] [inst_1 : DivisionMonoid H] (h : G ≃* H) (x : G), h x⁻¹ = (h x)⁻¹ | true |
CochainComplex.HomComplex.Cochain.shiftAddHom._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(K L : CochainComplex C ℤ) (n a : ℤ) (a_1 b : CochainComplex.HomComplex.Cochain K L n),
(fun γ => γ.shift a) (a_1 + b) = (fun γ => γ.shift a) a_1 + (fun γ => γ.shift a) b | false |
Submonoid.mem_map_of_mem | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] (f : F) {S : Submonoid M} {x : M}, x ∈ S → f x ∈ Submonoid.map f S | true |
groupHomology.opcyclesIso₀._proof_4 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u_1, u_1, u_1} k G),
(HomologicalComplex.sc (groupHomology.inhomogeneousChains A) 1).HasHomology | false |
Lean.Lsp.WorkspaceClientCapabilities.mk.noConfusion | Lean.Data.Lsp.Capabilities | {P : Sort u} →
{applyEdit? : Option Bool} →
{workspaceEdit? : Option Lean.Lsp.WorkspaceEditClientCapabilities} →
{applyEdit?' : Option Bool} →
{workspaceEdit?' : Option Lean.Lsp.WorkspaceEditClientCapabilities} →
{ applyEdit? := applyEdit?, workspaceEdit? := workspaceEdit? } =
{ applyEdit? := applyEdit?', workspaceEdit? := workspaceEdit?' } →
(applyEdit? = applyEdit?' → workspaceEdit? = workspaceEdit?' → P) → P | false |
Bool.atLeastTwo_true_left | Init.Data.BitVec.Bitblast | ∀ {b c : Bool}, true.atLeastTwo b c = (b || c) | true |
_private.Mathlib.Probability.Kernel.Disintegration.CondCDF.0.ProbabilityTheory.preCDF_le_one._simp_1_1 | Mathlib.Probability.Kernel.Disintegration.CondCDF | ∀ {α : Type u_1} {m : MeasurableSpace α}, MeasurableSet Set.univ = True | false |
Finset.nsmul_empty | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : AddMonoid α] {n : ℕ}, n ≠ 0 → n • ∅ = ∅ | true |
MonoidWithZeroHom.ValueGroup₀.restrict₀_eq_zero_iff | Mathlib.Algebra.GroupWithZero.Range | ∀ {A : Type u_1} {B : Type u_2} {F : Type u_3} [inst : FunLike F A B] {f : F} [inst_1 : MonoidWithZero A]
[inst_2 : GroupWithZero B] [inst_3 : MonoidWithZeroHomClass F A B] {a : A},
(MonoidWithZeroHom.ValueGroup₀.restrict₀ f) a = 0 ↔ f a = 0 | true |
Std.Iter.Equiv.trans | Std.Data.Iterators.Lemmas.Equivalence.Basic | ∀ {α₁ α₂ α₃ β : Type w} [inst : Std.Iterator α₁ Id β] [inst_1 : Std.Iterator α₂ Id β] [inst_2 : Std.Iterator α₃ Id β]
{ita : Std.Iter β} {itb : Std.Iter β} {itc : Std.Iter β}, ita.Equiv itb → itb.Equiv itc → ita.Equiv itc | true |
ENNReal.instDivInvMonoid._proof_4 | Mathlib.Data.ENNReal.Basic | ∀ (n : ℕ) (a : ENNReal), zpowRec npowRec (Int.negSucc n) a = (zpowRec npowRec (↑n.succ) a)⁻¹ | false |
Lean.Meta.DefaultInstances.mk.inj | Lean.Meta.Instances | ∀ {defaultInstances : Lean.NameMap (List (Lean.Name × ℕ))} {priorities : Lean.Meta.PrioritySet}
{defaultInstances_1 : Lean.NameMap (List (Lean.Name × ℕ))} {priorities_1 : Lean.Meta.PrioritySet},
{ defaultInstances := defaultInstances, priorities := priorities } =
{ defaultInstances := defaultInstances_1, priorities := priorities_1 } →
defaultInstances = defaultInstances_1 ∧ priorities = priorities_1 | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.