name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Std.DTreeMap.Internal.Impl.get | Std.Data.DTreeMap.Internal.Queries | {α : Type u} →
{β : α → Type v} → [inst : Ord α] → [Std.LawfulEqOrd α] → (t : Std.DTreeMap.Internal.Impl α β) → (k : α) → k ∈ t → β k | true |
Fin.castSucc_one | Init.Data.Fin.Lemmas | ∀ {n : ℕ}, Fin.castSucc 1 = 1 | true |
Subgroup.instUniqueOfSubsingleton | Mathlib.Algebra.Group.Subgroup.Lattice | {G : Type u_1} → [inst : Group G] → [Subsingleton G] → Unique (Subgroup G) | true |
Lean.IR.ExpandResetReuse.removeSelfSet._unsafe_rec | Lean.Compiler.IR.ExpandResetReuse | Lean.IR.ExpandResetReuse.Context → Lean.IR.FnBody → Lean.IR.FnBody | false |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.LebesgueDifferentiationThm.0.IntervalIntegrable.ae_hasDerivAt_integral._proof_1_10 | Mathlib.MeasureTheory.Integral.IntervalIntegral.LebesgueDifferentiationThm | ∀ {f : ℝ → ℝ} {a b : ℝ},
∀ c ∈ Set.Icc a b, ∀ y ∈ Set.Ioo a b, ∀ a_1 ∈ Set.Ioc y c, f a_1 = (fun x => if x ∈ Set.Ioc a b then f x else 0) a_1 | false |
_private.Mathlib.Analysis.BoxIntegral.Partition.Split.0.BoxIntegral.Box.coe_splitUpper._simp_1_4 | Mathlib.Analysis.BoxIntegral.Partition.Split | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | false |
Lean.Parser.Term.doAssert._regBuiltin.Lean.Parser.Term.doAssert.formatter_9 | Lean.Parser.Do | IO Unit | false |
CategoryTheory.bifunctorComp₂₃._proof_4 | Mathlib.CategoryTheory.Functor.Trifunctor | ∀ {C₁ : Type u_8} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_5} {C₂₃ : Type u_10}
[inst : CategoryTheory.Category.{u_7, u_8} C₁] [inst_1 : CategoryTheory.Category.{u_1, u_2} C₂]
[inst_2 : CategoryTheory.Category.{u_6, u_3} C₃] [inst_3 : CategoryTheory.Category.{u_4, u_5} C₄]
[inst_4 : CategoryTheory.Category.{u_9, u_10} C₂₃] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂₃ C₄))
(G₂₃ : CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₂₃)) {X₁ Y₁ : C₁} (φ : X₁ ⟶ Y₁) ⦃X Y : C₂⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.bifunctorComp₂₃Obj F G₂₃ X₁).map f)
{ app := fun X₃ => (F.map φ).app ((G₂₃.obj Y).obj X₃), naturality := ⋯ } =
CategoryTheory.CategoryStruct.comp { app := fun X₃ => (F.map φ).app ((G₂₃.obj X).obj X₃), naturality := ⋯ }
((CategoryTheory.bifunctorComp₂₃Obj F G₂₃ Y₁).map f) | false |
List.Sublist.flatMap_right | Mathlib.Data.List.Flatten | ∀ {α : Type u_1} {β : Type u_2} (l : List α) {f g : α → List β},
(∀ a ∈ l, (f a).Sublist (g a)) → (List.flatMap f l).Sublist (List.flatMap g l) | true |
Insert.casesOn | Init.Core | {α : Type u} →
{γ : Type v} →
{motive : Insert α γ → Sort u_1} →
(t : Insert α γ) → ((insert : α → γ → γ) → motive { insert := insert }) → motive t | false |
Lean.mkAnnotation | Lean.Expr | Lean.Name → Lean.Expr → Lean.Expr | true |
ContMDiffAdd.recOn | Mathlib.Geometry.Manifold.Algebra.Monoid | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{H : Type u_2} →
[inst_1 : TopologicalSpace H] →
{E : Type u_3} →
[inst_2 : NormedAddCommGroup E] →
[inst_3 : NormedSpace 𝕜 E] →
{I : ModelWithCorners 𝕜 E H} →
{n : WithTop ℕ∞} →
{G : Type u_4} →
[inst_4 : Add G] →
[inst_5 : TopologicalSpace G] →
[inst_6 : ChartedSpace H G] →
{motive : ContMDiffAdd I n G → Sort u} →
(t : ContMDiffAdd I n G) →
([toIsManifold : IsManifold I n G] →
(contMDiff_add : ContMDiff (I.prod I) I n fun p => p.1 + p.2) → motive ⋯) →
motive t | false |
LieIdeal.coe_lcs_eq | Mathlib.Algebra.Lie.Nilpotent | ∀ {R : Type u_1} {L : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (I : LieIdeal R L)
(M : Type u_3) [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] (k : ℕ) [LieModule R L M],
↑(I.lcs M k) = ↑(LieModule.lowerCentralSeries R (↥I) M k) | true |
Std.HashMap.Raw.getKey_union_of_mem_right | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.HashMap.Raw α β} [inst_2 : EquivBEq α]
[inst_3 : LawfulHashable α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (mem : k ∈ m₂), (m₁ ∪ m₂).getKey k ⋯ = m₂.getKey k mem | true |
HomotopicalAlgebra.PrepathObject.trans_p₁ | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C} (P P' : HomotopicalAlgebra.PrepathObject A)
[inst_1 : CategoryTheory.Limits.HasPullback P.p₁ P'.p₀],
(P.trans P').p₁ = CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.snd P.p₁ P'.p₀) P'.p₁ | true |
PresheafOfModules.instAddCommGroupHom._proof_11 | Mathlib.Algebra.Category.ModuleCat.Presheaf | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{M₁ M₂ : PresheafOfModules R} (a b : M₁ ⟶ M₂), a + b = b + a | false |
List.Perm.eq_of_pairwise | Init.Data.List.Perm | ∀ {α : Type u_1} {le : α → α → Prop} {l₁ l₂ : List α},
(∀ (a b : α), a ∈ l₁ → b ∈ l₂ → le a b → le b a → a = b) →
List.Pairwise le l₁ → List.Pairwise le l₂ → l₁.Perm l₂ → l₁ = l₂ | true |
NonemptyFinLinOrd.instConcreteCategoryOrderHomCarrier | Mathlib.Order.Category.NonemptyFinLinOrd | CategoryTheory.ConcreteCategory NonemptyFinLinOrd fun x1 x2 => ↑x1.toLinOrd →o ↑x2.toLinOrd | true |
_private.Init.Internal.Order.Lemmas.0.Lean.Order.Functor.monotone_map._simp_1_1 | Init.Internal.Order.Lemmas | ∀ {m : Type u → Type v} {inst : Monad m} [self : LawfulMonad m] {α β : Type u} (f : α → β) (x : m α),
f <$> x = do
let a ← x
pure (f a) | false |
MeasureTheory.SimpleFunc.integral_eq_sum | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ {α : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} [hE : CompleteSpace E] (f : MeasureTheory.SimpleFunc α E),
MeasureTheory.Integrable (⇑f) μ → ∫ (x : α), f x ∂μ = ∑ x ∈ f.range, μ.real (⇑f ⁻¹' {x}) • x | true |
IsCompactlyGenerated.BooleanGenerators.distribLattice_of_sSup_eq_top | Mathlib.Order.BooleanGenerators | {α : Type u_1} →
[inst : CompleteLattice α] →
{S : Set α} → [IsCompactlyGenerated α] → IsCompactlyGenerated.BooleanGenerators S → sSup S = ⊤ → DistribLattice α | true |
Functor.Comp.instSeq | Mathlib.Control.Functor | {F : Type u → Type w} → {G : Type v → Type u} → [Applicative F] → [Applicative G] → Seq (Functor.Comp F G) | true |
FirstOrder.Language.Hom.id_comp | Mathlib.ModelTheory.Basic | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type w'} [inst : L.Structure M] [inst_1 : L.Structure N] (f : L.Hom M N),
(FirstOrder.Language.Hom.id L N).comp f = f | true |
PosNum.ofNatSucc._unsafe_rec | Mathlib.Data.Num.Basic | ℕ → PosNum | false |
OpenPartialHomeomorph.extend_symm_preimage_inter_range_eventuallyEq | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] [inst_4 : TopologicalSpace M]
(f : OpenPartialHomeomorph M H) {I : ModelWithCorners 𝕜 E H} {s : Set M} {x : M},
s ⊆ f.source → x ∈ f.source → ↑(f.extend I).symm ⁻¹' s ∩ Set.range ↑I =ᶠ[nhds (↑(f.extend I) x)] ↑(f.extend I) '' s | true |
Lean.Compiler.LCNF.FixedParams.evalApp | Lean.Compiler.LCNF.FixedParams | Lean.Name →
Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure) → Lean.Compiler.LCNF.FixedParams.FixParamM Unit | true |
PartialEquiv.IsImage.eq_1 | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} (e : PartialEquiv α β) (s : Set α) (t : Set β),
e.IsImage s t = ∀ ⦃x : α⦄, x ∈ e.source → (↑e x ∈ t ↔ x ∈ s) | true |
continuousMultilinearCurryLeftEquiv._proof_5 | Mathlib.Analysis.Normed.Module.Multilinear.Curry | ∀ (G : Type u_1) [inst : NormedAddCommGroup G], ContinuousAdd G | false |
ContinuousMap.coe_mabs | Mathlib.Topology.ContinuousMap.Lattice | ∀ {α : Type u_1} [inst : TopologicalSpace α] {β : Type u_2} [inst_1 : TopologicalSpace β] [inst_2 : Group β]
[inst_3 : IsTopologicalGroup β] [inst_4 : Lattice β] [inst_5 : TopologicalLattice β] (f : C(α, β)), ⇑|f|ₘ = |⇑f|ₘ | true |
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.AssignmentsInvariant | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | {n : ℕ} → Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n → Prop | true |
IsLinearTopology.casesOn | Mathlib.Topology.Algebra.LinearTopology | {R : Type u_1} →
{M : Type u_3} →
[inst : Ring R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
[inst_3 : TopologicalSpace M] →
{motive : IsLinearTopology R M → Sort u} →
(t : IsLinearTopology R M) →
((hasBasis_submodule' : (nhds 0).HasBasis (fun N => ↑N ∈ nhds 0) fun N => ↑N) → motive ⋯) → motive t | false |
HomologicalComplex.HomologySequence.mapSnakeInput._proof_4 | Mathlib.Algebra.Homology.HomologySequenceLemmas | ∀ {C : Type u_3} {ι : Type u_1} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Abelian C]
{c : ComplexShape ι} (j : ι), (HomologicalComplex.cyclesFunctor C c j).PreservesZeroMorphisms | false |
Batteries.RunningStats.count | Batteries.Data.RunningStats | Batteries.RunningStats → ℕ | true |
Ideal.quotientEquiv_symm_mk | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u} [inst : Ring R] {S : Type v} [inst_1 : Ring S] (I : Ideal R) (J : Ideal S) [inst_2 : I.IsTwoSided]
[inst_3 : J.IsTwoSided] (f : R ≃+* S) (hIJ : J = Ideal.map (↑f) I) (x : S),
(I.quotientEquiv J f hIJ).symm ((Ideal.Quotient.mk J) x) = (Ideal.Quotient.mk I) (f.symm x) | true |
Lean.Parser.Tactic.rewriteSeq | Init.Tactics | Lean.ParserDescr | true |
_private.Std.Time.Date.Unit.Day.0.Std.Time.Day.instLawfulEqOrdOrdinal._proof_1 | Std.Time.Date.Unit.Day | Std.LawfulEqOrd Std.Time.Day.Ordinal | false |
LinearMap.isometryOfOrthonormal._proof_1 | Mathlib.Analysis.InnerProductSpace.Orthonormal | ∀ {𝕜 : Type u_1} {E : Type u_3} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Type u_4} {E' : Type u_2} [inst_3 : SeminormedAddCommGroup E'] [inst_4 : InnerProductSpace 𝕜 E'] (f : E →ₗ[𝕜] E')
{v : Module.Basis ι 𝕜 E}, Orthonormal 𝕜 ⇑v → Orthonormal 𝕜 (⇑f ∘ ⇑v) → ∀ (x y : E), inner 𝕜 (f x) (f y) = inner 𝕜 x y | false |
AddOpposite.instNonUnitalCommRing._proof_1 | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_1} [inst : NonUnitalCommRing R] (a b : Rᵃᵒᵖ), a * b = b * a | false |
AddMonoidHom.ofMapMidpoint._proof_2 | Mathlib.LinearAlgebra.AffineSpace.Midpoint | ∀ (R : Type u_4) (R' : Type u_2) {E : Type u_3} {F : Type u_1} [inst : Ring R] [inst_1 : Invertible 2]
[inst_2 : AddCommGroup E] [inst_3 : Module R E] [inst_4 : Ring R'] [inst_5 : Invertible 2] [inst_6 : AddCommGroup F]
[inst_7 : Module R' F] (f : E → F),
(∀ (x y : E), f (midpoint R x y) = midpoint R' (f x) (f y)) →
∀ (x y : E), midpoint R' (f 0) (f (x + y)) + midpoint R' (f 0) (f (x + y)) = f (midpoint R x y) + f (midpoint R x y) | false |
_private.Init.Data.String.Termination.0.String.Slice.Pos.wellFounded_lt._simp_1_2 | Init.Data.String.Termination | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ < i₂) = (i₁.byteIdx < i₂.byteIdx) | false |
Finmap.mem_replace | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {a a' : α} {b : β a} {s : Finmap β},
a' ∈ Finmap.replace a b s ↔ a' ∈ s | true |
_private.Mathlib.Tactic.Linarith.Frontend.0.Mathlib.Tactic.Linarith.linarithUsedHyps.match_7 | Mathlib.Tactic.Linarith.Frontend | (motive : Lean.MVarId × Option Lean.Expr × Option Lean.Expr → Sort u_1) →
(__discr : Lean.MVarId × Option Lean.Expr × Option Lean.Expr) →
((g : Lean.MVarId) → (target_type new_var : Option Lean.Expr) → motive (g, target_type, new_var)) → motive __discr | false |
CategoryTheory.Functor.rightAdjointObjIsDefined_of_adjunction | Mathlib.CategoryTheory.Adjunction.PartialAdjoint | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) (Y : D), F.rightAdjointObjIsDefined Y | true |
Lean.Parser.Tactic._aux_Std_Tactic_Do_Syntax___macroRules_Lean_Parser_Tactic_mreplaceError_1 | Std.Tactic.Do.Syntax | Lean.Macro | false |
CategoryTheory.GradedObject.mapBifunctorBifunctor₂₃Desc.congr_simp | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {C₂₃ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_4} C₄]
[inst_4 : CategoryTheory.Category.{v_6, u_6} C₂₃] {F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂₃ C₄)}
{G₂₃ : CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₂₃)} {I₁ : Type u_7} {I₂ : Type u_8} {I₃ : Type u_9}
{J : Type u_10} {r : I₁ × I₂ × I₃ → J} {ρ₂₃ : CategoryTheory.GradedObject.BifunctorComp₂₃IndexData r}
{X₁ : CategoryTheory.GradedObject I₁ C₁} {X₂ : CategoryTheory.GradedObject I₂ C₂}
{X₃ : CategoryTheory.GradedObject I₃ C₃}
[inst_5 : (((CategoryTheory.GradedObject.mapBifunctor G₂₃ I₂ I₃).obj X₂).obj X₃).HasMap ρ₂₃.p]
[inst_6 :
(((CategoryTheory.GradedObject.mapBifunctor F I₁ ρ₂₃.I₂₃).obj X₁).obj
(CategoryTheory.GradedObject.mapBifunctorMapObj G₂₃ ρ₂₃.p X₂ X₃)).HasMap
ρ₂₃.q]
[H : CategoryTheory.GradedObject.HasGoodTrifunctor₂₃Obj F G₂₃ ρ₂₃ X₁ X₂ X₃] {j : J} {A : C₄}
(f f_1 :
(i₁ : I₁) → (i₂ : I₂) → (i₃ : I₃) → r (i₁, i₂, i₃) = j → ((F.obj (X₁ i₁)).obj ((G₂₃.obj (X₂ i₂)).obj (X₃ i₃)) ⟶ A)),
f = f_1 →
CategoryTheory.GradedObject.mapBifunctorBifunctor₂₃Desc f =
CategoryTheory.GradedObject.mapBifunctorBifunctor₂₃Desc f_1 | true |
TwoSidedIdeal.orderIsoIdeal._proof_4 | Mathlib.RingTheory.TwoSidedIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] (J : Ideal R), ∀ x ∈ ↑J, x ∈ ↑(TwoSidedIdeal.mk' ↑J ⋯ ⋯ ⋯ ⋯ ⋯) | false |
Lean.Grind.CommRing.Poly.mulConst | Init.Grind.Ring.CommSolver | ℤ → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly | true |
AddMagmaCat.comp_apply | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {M N T : AddMagmaCat} (f : M ⟶ N) (g : N ⟶ T) (x : ↑M),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp f g)) x =
(CategoryTheory.ConcreteCategory.hom g) ((CategoryTheory.ConcreteCategory.hom f) x) | true |
HomogeneousIdeal.toIdeal_comap | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Maps | ∀ {A : Type u_1} {B : Type u_2} {σ : Type u_4} {τ : Type u_5} {ι : Type u_7} [inst : Semiring A] [inst_1 : Semiring B]
[inst_2 : SetLike σ A] [inst_3 : SetLike τ B] [inst_4 : AddSubmonoidClass σ A] [inst_5 : AddSubmonoidClass τ B]
[inst_6 : DecidableEq ι] [inst_7 : AddMonoid ι] {𝒜 : ι → σ} {ℬ : ι → τ} [inst_8 : GradedRing 𝒜]
[inst_9 : GradedRing ℬ] (f : 𝒜 →+*ᵍ ℬ) {J : HomogeneousIdeal ℬ},
(HomogeneousIdeal.comap f J).toIdeal = Ideal.comap f J.toIdeal | true |
_private.Mathlib.MeasureTheory.Measure.Dirac.0.MeasureTheory.ae_dirac_eq._simp_1_1 | Mathlib.MeasureTheory.Measure.Dirac | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F α]
{μ : F} {s : Set α}, (s ∈ MeasureTheory.ae μ) = (μ sᶜ = 0) | false |
Module.Relations.Solution.IsPresentation.postcomp_uniq | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u} [inst : Ring A] {relations : Module.Relations A} {M : Type v} [inst_1 : AddCommGroup M]
[inst_2 : Module A M] {solution : relations.Solution M} (h : solution.IsPresentation) {N : Type v'}
[inst_3 : AddCommGroup N] [inst_4 : Module A N] {solution' : relations.Solution N} (h' : solution'.IsPresentation),
solution.postcomp ↑(h.uniq h') = solution' | true |
Finsupp.mapRange.linearMap_apply | Mathlib.LinearAlgebra.Finsupp.Defs | ∀ {α : Type u_1} {M : Type u_2} {N : Type u_3} {R : Type u_5} {R₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : Module R M] [inst_4 : AddCommMonoid N] [inst_5 : Module R₂ N] {σ₁₂ : R →+* R₂}
(f : M →ₛₗ[σ₁₂] N) (g : α →₀ M), (Finsupp.mapRange.linearMap f) g = Finsupp.mapRange ⇑f ⋯ g | true |
Lean.Meta.Grind.Arith.Cutsat.FindIntValResult.found.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.Search | ∀ (val : ℤ), sizeOf (Lean.Meta.Grind.Arith.Cutsat.FindIntValResult.found val) = 1 + sizeOf val | true |
CategoryTheory.ObjectProperty.commShiftι | Mathlib.CategoryTheory.ObjectProperty.Shift | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
(P : CategoryTheory.ObjectProperty C) →
{A : Type u_2} →
[inst_1 : AddMonoid A] →
[inst_2 : CategoryTheory.HasShift C A] → [inst_3 : P.IsStableUnderShift A] → P.ι.CommShift A | true |
Mathlib.Tactic.LinearCombination.smul_eq_const | Mathlib.Tactic.LinearCombination.Lemmas | ∀ {α : Type u_1} {K : Type u_2} {t s : K} [inst : SMul K α], t = s → ∀ (c : α), t • c = s • c | true |
Nat.size_bit | Mathlib.Data.Nat.Size | ∀ {b : Bool} {n : ℕ}, Nat.bit b n ≠ 0 → (Nat.bit b n).size = n.size.succ | true |
_private.Mathlib.Topology.Connected.Clopen.0.isPreconnected_iff_subset_of_disjoint_closed._simp_1_1 | Mathlib.Topology.Connected.Clopen | ∀ {α : Type u} {s t : Set α}, (¬s ⊆ t) = ∃ a ∈ s, a ∉ t | false |
WithTop.strictAnti_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {f : WithTop α → β},
StrictAnti f ↔ (StrictAnti fun a => f ↑a) ∧ ∀ (x : α), f ⊤ < f ↑x | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceL._proof_9 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (l r l_1 r_1 : Std.DTreeMap.Internal.Impl α β),
(l.size + 1 + r.size + 1 + (l_1.size + 1 + r_1.size) + 0 ≤ 1 ∨
l.size + 1 + r.size + 1 + (l_1.size + 1 + r_1.size) ≤ 3 * 0 ∧
0 ≤ 3 * (l.size + 1 + r.size + 1 + (l_1.size + 1 + r_1.size))) ∨
1 ≤ l.size + 1 + r.size + 1 + (l_1.size + 1 + r_1.size) ∧
(l.size + 1 + r.size + 1 + (l_1.size + 1 + r_1.size) - 1 + 0 ≤ 1 ∨
l.size + 1 + r.size + 1 + (l_1.size + 1 + r_1.size) - 1 ≤ 3 * 0 ∧
0 ≤ 3 * (l.size + 1 + r.size + 1 + (l_1.size + 1 + r_1.size) - 1)) →
False | false |
HomotopicalAlgebra.RightHomotopyRel.leftHomotopy | Mathlib.AlgebraicTopology.ModelCategory.Homotopy | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : HomotopicalAlgebra.ModelCategory C] →
{X Y : C} →
{f g : X ⟶ Y} →
[HomotopicalAlgebra.IsFibrant Y] →
HomotopicalAlgebra.RightHomotopyRel f g →
(Q : HomotopicalAlgebra.Cylinder X) → [Q.IsGood] → Q.LeftHomotopy f g | true |
CategoryTheory.Limits.createsFiniteColimitsOfCreatesCoequalizersAndFiniteCoproducts | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
[CategoryTheory.Limits.HasCoequalizers D] →
[CategoryTheory.Limits.HasFiniteCoproducts D] →
(G : CategoryTheory.Functor C D) →
[G.ReflectsIsomorphisms] →
[CategoryTheory.CreatesColimitsOfShape CategoryTheory.Limits.WalkingParallelPair G] →
[CategoryTheory.Limits.CreatesFiniteCoproducts G] → CategoryTheory.Limits.CreatesFiniteColimits G | true |
Finset.coe_wcovBy_coe._simp_1 | Mathlib.Data.Finset.Grade | ∀ {α : Type u_1} {s t : Finset α}, (↑s ⩿ ↑t) = (s ⩿ t) | false |
PEquiv.single_apply_of_ne | Mathlib.Data.PEquiv | ∀ {α : Type u} {β : Type v} [inst : DecidableEq α] [inst_1 : DecidableEq β] {a₁ a₂ : α},
a₁ ≠ a₂ → ∀ (b : β), (PEquiv.single a₁ b) a₂ = none | true |
Aesop.ForwardRule.mk._flat_ctor | Aesop.Rule.Forward | ℕ →
ℕ →
Array (Array Aesop.Slot) →
Array Aesop.PremiseIndex →
Option (Aesop.RulePattern × Aesop.PremiseIndex) →
Aesop.RuleName → Aesop.RuleTerm → Aesop.ForwardRulePriority → Aesop.ForwardRule | false |
QuaternionAlgebra.starAe._proof_4 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} {c₁ c₂ c₃ : R} [inst : CommRing R],
Function.RightInverse (starAddEquiv.trans MulOpposite.opAddEquiv).invFun
(starAddEquiv.trans MulOpposite.opAddEquiv).toFun | false |
Std.ExtHashSet.erase_empty | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α] {a : α}, ∅.erase a = ∅ | true |
Submodule.smul_of_tower_mem | Mathlib.Algebra.Module.Submodule.Defs | ∀ {S : Type u'} {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M}
(p : Submodule R M) {x : M} [inst_2 : SMul S R] [inst_3 : SMul S M] [IsScalarTower S R M] (r : S), x ∈ p → r • x ∈ p | true |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.Compacts.continuous_prod.match_1_5 | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (V : Set α) (W : Set β)
(motive : (x : TopologicalSpace.Compacts α × TopologicalSpace.Compacts β) → x ∈ {K | ↑K ⊆ V} ×ˢ {K | ↑K ⊆ W} → Prop)
(x : TopologicalSpace.Compacts α × TopologicalSpace.Compacts β) (x_1 : x ∈ {K | ↑K ⊆ V} ×ˢ {K | ↑K ⊆ W}),
(∀ (K' : TopologicalSpace.Compacts α) (L' : TopologicalSpace.Compacts β)
(x : (K', L') ∈ {K | ↑K ⊆ V} ×ˢ {K | ↑K ⊆ W}), motive (K', L') x) →
motive x x_1 | false |
Nat.getD_toArray_rcc_eq_fallback | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i fallback : ℕ}, n + 1 ≤ i + m → (m...=n).toArray.getD i fallback = fallback | true |
Lean.PrefixTreeNode.WellFormed.recOn | Lean.Data.PrefixTree | ∀ {α : Type u_1} {cmp : α → α → Ordering} {β : Type u_2}
{motive : (a : Lean.PrefixTreeNode α β cmp) → Lean.PrefixTreeNode.WellFormed cmp a → Prop}
{a : Lean.PrefixTreeNode α β cmp} (t : Lean.PrefixTreeNode.WellFormed cmp a),
motive Lean.PrefixTreeNode.empty ⋯ →
(∀ {t : Lean.PrefixTreeNode α β cmp} {k : List α} {val : β} (a : Lean.PrefixTreeNode.WellFormed cmp t),
motive t a → motive (Lean.PrefixTreeNode.insert cmp t k val) ⋯) →
motive a t | false |
_private.Mathlib.Analysis.Calculus.FDeriv.Measurable.0.FDerivMeasurableAux.D_subset_differentiable_set._proof_1_7 | Mathlib.Analysis.Calculus.FDeriv.Measurable | (3 + 1).AtLeastTwo | false |
Set.ncard_eq_zero._auto_1 | Mathlib.Data.Set.Card | Lean.Syntax | false |
String.Slice.toList_revPositions | Init.Data.String.Lemmas.Iterate | ∀ {s : String.Slice}, s.revPositions.toList = String.Slice.Model.revPositionsFrom s.endPos | true |
_private.Lean.Meta.Tactic.Cbv.Main.0.Lean.Meta.Tactic.Cbv.handleProj | Lean.Meta.Tactic.Cbv.Main | Lean.Meta.Sym.Simp.Simproc | true |
IsRadical | Mathlib.RingTheory.Nilpotent.Defs | {R : Type u_1} → [Dvd R] → [Pow R ℕ] → R → Prop | true |
Lean.MonadHashMapCacheAdapter.noConfusion | Lean.Util.MonadCache | {P : Sort u} →
{α β : Type} →
{m : Type → Type} →
{inst : BEq α} →
{inst_1 : Hashable α} →
{t : Lean.MonadHashMapCacheAdapter α β m} →
{α' β' : Type} →
{m' : Type → Type} →
{inst' : BEq α'} →
{inst'_1 : Hashable α'} →
{t' : Lean.MonadHashMapCacheAdapter α' β' m'} →
α = α' →
β = β' →
m = m' →
inst ≍ inst' →
inst_1 ≍ inst'_1 → t ≍ t' → Lean.MonadHashMapCacheAdapter.noConfusionType P t t' | false |
CategoryTheory.Oplax.StrongTrans.Hom._sizeOf_inst | 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) → [SizeOf B] → [SizeOf C] → SizeOf (CategoryTheory.Oplax.StrongTrans.Hom η θ) | false |
_private.Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Real.0.RealRMK.exists_nat_large | Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Real | ∀ (a' b' : ℝ) {ε : ℝ}, 0 < ε → ∃ N, 0 < N ∧ a' / ↑N * (b' + a' / ↑N) ≤ ε | true |
AlgebraicGeometry.IsImmersion.rec | Mathlib.AlgebraicGeometry.Morphisms.Immersion | {X Y : AlgebraicGeometry.Scheme} →
{f : X ⟶ Y} →
{motive : AlgebraicGeometry.IsImmersion f → Sort u_1} →
([toIsPreimmersion : AlgebraicGeometry.IsPreimmersion f] →
(isLocallyClosed_range : IsLocallyClosed (Set.range ⇑f)) → motive ⋯) →
(t : AlgebraicGeometry.IsImmersion f) → motive t | false |
SimpleGraph.Iso.mapNeighborSet._proof_2 | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {W : Type u_2} {G : SimpleGraph V} {G' : SimpleGraph W} (f : G ≃g G') (v : V) (w : ↑(G.neighborSet v)),
(fun w => ⟨f.symm ↑w, ⋯⟩) ((fun w => ⟨f ↑w, ⋯⟩) w) = w | false |
BitVec.getLsbD_rotateLeftAux_of_lt | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {r i : ℕ}, i < r → (x.rotateLeftAux r).getLsbD i = x.getLsbD (w - r + i) | true |
_private.Mathlib.Data.Vector.Basic.0.List.Vector.mOfFn.match_1.splitter | Mathlib.Data.Vector.Basic | {m : Type u_3 → Type u_2} →
{α : Type u_3} →
(motive : (x : ℕ) → (Fin x → m α) → Sort u_1) →
(x : ℕ) →
(x_1 : Fin x → m α) →
((x : Fin 0 → m α) → motive 0 x) → ((n : ℕ) → (f : Fin (n + 1) → m α) → motive n.succ f) → motive x x_1 | true |
Lean.Elab.Tactic.Try.evalTryTrace | Lean.Elab.Tactic.Try | Lean.Elab.Tactic.Tactic | true |
List.length_mapFinIdx_go | Init.Data.List.MapIdx | ∀ {α : Type u_1} {as : List α} {α_1 : Type u_2} {f : (i : ℕ) → α → i < as.length → α_1} {bs : List α} {acc : Array α_1}
{h : bs.length + acc.size = as.length}, (List.mapFinIdx.go as f bs acc h).length = as.length | true |
USize.zero_or | Init.Data.UInt.Bitwise | ∀ {a : USize}, 0 ||| a = a | true |
Lean.Grind.AC.eq_erase_dup_cert | Init.Grind.AC | Lean.Grind.AC.Seq → Lean.Grind.AC.Seq → Lean.Grind.AC.Seq → Lean.Grind.AC.Seq → Bool | true |
_private.Lean.Meta.CongrTheorems.0.Lean.Meta.getFVarId.match_1 | Lean.Meta.CongrTheorems | (motive : Option Lean.Expr → Sort u_1) →
(x : Option Lean.Expr) → ((h : Lean.Expr) → motive (some h)) → ((x : Option Lean.Expr) → motive x) → motive x | false |
ContinuousMap.homotopicRel_empty | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f₀ f₁ : C(X, Y)},
f₀.HomotopicRel f₁ ∅ ↔ f₀.Homotopic f₁ | true |
Manifold.riemannianEDist_comm | Mathlib.Geometry.Manifold.Riemannian.PathELength | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type u_2} [inst_2 : TopologicalSpace H]
{I : ModelWithCorners ℝ E H} {M : Type u_3} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M]
[inst_5 : (x : M) → ENorm (TangentSpace I x)] [∀ (x : M), ENormSMulClass ℝ (TangentSpace I x)] {x y : M},
Manifold.riemannianEDist I x y = Manifold.riemannianEDist I y x | true |
CategoryTheory.ProjectiveResolution.isoExt._proof_2 | Mathlib.CategoryTheory.Abelian.Ext | ∀ {R : Type u_2} [inst : Ring R], CategoryTheory.CategoryWithHomology (ModuleCat R)ᵒᵖ | false |
_private.Init.Data.Int.Linear.0.Int.Linear.Expr.denote.match_1.eq_1 | Init.Data.Int.Linear | ∀ (motive : Int.Linear.Expr → Sort u_1) (a b : Int.Linear.Expr) (h_1 : (a b : Int.Linear.Expr) → motive (a.add b))
(h_2 : (a b : Int.Linear.Expr) → motive (a.sub b)) (h_3 : (a : Int.Linear.Expr) → motive a.neg)
(h_4 : (k : ℤ) → motive (Int.Linear.Expr.num k)) (h_5 : (v : Int.Linear.Var) → motive (Int.Linear.Expr.var v))
(h_6 : (k : ℤ) → (e : Int.Linear.Expr) → motive (Int.Linear.Expr.mulL k e))
(h_7 : (e : Int.Linear.Expr) → (k : ℤ) → motive (e.mulR k)),
(match a.add b with
| a.add b => h_1 a b
| a.sub b => h_2 a b
| a.neg => h_3 a
| Int.Linear.Expr.num k => h_4 k
| Int.Linear.Expr.var v => h_5 v
| Int.Linear.Expr.mulL k e => h_6 k e
| e.mulR k => h_7 e k) =
h_1 a b | true |
LieModule.isNilpotent_quotient_iff | Mathlib.Algebra.Lie.Nilpotent | ∀ (R : Type u) (L : Type v) (M : Type w) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] (N : LieSubmodule R L M)
[inst_6 : LieModule R L M], LieModule.IsNilpotent L (M ⧸ N) ↔ ∃ k, LieModule.lowerCentralSeries R L M k ≤ N | true |
Lean.ReducibilityStatus.semireducible.sizeOf_spec | Lean.ReducibilityAttrs | sizeOf Lean.ReducibilityStatus.semireducible = 1 | true |
Lean.Order.PProd.chain.snd | Init.Internal.Order.Basic | {α : Sort u} → {β : Sort v} → [Lean.Order.CCPO α] → [Lean.Order.CCPO β] → (α ×' β → Prop) → β → Prop | true |
ContinuousAffineEquiv.continuous | Mathlib.Topology.Algebra.ContinuousAffineEquiv | ∀ {k : Type u_1} {P₁ : Type u_2} {P₂ : Type u_3} {V₁ : Type u_6} {V₂ : Type u_7} [inst : Ring k]
[inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁] [inst_3 : AddTorsor V₁ P₁] [inst_4 : TopologicalSpace P₁]
[inst_5 : AddCommGroup V₂] [inst_6 : Module k V₂] [inst_7 : AddTorsor V₂ P₂] [inst_8 : TopologicalSpace P₂]
(e : P₁ ≃ᴬ[k] P₂), Continuous ⇑e | true |
CategoryTheory.Limits.cokernelBiprodInlIso_inv | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y],
CategoryTheory.Limits.cokernelBiprodInlIso.inv =
(CategoryTheory.Limits.biprod.isCokernelInlCokernelFork X Y).desc
(CategoryTheory.Limits.colimit.cocone (CategoryTheory.Limits.parallelPair CategoryTheory.Limits.biprod.inl 0)) | true |
Std.DHashMap.Raw.Equiv.diff_left | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ m₃ : Std.DHashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → m₃.WF → m₁.Equiv m₂ → (m₁ \ m₃).Equiv (m₂ \ m₃) | true |
_private.Mathlib.NumberTheory.Ostrowski.0.Rat.AbsoluteValue.eq_one_of_not_dvd._simp_1_3 | Mathlib.NumberTheory.Ostrowski | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddLeftStrictMono α] {a : α}, (0 < -a) = (a < 0) | false |
Cardinal.ofENat_le_ofNat | Mathlib.SetTheory.Cardinal.ENat | ∀ {m : ℕ∞} {n : ℕ} [inst : n.AtLeastTwo], ↑m ≤ OfNat.ofNat n ↔ m ≤ OfNat.ofNat n | true |
UpperSet.Ici_strictMono | Mathlib.Order.UpperLower.Principal | ∀ (α : Type u_1) [inst : Preorder α], StrictMono UpperSet.Ici | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.