name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Polynomial.zero_of_eval_zero | Mathlib.Algebra.Polynomial.Roots | ∀ {R : Type u} [inst : CommRing R] [IsDomain R] [Infinite R] (p : Polynomial R),
(∀ (x : R), Polynomial.eval x p = 0) → p = 0 | true |
RingQuot.definition._@.Mathlib.Algebra.RingQuot.3673095128._hygCtx._hyg.2 | Mathlib.Algebra.RingQuot | (S : Type uS) →
[inst : CommSemiring S] →
{A : Type uA} → [inst_1 : Semiring A] → [inst_2 : Algebra S A] → (s : A → A → Prop) → A →ₐ[S] RingQuot s | false |
Set.NPow | Mathlib.Algebra.Group.Pointwise.Set.Basic | {α : Type u_2} → [One α] → [Mul α] → Pow (Set α) ℕ | true |
Std.TreeSet.Raw.instSliceableRccSlice | Std.Data.TreeSet.Raw.Slice | {α : Type u} →
(cmp : autoParam (α → α → Ordering) Std.TreeSet.Raw.instSliceableRccSlice._auto_1) →
Std.Rcc.Sliceable (Std.TreeSet.Raw α cmp) α (Std.DTreeMap.Internal.Unit.RccSlice α) | true |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind.enumWithDefault.elim | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic | {motive : Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind → Sort u} →
(t : Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind) →
t.ctorIdx = 1 →
((info : Lean.InductiveVal) →
(ctors : Array Lean.ConstructorVal) →
motive (Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind... | false |
Finset.one_le_divConst_self | Mathlib.Combinatorics.Additive.DoublingConst | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] {A : Finset G}, A.Nonempty → 1 ≤ A.divConst A | true |
Lean.Meta.StructProjDecl._sizeOf_inst | Lean.Meta.Structure | SizeOf Lean.Meta.StructProjDecl | false |
OpenPartialHomeomorph.ofSet_symm | Mathlib.Topology.OpenPartialHomeomorph.IsImage | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X} (hs : IsOpen s),
(OpenPartialHomeomorph.ofSet s hs).symm = OpenPartialHomeomorph.ofSet s hs | true |
Std.Time.Database.TZdb.inst.match_1 | Std.Time.Zoned.Database.TZdb | (motive : Option String → Sort u_1) →
(env : Option String) → ((path : String) → motive (some path)) → ((x : Option String) → motive x) → motive env | false |
_private.Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous.0.MvPolynomial.weightedHomogeneousComponent_finsupp._simp_1_2 | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | false |
_private.Mathlib.Topology.LocallyFinite.0.LocallyFinite.closure_iUnion._simp_1_1 | Mathlib.Topology.LocallyFinite | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {s : Set X}, (x ∈ closure s) = (nhdsWithin x s).NeBot | false |
Std.Time.ZonedDateTime.toPlainDateTime | Std.Time.Zoned.ZonedDateTime | Std.Time.ZonedDateTime → Std.Time.PlainDateTime | true |
Multiset.decidableEq._proof_2 | Mathlib.Data.Multiset.Defs | ∀ {α : Type u_1} (x x_1 : List α), ⟦x⟧ = ⟦x_1⟧ ↔ x ≈ x_1 | false |
gcd_same | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] (a : α), gcd a a = normalize a | true |
Lean.Elab.InlayHintTextEdit.recOn | Lean.Elab.InfoTree.InlayHints | {motive : Lean.Elab.InlayHintTextEdit → Sort u} →
(t : Lean.Elab.InlayHintTextEdit) →
((range : Lean.Syntax.Range) → (newText : String) → motive { range := range, newText := newText }) → motive t | false |
NormedAddGroupHom.coeAddHom_apply | Mathlib.Analysis.Normed.Group.Hom | ∀ {V₁ : Type u_2} {V₂ : Type u_3} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
(a : NormedAddGroupHom V₁ V₂) (a_1 : V₁), NormedAddGroupHom.coeAddHom a a_1 = a a_1 | true |
CategoryTheory.ShortComplex.Exact.epi_f | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S : CategoryTheory.ShortComplex C}, S.Exact → S.g = 0 → CategoryTheory.Epi S.f | true |
bddAbove_Ioc | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, BddAbove (Set.Ioc a b) | true |
CochainComplex.HomComplex.leftHomologyData'_π | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexCohomology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(K L : CochainComplex C ℤ) (n m p : ℤ) (hm : n + 1 = m) (hp : m + 1 = p),
(CochainComplex.HomComplex.leftHomologyData' K L n m p hm hp).π =
AddCommGrpCat.ofHom (CochainComplex.HomComplex.CohomologyClass.mkAddMonoidH... | true |
HomologicalComplex.shortComplexFunctor'._proof_5 | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_3} (c : ComplexShape ι) (i j k : ι) (X : HomologicalComplex C c),
{ τ₁ := (CategoryTheory.CategoryStruct.id X).f i, τ₂ := (CategoryTheory.CategoryStruct.id X).f j,
τ₃ := (CategoryTheo... | false |
Measurable.lmarginal | Mathlib.MeasureTheory.Integral.Marginal | ∀ {δ : Type u_1} {X : δ → Type u_3} [inst : (i : δ) → MeasurableSpace (X i)] (μ : (i : δ) → MeasureTheory.Measure (X i))
[inst_1 : DecidableEq δ] {s : Finset δ} {f : ((i : δ) → X i) → ENNReal} [∀ (i : δ), MeasureTheory.SigmaFinite (μ i)],
Measurable f → Measurable (∫⋯∫⁻_s, f ∂μ) | true |
MeasureTheory.Measure.toSphere_apply_aux | Mathlib.MeasureTheory.Constructions.HaarToSphere | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E]
(μ : MeasureTheory.Measure E) (s : Set ↑(Metric.sphere 0 1)) (r : ↑(Set.Ioi 0)),
μ (Subtype.val '' (⇑(homeomorphUnitSphereProd E) ⁻¹' s ×ˢ Set.Iio r)) = μ (Set.Ioo 0 ↑r • Subtype.val '' s) | true |
CoalgHom.End._proof_3 | Mathlib.RingTheory.Coalgebra.Hom | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : CoalgebraStruct R A] (x x_1 x_2 : A →ₗc[R] A), x * x_1 * x_2 = x * x_1 * x_2 | false |
InitialSeg.total | Mathlib.Order.InitialSeg | {α : Type u_1} →
{β : Type u_2} →
(r : α → α → Prop) → (s : β → β → Prop) → [IsWellOrder α r] → [IsWellOrder β s] → InitialSeg r s ⊕ InitialSeg s r | true |
Set.unit._proof_4 | Mathlib.RingTheory.DedekindDomain.SInteger | ∀ {R : Type u_2} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (S : Set (IsDedekindDomain.HeightOneSpectrum R))
(K : Type u_1) [inst_2 : Field K] [inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (x : Kˣ),
x ∈ {x | ∀ v ∉ S, (IsDedekindDomain.HeightOneSpectrum.valuation K v) ↑x = 1} ↔
x ∈ ↑(⨅ v, ⨅ (_ : v ... | false |
Polynomial.instIsJacobsonRing | Mathlib.RingTheory.Jacobson.Ring | ∀ {R : Type u_1} [inst : CommRing R] [IsJacobsonRing R], IsJacobsonRing (Polynomial R) | true |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Finset.prod_fin_Icc_eq_prod_nat_Icc._proof_1_5 | Mathlib.Algebra.BigOperators.Intervals | ∀ {α : Type u_1} [inst : CommMonoid α] {n : ℕ} (a b : Fin n) (f : Fin n → α),
∀ a_1 ∈ Finset.Icc ↑a ↑b, a_1 ∉ Finset.range n → (if h : a_1 < n then f ⟨a_1, h⟩ else 1) = 1 | false |
fintypeNodupList._simp_3 | Mathlib.Data.Fintype.List | ∀ {α : Type u_1} {β : Type v} {b : β} {s : Multiset α} {f : α → Multiset β}, (b ∈ s.bind f) = ∃ a ∈ s, b ∈ f a | false |
LinearMap.ofIsComplProdEquiv._proof_2 | Mathlib.LinearAlgebra.Projection | ∀ {R₁ : Type u_1} [inst : CommRing R₁], RingHomInvPair (RingHom.id R₁) (RingHom.id R₁) | false |
IsRelPrime.neg_right | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u_1} [inst : CommRing R] {x y : R}, IsRelPrime x y → IsRelPrime x (-y) | true |
Mathlib.Tactic.BicategoryLike.IsoLift.mk._flat_ctor | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Mathlib.Tactic.BicategoryLike.Mor₂Iso → Lean.Expr → Mathlib.Tactic.BicategoryLike.IsoLift | false |
Representation.invtSubmodule.instBoundedOrderSubtypeSubmoduleMemSublattice.match_1 | Mathlib.RepresentationTheory.Submodule | ∀ {k : Type u_2} {G : Type u_3} {V : Type u_1} [inst : CommSemiring k] [inst_1 : Monoid G] [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] (ρ : Representation k G V) (motive : ↥ρ.invtSubmodule → Prop) (x : ↥ρ.invtSubmodule),
(∀ (p : Submodule k V) (hp : p ∈ ρ.invtSubmodule), motive ⟨p, hp⟩) → motive x | false |
Equiv.Perm.IsCycle.zpowersEquivSupport.congr_simp | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Fintype α] {σ : Equiv.Perm α} (hσ : σ.IsCycle),
hσ.zpowersEquivSupport = hσ.zpowersEquivSupport | true |
Std.TreeMap.getKey?_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeMap α Unit cmp} [Std.TransCmp cmp] {l : List α} {k k' : α},
cmp k k' = Ordering.eq →
k ∉ t → List.Pairwise (fun a b => ¬cmp a b = Ordering.eq) l → k ∈ l → (t.insertManyIfNewUnit l).getKey? k' = some k | true |
ModelWithCorners.continuous_invFun | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (self : ModelWithCorners 𝕜 E H),
Continuous self.invFun | true |
AlgEquiv.autCongr_trans | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {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 : Algebra R A₁] [inst_5 : Algebra R A₂] [inst_6 : Algebra R A₃]
(ϕ : A₁ ≃ₐ[R] A₂) (ψ : A₂ ≃ₐ[R] A₃), ϕ.autCongr.trans ψ.autCongr = (ϕ.trans ψ).autCongr | true |
Set.image_subset_iff | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, f '' s ⊆ t ↔ s ⊆ f ⁻¹' t | true |
AlgebraicGeometry.Scheme.Opens.fromSpecStalkOfMem_toSpecΓ_assoc | Mathlib.AlgebraicGeometry.Stalk | ∀ {X : AlgebraicGeometry.Scheme} (U : X.Opens) (x : ↥X) (hxU : x ∈ U) {Z : AlgebraicGeometry.Scheme}
(h : AlgebraicGeometry.Spec (X.presheaf.obj (Opposite.op U)) ⟶ Z),
CategoryTheory.CategoryStruct.comp (U.fromSpecStalkOfMem x hxU) (CategoryTheory.CategoryStruct.comp U.toSpecΓ h) =
CategoryTheory.CategoryStruct... | true |
ISize | Init.Data.SInt.Basic | Type | true |
ContinuousMap.Homotopy.affine_apply | Mathlib.Topology.Homotopy.Affine | ∀ {X : Type u_1} {E : Type u_2} [inst : TopologicalSpace X] [inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E]
[inst_3 : IsTopologicalAddGroup E] [inst_4 : Module ℝ E] [inst_5 : ContinuousSMul ℝ E] (f g : C(X, E))
(x : ↑unitInterval × X), (ContinuousMap.Homotopy.affine f g) x = (AffineMap.lineMap (f x.2) (g x.... | true |
_private.Lean.Meta.MkIffOfInductiveProp.0.Lean.Meta.constrToProp.match_3 | Lean.Meta.MkIffOfInductiveProp | (motive : Option ℕ × Lean.Expr → Sort u_1) →
(__discr : Option ℕ × Lean.Expr) → ((n : Option ℕ) → (r : Lean.Expr) → motive (n, r)) → motive __discr | false |
TensorProduct.Neg.aux | Mathlib.LinearAlgebra.TensorProduct.Basic | (R : Type u_1) →
[inst : CommSemiring R] →
{M : Type u_2} →
{N : Type u_3} →
[inst_1 : AddCommGroup M] →
[inst_2 : AddCommMonoid N] →
[inst_3 : Module R M] → [inst_4 : Module R N] → TensorProduct R M N →ₗ[R] TensorProduct R M N | true |
CategoryTheory.eqToIso | Mathlib.CategoryTheory.EqToHom | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → {X Y : C} → X = Y → (X ≅ Y) | true |
Lean.Elab.instInhabitedDefView | Lean.Elab.DefView | Inhabited Lean.Elab.DefView | true |
SSet.prodStdSimplex.objEquiv._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.ProdStdSimplex | ∀ {p q n : ℕ}
(x :
(CategoryTheory.MonoidalCategoryStruct.tensorObj (SSet.stdSimplex.obj (SimplexCategory.mk p))
(SSet.stdSimplex.obj (SimplexCategory.mk q))).obj
(Opposite.op (SimplexCategory.mk n))),
(SSet.stdSimplex.objEquiv.symm
(SimplexCategory.Hom.mk
(OrderHom.fst.comp
... | false |
ZMod.charZero | Mathlib.Data.ZMod.Basic | CharZero (ZMod 0) | true |
ENNReal.tendsto_inv_iff | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : InvolutiveInv G] [ContinuousInv G] {l : Filter α}
{m : α → G} {a : G}, Filter.Tendsto (fun x => (m x)⁻¹) l (nhds a⁻¹) ↔ Filter.Tendsto m l (nhds a) | true |
_private.Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence.0.CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._proof_11 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (r₀ r : ℤ), r₀ + -1 * r ≤ 0 → r₀ ≤ r | false |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunctionRecurrence_eq_prefixFunction._simp_1_5 | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {k : ℕ} {pat : ByteArray} {stackPos : ℕ} {hst : stackPos < pat.size},
(String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunction✝ pat stackPos hst ≤ k) =
∀ (k' : ℕ),
k < k' → k' ≤ stackPos → ¬String.Slice.Pattern.Model.ForwardSliceSearcher.PartialMatch✝ pat pat k' (stackPos + 1) | false |
Besicovitch.SatelliteConfig.mk.inj | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} {inst : MetricSpace α} {N : ℕ} {τ : ℝ} {c : Fin N.succ → α} {r : Fin N.succ → ℝ}
{rpos : ∀ (i : Fin N.succ), 0 < r i}
{h : Pairwise fun i j => r i ≤ dist (c i) (c j) ∧ r j ≤ τ * r i ∨ r j ≤ dist (c j) (c i) ∧ r i ≤ τ * r j}
{hlast : ∀ i < Fin.last N, r i ≤ dist (c i) (c (Fin.last N)) ∧ r (Fin.las... | true |
ProbabilityTheory.Kernel.withDensity_rnDeriv_of_subset_mutuallySingularSetSlice | Mathlib.Probability.Kernel.RadonNikodym | ∀ {α : Type u_1} {γ : Type u_2} {mα : MeasurableSpace α} {mγ : MeasurableSpace γ} {κ η : ProbabilityTheory.Kernel α γ}
[hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ] [ProbabilityTheory.IsFiniteKernel κ]
[inst : ProbabilityTheory.IsFiniteKernel η] {a : α} {s : Set γ},
s ⊆ κ.mutuallySingularSetSlice η a ... | true |
Hindman.FS.brecOn | Mathlib.Combinatorics.Hindman | ∀ {M : Type u_1} [inst : AddSemigroup M] {motive : (a : Stream' M) → (a_1 : M) → Hindman.FS a a_1 → Prop}
{a : Stream' M} {a_1 : M} (t : Hindman.FS a a_1),
(∀ (a : Stream' M) (a_2 : M) (t : Hindman.FS a a_2), Hindman.FS.below t → motive a a_2 t) → motive a a_1 t | true |
Lean.PersistentHashMap.Entry.ctorElimType | Lean.Data.PersistentHashMap | {α : Type u} →
{β : Type v} →
{σ : Type w} →
{motive : Lean.PersistentHashMap.Entry α β σ → Sort u_1} →
ℕ → Sort (max 1 u_1 (imax (u + 1) (v + 1) u_1) (imax (w + 1) u_1)) | false |
SimpleGraph.TripartiteFromTriangles.Graph.in₂₁_iff._simp_1 | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {t : Finset (α × β × γ)} {b : β} {c : γ},
(SimpleGraph.TripartiteFromTriangles.graph t).Adj (Sum3.in₂ c) (Sum3.in₁ b) = ∃ a, (a, b, c) ∈ t | false |
GradeMinOrder.recOn | Mathlib.Order.Grade | {𝕆 : Type u_5} →
{α : Type u_6} →
[inst : Preorder 𝕆] →
[inst_1 : Preorder α] →
{motive : GradeMinOrder 𝕆 α → Sort u} →
(t : GradeMinOrder 𝕆 α) →
([toGradeOrder : GradeOrder 𝕆 α] →
(isMin_grade : ∀ ⦃a : α⦄, IsMin a → IsMin (GradeOrder.grade a)) →
... | false |
Aesop.RulePatternIndex.recOn | Aesop.Index.RulePattern | {motive : Aesop.RulePatternIndex → Sort u} →
(t : Aesop.RulePatternIndex) →
((tree : Lean.Meta.DiscrTree Aesop.RulePatternIndex.Entry) →
(isEmpty : Bool) → motive { tree := tree, isEmpty := isEmpty }) →
motive t | false |
CategoryTheory.GrothendieckTopology.instIsGeneratedByOneHypercovers | Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C),
J.IsGeneratedByOneHypercovers | true |
_private.Mathlib.Order.OrderIsoNat.0.RelEmbedding.wellFounded_iff_isEmpty.match_1_1 | Mathlib.Order.OrderIsoNat | ∀ {α : Type u_1} {r : α → α → Prop} (motive : WellFounded r → Prop) (x : WellFounded r),
(∀ (h : ∀ (a : α), Acc r a), motive ⋯) → motive x | false |
Polynomial.Chebyshev.S_two_mul_complex_cosh | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Basic | ∀ (θ : ℂ) (n : ℤ),
Polynomial.eval (2 * Complex.cosh θ) (Polynomial.Chebyshev.S ℂ n) * Complex.sinh θ = Complex.sinh ((↑n + 1) * θ) | true |
NumberField.InfinitePlace.embedding_of_isReal_apply | Mathlib.NumberTheory.NumberField.InfinitePlace.Basic | ∀ {K : Type u_1} [inst : Field K] {w : NumberField.InfinitePlace K} (hw : w.IsReal) (x : K),
↑((NumberField.InfinitePlace.embedding_of_isReal hw) x) = w.embedding x | true |
Std.HashMap.contains_keysArray | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k : α}, m.keysArray.contains k = m.contains k | true |
ContinuousInv.measurableInv | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | ∀ {γ : Type u_3} [inst : TopologicalSpace γ] [inst_1 : MeasurableSpace γ] [BorelSpace γ] [inst_3 : Inv γ]
[ContinuousInv γ], MeasurableInv γ | true |
Homotopy.compLeftId | Mathlib.Algebra.Homology.Homotopy | {ι : Type u_1} →
{V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Preadditive V] →
{c : ComplexShape ι} →
{C D : HomologicalComplex V c} →
{f : D ⟶ D} →
Homotopy f (CategoryTheory.CategoryStruct.id D) →
(g : C ⟶ D... | true |
CategoryTheory.Join.mapWhiskerRight_rightUnitor_hom | Mathlib.CategoryTheory.Join.Pseudofunctor | ∀ {A : Type u_1} {B : Type u_2} (C : Type u_3) [inst : CategoryTheory.Category.{v_1, u_1} A]
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
(F : CategoryTheory.Functor A B),
CategoryTheory.Join.mapWhiskerRight F.rightUnitor.hom (CategoryTheory.Functor.id C) =
C... | true |
Std.TreeMap.Raw._sizeOf_inst | Std.Data.TreeMap.Raw.Basic | (α : Type u) →
(β : Type v) →
(cmp : autoParam (α → α → Ordering) Std.TreeMap.Raw._auto_1) →
[SizeOf α] → [SizeOf β] → SizeOf (Std.TreeMap.Raw α β cmp) | false |
OrderAddMonoidHom.instAddOfIsOrderedAddMonoid.eq_1 | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} [inst : AddCommMonoid α] [inst_1 : Preorder α] [inst_2 : AddCommMonoid β]
[inst_3 : Preorder β] [inst_4 : IsOrderedAddMonoid β],
OrderAddMonoidHom.instAddOfIsOrderedAddMonoid =
{
add := fun f g =>
let __src := ↑f + ↑g;
{ toAddMonoidHom := __src, monotone' :=... | true |
CategoryTheory.Limits.opProdIsoCoprod_inv_inl | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Products | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {A B : C}
[inst_1 : CategoryTheory.Limits.HasBinaryProduct A B],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.opProdIsoCoprod A B).inv.unop
CategoryTheory.Limits.coprod.inl.unop =
CategoryTheory.Limits.prod.fst | true |
TopologicalSpace.IsTopologicalBasis.isOpen_iff | Mathlib.Topology.Bases | ∀ {α : Type u} [t : TopologicalSpace α] {s : Set α} {b : Set (Set α)},
TopologicalSpace.IsTopologicalBasis b → (IsOpen s ↔ ∀ a ∈ s, ∃ t ∈ b, a ∈ t ∧ t ⊆ s) | true |
AddCon.addMonoid._proof_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : AddMonoid M] (c : AddCon M) (a : c.Quotient), 0 + a = a | false |
SimpleGraph.bot_adj | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} (v w : V), ⊥.Adj v w ↔ False | true |
Subring.mem_pointwise_smul_iff_inv_smul_mem | Mathlib.Algebra.Ring.Subring.Pointwise | ∀ {M : Type u_1} {R : Type u_2} [inst : Group M] [inst_1 : Ring R] [inst_2 : MulSemiringAction M R] {a : M}
{S : Subring R} {x : R}, x ∈ a • S ↔ a⁻¹ • x ∈ S | true |
CategoryTheory.Grp.hom_one | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp_ | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (H : CategoryTheory.Grp C) [inst_3 : CategoryTheory.IsCommMonObj H.X],
CategoryTheory.MonObj.one.hom.hom = CategoryTheory.MonObj.one | true |
Aesop.Hyp.mk | Aesop.Forward.State | Option Lean.FVarId → Aesop.Substitution → Aesop.Hyp | true |
TypeVec.splitFun | Mathlib.Data.TypeVec | {n : ℕ} →
{α : TypeVec.{u_1} (n + 1)} → {α' : TypeVec.{u_2} (n + 1)} → α.drop.Arrow α'.drop → (α.last → α'.last) → α.Arrow α' | true |
Lean.Elab.CommandContextInfo.mk.injEq | Lean.Elab.InfoTree.Types | ∀ (env : Lean.Environment) (cmdEnv? : Option Lean.Environment) (fileMap : Lean.FileMap) (mctx : Lean.MetavarContext)
(options : Lean.Options) (currNamespace : Lean.Name) (openDecls : List Lean.OpenDecl) (ngen : Lean.NameGenerator)
(env_1 : Lean.Environment) (cmdEnv?_1 : Option Lean.Environment) (fileMap_1 : Lean.Fi... | true |
PowerSeries.coeff_pow | Mathlib.RingTheory.PowerSeries.Basic | ∀ {R : Type u_2} [inst : CommSemiring R] (k n : ℕ) (φ : PowerSeries R),
(PowerSeries.coeff n) (φ ^ k) =
∑ l ∈ (Finset.range k).finsuppAntidiag n, ∏ i ∈ Finset.range k, (PowerSeries.coeff (l i)) φ | true |
fderivWithin_inter | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {x : E} {s t : Set E},
t ∈ nhds x → fderivWithin 𝕜 f (s ∩ t... | true |
_private.Mathlib.Order.Category.BoolAlg.0.BoolAlg.Hom.mk.injEq | Mathlib.Order.Category.BoolAlg | ∀ {X Y : BoolAlg} (hom' hom'_1 : BoundedLatticeHom ↑X ↑Y), ({ hom' := hom' } = { hom' := hom'_1 }) = (hom' = hom'_1) | true |
HahnModule.instIsTorsionFree | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {R : Type u_3} {Γ : Type u_6} {V : Type u_7} [inst : Ring R] [IsDomain R] [inst_2 : AddCommGroup V]
[inst_3 : AddCommMonoid Γ] [inst_4 : LinearOrder Γ] [inst_5 : IsOrderedCancelAddMonoid Γ] [inst_6 : Module R V]
[Module.IsTorsionFree R V], Module.IsTorsionFree (HahnSeries Γ R) (HahnModule Γ R V) | true |
_private.Mathlib.Geometry.Manifold.VectorBundle.Hom.0.ContMDiffWithinAt.clm_bundle_apply._simp_1_1 | Mathlib.Geometry.Manifold.VectorBundle.Hom | ∀ {𝕜 : Type u_1} {B : Type u_2} {F₁ : Type u_3} {F₂ : Type u_4} {M : Type u_5} {n : WithTop ℕ∞} {E₁ : B → Type u_6}
{E₂ : B → Type u_7} [inst : NontriviallyNormedField 𝕜] [inst_1 : (x : B) → AddCommGroup (E₁ x)]
[inst_2 : (x : B) → Module 𝕜 (E₁ x)] [inst_3 : NormedAddCommGroup F₁] [inst_4 : NormedSpace 𝕜 F₁]
... | false |
Std.ExtHashSet.contains_of_contains_insert' | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashSet α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{k a : α}, (m.insert k).contains a = true → ¬((k == a) = true ∧ m.contains k = false) → m.contains a = true | true |
AddCommGrpCat.epi_iff_range_eq_top | Mathlib.Algebra.Category.Grp.EpiMono | ∀ {A B : AddCommGrpCat} (f : A ⟶ B), CategoryTheory.Epi f ↔ (AddCommGrpCat.Hom.hom f).range = ⊤ | true |
_private.Mathlib.Algebra.Order.Archimedean.Basic.0.archimedean_iff_nat_le.match_1_1 | Mathlib.Algebra.Order.Archimedean.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : LinearOrder K] (x : K) (motive : (∃ n, x ≤ ↑n) → Prop) (x_1 : ∃ n, x ≤ ↑n),
(∀ (n : ℕ) (h : x ≤ ↑n), motive ⋯) → motive x_1 | false |
Lean.Elab.Visibility.private.elim | Lean.Elab.DeclModifiers | {motive : Lean.Elab.Visibility → Sort u} →
(t : Lean.Elab.Visibility) → t.ctorIdx = 1 → motive Lean.Elab.Visibility.private → motive t | false |
Finset.Icc_ofDual | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] (a b : αᵒᵈ),
Finset.Icc (OrderDual.ofDual a) (OrderDual.ofDual b) = Finset.map OrderDual.ofDual.toEmbedding (Finset.Icc b a) | true |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable.0.EisensteinSeries.div_max_sq_ge_one._simp_1_4 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable | ∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True | false |
DoubleCoset.eq_of_not_disjoint | Mathlib.GroupTheory.DoubleCoset | ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G} {a b : G},
¬Disjoint (DoubleCoset.doubleCoset a ↑H ↑K) (DoubleCoset.doubleCoset b ↑H ↑K) →
DoubleCoset.doubleCoset a ↑H ↑K = DoubleCoset.doubleCoset b ↑H ↑K | true |
Mathlib.Tactic.Bicategory.naturality_inv | Mathlib.Tactic.CategoryTheory.Bicategory.PureCoherence | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {p : a ⟶ b} {f g : b ⟶ c} {pf : a ⟶ c} {η : f ≅ g}
(η_f : CategoryTheory.CategoryStruct.comp p f ≅ pf) (η_g : CategoryTheory.CategoryStruct.comp p g ≅ pf),
CategoryTheory.Bicategory.whiskerLeftIso p η ≪≫ η_g = η_f →
CategoryTheory.Bicategory.whiske... | true |
ISize.div_self | Init.Data.SInt.Lemmas | ∀ {a : ISize}, a / a = if a = 0 then 0 else 1 | true |
Affine.Simplex.altitudeFoot_mem_affineSpan_image_compl | Mathlib.Geometry.Euclidean.Altitude | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) (i : Fin (n + 1)),
s.altitudeFoot i ∈ affineSpan ℝ (s.points '' {i}ᶜ) | true |
One.toOfNat1.hcongr_2 | Mathlib.GroupTheory.CoprodI | ∀ (α α' : Type u_1), α = α' → ∀ (inst : One α) (inst' : One α'), inst ≍ inst' → One.toOfNat1 ≍ One.toOfNat1 | true |
CategoryTheory.RetractArrow.left_i | Mathlib.CategoryTheory.Retract | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z W : C} {f : X ⟶ Y} {g : Z ⟶ W}
(h : CategoryTheory.RetractArrow f g), h.left.i = h.i.left | true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Search.0.Lean.Meta.Grind.Arith.Cutsat.CooperSplit.assert.match_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Search | (motive : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → Sort u_1) →
(c₃? : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) →
((c₃ : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) → motive (some c₃)) →
((x : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) → motive x) → motive c₃? | false |
CategoryTheory.Limits.MulticospanIndex.sectionsEquiv._proof_5 | Mathlib.CategoryTheory.Limits.Types.Multiequalizer | ∀ {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J (Type u_1))
(s : ↑I.multicospan.sections),
(fun s =>
⟨fun i =>
match i with
| CategoryTheory.Limits.WalkingMulticospan.left i => s.val i
| CategoryTheory.Limits.WalkingMulticospan.right... | false |
Std.ExtTreeSet.self_le_max?_insert | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k kmi : α},
(t.insert k).max?.get ⋯ = kmi → (cmp k kmi).isLE = true | true |
_private.Batteries.Data.Fin.Lemmas.0.Fin.exists_eq_some_of_findSome?_eq_some._proof_1_1 | Batteries.Data.Fin.Lemmas | ∀ {n : ℕ} {α : Type u_1} {x : α} {f : Fin n → Option α}, Fin.findSome? f = some x → ∃ i, f i = some x | false |
DirectSum.Decomposition.casesOn | Mathlib.Algebra.DirectSum.Decomposition | {ι : Type u_1} →
{M : Type u_3} →
{σ : Type u_4} →
[inst : DecidableEq ι] →
[inst_1 : AddCommMonoid M] →
[inst_2 : SetLike σ M] →
[inst_3 : AddSubmonoidClass σ M] →
{ℳ : ι → σ} →
{motive : DirectSum.Decomposition ℳ → Sort u} →
(t ... | false |
_private.Init.Data.String.Basic.0.String.Slice.Pos.ofSliceFrom_le_ofSliceFrom_iff._simp_1_1 | Init.Data.String.Basic | ∀ {s : String.Slice} {l r : s.Pos}, (l ≤ r) = (l.offset ≤ r.offset) | false |
Lean.Expr.ensureHasNoMVars | Mathlib.Lean.Expr.Basic | Lean.Expr → Lean.MetaM Unit | true |
Std.DTreeMap.Internal.Impl.Const.entryAtIdx?.eq_def | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} (x : Std.DTreeMap.Internal.Impl α fun x => β) (x_1 : ℕ),
Std.DTreeMap.Internal.Impl.Const.entryAtIdx? x x_1 =
match x, x_1 with
| Std.DTreeMap.Internal.Impl.leaf, x => none
| Std.DTreeMap.Internal.Impl.inner size k v l r, n =>
match compare n l.size with
| Ordering.... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.