name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Elab.Do.observingPostpone | Lean.Elab.Do.Basic | {α : Type} → Lean.Elab.Do.DoElabM α → Lean.Elab.Do.DoElabM (Option α) | true |
CategoryTheory.Limits.HasImageMaps.has_image_map | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {inst_1 : CategoryTheory.Limits.HasImages C}
[self : CategoryTheory.Limits.HasImageMaps C] {f g : CategoryTheory.Arrow C} (st : f ⟶ g),
CategoryTheory.Limits.HasImageMap st | true |
IncidenceAlgebra.coe_add._simp_1 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_2} {α : Type u_5} [inst : AddZeroClass 𝕜] [inst_1 : LE α] (f g : IncidenceAlgebra 𝕜 α), ⇑f + ⇑g = ⇑(f + g) | false |
CategoryTheory.CommGrp.forget_obj | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X : CategoryTheory.CommGrp C),
(CategoryTheory.CommGrp.forget C).obj X = X.X | true |
AlgebraicGeometry.Scheme.Hom.resLE_appLE | Mathlib.AlgebraicGeometry.Restrict | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) {U : Y.Opens} {V : X.Opens}
(e : V ≤ (TopologicalSpace.Opens.map f.base).obj U) (O : (↑U).Opens) (W : (↑V).Opens)
(e' : W ≤ (TopologicalSpace.Opens.map (AlgebraicGeometry.Scheme.Hom.resLE f U V e).base).obj O),
AlgebraicGeometry.Scheme.Hom.appLE (AlgebraicGeometry.Sc... | true |
Lean.NamePart.num.noConfusion | Lean.Data.NameTrie | {P : Sort u} → {n n' : ℕ} → Lean.NamePart.num n = Lean.NamePart.num n' → (n = n' → P) → P | false |
CategoryTheory.Sieve.pushforward_monotone | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : Y ⟶ X),
Monotone (CategoryTheory.Sieve.pushforward f) | true |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.DiagramWithUniqueTerminal.mk.congr_simp | Mathlib.CategoryTheory.Presentable.Directed | ∀ {J : Type w} [inst : CategoryTheory.SmallCategory J] {κ : Cardinal.{w}}
(toDiagram : CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram J κ) (top : J)
(isTerminal isTerminal_1 : toDiagram.IsTerminal top),
isTerminal = isTerminal_1 →
∀ (uniq_terminal : ∀ (j : J) (hj : toDiagram.IsTerminal j),... | true |
QuotientGroup.Quotient.group._proof_8 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} [inst : Group G] (N : Subgroup G) [nN : N.Normal],
autoParam (∀ (a b : G ⧸ N), a / b = a * b⁻¹) DivInvMonoid.div_eq_mul_inv._autoParam | false |
Group.exponent_dvd_iff_forall_zpow_eq_one | Mathlib.GroupTheory.Exponent | ∀ {G : Type u} [inst : Group G] {n : ℤ}, ↑(Monoid.exponent G) ∣ n ↔ ∀ (g : G), g ^ n = 1 | true |
affineCombination_mem_affineSpan | Mathlib.LinearAlgebra.AffineSpace.Combination | ∀ {ι : Type u_1} {k : Type u_2} {V : Type u_3} {P : Type u_4} [inst : Ring k] [inst_1 : AddCommGroup V]
[inst_2 : Module k V] [inst_3 : AddTorsor V P] [Nontrivial k] {s : Finset ι} {w : ι → k},
∑ i ∈ s, w i = 1 → ∀ (p : ι → P), (Finset.affineCombination k s p) w ∈ affineSpan k (Set.range p) | true |
le_gauge_of_subset_closedBall | Mathlib.Analysis.Convex.Gauge | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {s : Set E} {r : ℝ} {x : E},
Absorbent ℝ s → 0 ≤ r → s ⊆ Metric.closedBall 0 r → ‖x‖ / r ≤ gauge s x | true |
CochainComplex.mappingCocone.liftCochain.congr_simp | Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} (φ : K ⟶ L) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ] {M : CochainComplex C ℤ}
{n m : ℤ} (α α_1 : CochainComplex.HomComplex.Cochain M K n),
α = α_1 →
∀ (β β_1 : CochainCom... | true |
MonoidAlgebra.comapDomainAddMonoidHom._proof_2 | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : Semiring R] (f : M → N) (hf : Function.Injective f),
MonoidAlgebra.comapDomain f hf 0 = 0 | false |
_private.Mathlib.Combinatorics.Enumerative.Partition.GenFun.0.Nat.Partition.aux_dvd_of_coeff_ne_zero | Mathlib.Combinatorics.Enumerative.Partition.GenFun | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : TopologicalSpace R] [T2Space R] {f : ℕ → ℕ → R} {d : ℕ}
{s : Finset ℕ},
0 ∉ s →
∀ {g : ℕ →₀ ℕ},
g ∈ s.finsuppAntidiag d →
(∀ i ∈ s, (PowerSeries.coeff (g i)) (1 + ∑' (j : ℕ), f i (j + 1) • PowerSeries.X ^ (i * (j + 1))) ≠ 0) →
∀ (x : ℕ),... | true |
FirstOrder.Field.FieldAxiom.mulAssoc | Mathlib.ModelTheory.Algebra.Field.Basic | FirstOrder.Field.FieldAxiom | true |
convexJoin_singleton_segment | Mathlib.Analysis.Convex.Join | ∀ {𝕜 : Type u_2} {E : Type u_3} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] (a b c : E),
convexJoin 𝕜 {a} (segment 𝕜 b c) = (convexHull 𝕜) {a, b, c} | true |
Int16.lt_of_lt_of_le | Init.Data.SInt.Lemmas | ∀ {a b c : Int16}, a < b → b ≤ c → a < c | true |
Vector.setIfInBounds_setIfInBounds | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n i : ℕ} (a : α) {b : α} {xs : Vector α n},
(xs.setIfInBounds i a).setIfInBounds i b = xs.setIfInBounds i b | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.oppositeLeftAction_actionRight_op | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_1) (D : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] (c : C) {d d' : D} (f : d ⟶ d'),
CategoryTheory.MonoidalCategory.MonoidalLeft... | true |
CategoryTheory.Functor.FullyFaithful.ofFullyFaithful | Mathlib.CategoryTheory.Functor.FullyFaithful | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(F : CategoryTheory.Functor C D) → [F.Full] → [F.Faithful] → F.FullyFaithful | true |
Int.Linear.eq_coeff | Init.Data.Int.Linear | ∀ (ctx : Int.Linear.Context) (p p' : Int.Linear.Poly) (k : ℤ),
Int.Linear.eq_coeff_cert p p' k = true → Int.Linear.Poly.denote' ctx p = 0 → Int.Linear.Poly.denote' ctx p' = 0 | true |
Prod.gameAdd_mk_iff | Mathlib.Order.GameAdd | ∀ {α : Type u_1} {β : Type u_2} {rα : α → α → Prop} {rβ : β → β → Prop} {a₁ a₂ : α} {b₁ b₂ : β},
Prod.GameAdd rα rβ (a₁, b₁) (a₂, b₂) ↔ rα a₁ a₂ ∧ b₁ = b₂ ∨ rβ b₁ b₂ ∧ a₁ = a₂ | true |
Fin.instCommRing._proof_11 | Mathlib.Data.ZMod.Defs | ∀ (n : ℕ) [inst : NeZero n] (n_1 : ℕ), ↑(n_1 + 1) = ↑n_1 + 1 | false |
_private.Mathlib.Topology.Order.LiminfLimsup.0.tendsto_iSup_of_tendsto_limsup._simp_1_2 | Mathlib.Topology.Order.LiminfLimsup | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] {p : α → Prop} [Nonempty α],
(∀ᶠ (x : α) in Filter.atTop, p x) = ∃ a, ∀ b ≥ a, p b | false |
CategoryTheory.Functor.LaxBraided.ofNatIso | Mathlib.CategoryTheory.Monoidal.Braided.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] →
{D : Type u₂} →
[inst_3 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_4 : CategoryTheory.MonoidalCategory D] →
... | true |
FormalMultilinearSeries.compContinuousLinearMap | Mathlib.Analysis.Calculus.FormalMultilinearSeries | {𝕜 : Type u} →
{E : Type v} →
{F : Type w} →
{G : Type x} →
[inst : Semiring 𝕜] →
[inst_1 : AddCommMonoid E] →
[inst_2 : Module 𝕜 E] →
[inst_3 : TopologicalSpace E] →
[inst_4 : ContinuousAdd E] →
[inst_5 : ContinuousConstSMul �... | true |
RingCat.instCreatesLimitSemiRingCatForget₂RingHomCarrierCarrier | Mathlib.Algebra.Category.Ring.Limits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
(F : CategoryTheory.Functor J RingCat) →
[Small.{u, max u v} ↑(F.comp (CategoryTheory.forget RingCat)).sections] →
CategoryTheory.CreatesLimit F (CategoryTheory.forget₂ RingCat SemiRingCat) | true |
_private.Mathlib.Analysis.SpecialFunctions.Gamma.Beta.0.Complex.betaIntegral_symm._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Gamma.Beta | ∀ {E : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : ℝ → E} {μ : MeasureTheory.Measure ℝ}
(a b : ℝ), -∫ (x : ℝ) in a..b, f x ∂μ = ∫ (x : ℝ) in b..a, f x ∂μ | false |
CStarAlgebra.mk | Mathlib.Analysis.CStarAlgebra.Classes | {A : Type u_1} →
[toNormedRing : NormedRing A] →
[toStarRing : StarRing A] →
[toCompleteSpace : CompleteSpace A] →
[toCStarRing : CStarRing A] →
[toNormedAlgebra : NormedAlgebra ℂ A] → [toStarModule : StarModule ℂ A] → CStarAlgebra A | true |
Nat.instConditionallyCompleteLinearOrderBot | Mathlib.Data.Nat.Lattice | ConditionallyCompleteLinearOrderBot ℕ | true |
Lean.TSyntax.instCoeNumLitPrec | Init.Meta.Defs | Coe Lean.NumLit Lean.Prec | true |
Pi.measurableMul | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {ι : Type u_5} {α : ι → Type u_6} [inst : (i : ι) → Mul (α i)] [inst_1 : (i : ι) → MeasurableSpace (α i)]
[∀ (i : ι), MeasurableMul (α i)], MeasurableMul ((i : ι) → α i) | true |
FP.Float.nan | Mathlib.Data.FP.Basic | [C : FP.FloatCfg] → FP.Float | true |
_private.Mathlib.Tactic.LinearCombination.0.Mathlib.Tactic.LinearCombination.elabLinearCombination.match_3 | Mathlib.Tactic.LinearCombination | (motive : Option Lean.Term → Sort u_1) →
(input : Option Lean.Term) → (Unit → motive none) → ((e : Lean.Term) → motive (some e)) → motive input | false |
Array.any_eq_true' | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {as : Array α}, as.any p = true ↔ ∃ x ∈ as, p x = true | true |
ContinuousLinearMap.isInvertible_comp_equiv._simp_1 | Mathlib.Topology.Algebra.Module.Equiv | ∀ {R : Type u_1} {M : Type u_2} {M₂ : Type u_3} {M₃ : Type u_4} [inst : TopologicalSpace M]
[inst_1 : TopologicalSpace M₂] [inst_2 : TopologicalSpace M₃] [inst_3 : Semiring R] [inst_4 : AddCommMonoid M]
[inst_5 : Module R M] [inst_6 : AddCommMonoid M₂] [inst_7 : Module R M₂] [inst_8 : AddCommMonoid M₃]
[inst_9 : ... | false |
Aesop.Frontend.Feature.ctorElim | Aesop.Frontend.RuleExpr | {motive : Aesop.Frontend.Feature → Sort u} →
(ctorIdx : ℕ) →
(t : Aesop.Frontend.Feature) → ctorIdx = t.ctorIdx → Aesop.Frontend.Feature.ctorElimType ctorIdx → motive t | false |
UInt32.reduceAdd._regBuiltin.UInt32.reduceAdd.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.2998934274._hygCtx._hyg.35 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | false |
Set.prod_pow | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Monoid α] [inst_1 : Monoid β] (s : Set α) (t : Set β) (n : ℕ),
s ×ˢ t ^ n = (s ^ n) ×ˢ (t ^ n) | true |
_private.Mathlib.Data.ENNReal.Real.0.Mathlib.Meta.Positivity.evalENNRealOfReal.match_1 | Mathlib.Data.ENNReal.Real | (motive :
(u : Lean.Level) →
{α : Q(Type u)} →
(_zα : Q(Zero «$α»)) →
(_pα : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness _zα _pα e) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness _zα _pα e) → Sort u_1) →
... | false |
CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse_obj_mon_mul_app | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.MonoidalCategory D] [inst_3 : CategoryTheory.BraidedCategory D]
(F : CategoryTheory.Functor C (CategoryTheory.CommMon D)) (X : C),
CategoryTheory.MonObj.mul.app X = Cate... | true |
AddSubmonoid.fromLeftNeg_leftNegEquiv_symm | Mathlib.GroupTheory.Submonoid.Inverses | ∀ {M : Type u_1} [inst : AddCommMonoid M] (S : AddSubmonoid M) (hS : S ≤ IsAddUnit.addSubmonoid M) (x : ↥S),
S.fromLeftNeg ((S.leftNegEquiv hS).symm x) = x | true |
AlgebraicGeometry.Scheme.instHasPullbacksPrecoverageOfHasPullbacks | Mathlib.AlgebraicGeometry.Sites.MorphismProperty | ∀ (P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme) [P.HasPullbacks],
(AlgebraicGeometry.Scheme.precoverage P).HasPullbacks | true |
Lean.Elab.Tactic.MkSimpContextResult.rec | Lean.Elab.Tactic.Simp | {motive : Lean.Elab.Tactic.MkSimpContextResult → Sort u} →
((ctx : Lean.Meta.Simp.Context) →
(simprocs : Lean.Meta.Simp.SimprocsArray) →
(dischargeWrapper : Lean.Elab.Tactic.Simp.DischargeWrapper) →
(simpArgs : Array (Lean.Syntax × Lean.Elab.Tactic.ElabSimpArgResult)) →
motive { ct... | false |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxsOf_lt._proof_1_8 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {x : α} [inst : BEq α] (h : 1 ≤ (List.filter (fun x_1 => x_1 == x) xs).length),
(List.findIdxs (fun x_1 => x_1 == x) xs)[0] < xs.length | false |
_private.Mathlib.Algebra.GroupWithZero.Action.Pointwise.Finset.0.Finset.inv_op_smul_finset_distrib₀._simp_1_3 | Mathlib.Algebra.GroupWithZero.Action.Pointwise.Finset | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] [inst_1 : GroupWithZero α] [inst_2 : MulAction α β]
{s : Finset β} {a : α} {b : β}, a ≠ 0 → (b ∈ a • s) = (a⁻¹ • b ∈ s) | false |
CategoryTheory.Limits.Sigma.whiskerEquiv_hom | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u_1} {K : Type u_2} {f : J → C} {g : K → C}
(e : J ≃ K) (w : (j : J) → g (e j) ≅ f j) [inst_1 : CategoryTheory.Limits.HasCoproduct f]
[inst_2 : CategoryTheory.Limits.HasCoproduct g],
(CategoryTheory.Limits.Sigma.whiskerEquiv e w).hom = CategoryThe... | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstr._sizeOf_15 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → ℕ | false |
LinearMap.mulLeft._proof_2 | Mathlib.Algebra.Module.LinearMap.Defs | ∀ (R : Type u_2) {A : Type u_1} [inst : Semiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[SMulCommClass R A A] (a : A) (x : R) (y : A), a * x • y = x • (a * y) | false |
Std.Iter.toList_zip_of_finite_left | Std.Data.Iterators.Lemmas.Combinators.Zip | ∀ {α₁ α₂ β₁ β₂ : Type u_1} [inst : Std.Iterator α₁ Id β₁] [inst_1 : Std.Iterator α₂ Id β₂] {it₁ : Std.Iter β₁}
{it₂ : Std.Iter β₂} [Std.Iterators.Finite α₁ Id] [Std.Iterators.Productive α₂ Id],
(it₁.zip it₂).toList = it₁.toList.zip (Std.Iter.take it₁.toList.length it₂).toList | true |
IsTopologicalGroup.mulInvClosureNhd.casesOn | Mathlib.Topology.Algebra.OpenSubgroup | {G : Type u_1} →
[inst : TopologicalSpace G] →
{T W : Set G} →
[inst_1 : Group G] →
{motive : IsTopologicalGroup.mulInvClosureNhd T W → Sort u} →
(t : IsTopologicalGroup.mulInvClosureNhd T W) →
((nhds : T ∈ nhds 1) → (inv : T⁻¹ = T) → (isOpen : IsOpen T) → (mul : W * T ⊆ W) → m... | false |
SSet.Truncated.instMonoidalTruncation._aux_3 | Mathlib.AlgebraicTopology.SimplicialSet.Monoidal | (n : ℕ) →
(X Y : SSet) →
CategoryTheory.MonoidalCategoryStruct.tensorObj ((SSet.truncation n).obj X) ((SSet.truncation n).obj Y) ⟶
(SSet.truncation n).obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) | false |
Ordnode.insert'._unsafe_rec | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → [inst : LE α] → [DecidableLE α] → α → Ordnode α → Ordnode α | false |
CategoryTheory.Adjunction.right_triangle_components_assoc | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {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} (self : F ⊣ G) (Y : D) {Z : C} (h : G.obj Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.unit.app (G.obj Y))
(CategoryTheo... | true |
RingHom.FiniteType.of_surjective | Mathlib.RingTheory.FiniteType | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] (f : A →+* B),
Function.Surjective ⇑f → f.FiniteType | true |
_private.Lean.Meta.MkIffOfInductiveProp.0.Lean.Meta.Shape.casesOn | Lean.Meta.MkIffOfInductiveProp | {motive : Lean.Meta.Shape✝ → Sort u} →
(t : Lean.Meta.Shape✝¹) →
((variablesKept : List Bool) → (neqs : Option ℕ) → motive { variablesKept := variablesKept, neqs := neqs }) →
motive t | false |
Ring.DirectLimit.congr._proof_6 | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} [inst_1 : (i : ι) → CommRing (G i)]
{f : (i j : ι) → i ≤ j → G i →+* G j} {G' : ι → Type u_3} [inst_2 : (i : ι) → CommRing (G' i)]
{f' : (i j : ι) → i ≤ j → G' i →+* G' j} (e : (i : ι) → G i ≃+* G' i),
(∀ (i j : ι) (h : i ≤ j), (e j).toRingHom.comp (f i j h)... | false |
RingQuot.ringQuotToIdealQuotient | Mathlib.Algebra.RingQuot | {B : Type uR} → [inst : CommRing B] → (r : B → B → Prop) → RingQuot r →+* B ⧸ Ideal.ofRel r | true |
Std.Format.noConfusion | Init.Data.Format.Basic | {P : Sort u} → {t t' : Std.Format} → t = t' → Std.Format.noConfusionType P t t' | false |
Rat.cast_lt_natCast._simp_1 | Mathlib.Data.Rat.Cast.Order | ∀ {K : Type u_5} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] {m : ℚ} {n : ℕ}, (↑m < ↑n) = (m < ↑n) | false |
List.maximum_of_length_pos_mem | Mathlib.Data.List.MinMax | ∀ {α : Type u_1} [inst : LinearOrder α] {l : List α} (h : 0 < l.length), List.maximum_of_length_pos h ∈ l | true |
Lean.Json.below | Lean.Data.Json.Basic | {motive_1 : Lean.Json → Sort u} →
{motive_2 : Array Lean.Json → Sort u} →
{motive_3 : Std.TreeMap.Raw String Lean.Json compare → Sort u} →
{motive_4 : List Lean.Json → Sort u} →
{motive_5 : Std.DTreeMap.Raw String (fun x => Lean.Json) compare → Sort u} →
{motive_6 : (Std.DTreeMap.Internal.... | false |
Num.commSemiring._proof_5 | Mathlib.Data.Num.Lemmas | ∀ (x : Num), 0 * x = 0 | false |
CategoryTheory.AddMon.uniqueHomToTrivial | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon_ | {D : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} D] →
[inst_1 : CategoryTheory.SemiCartesianMonoidalCategory D] →
(A : CategoryTheory.AddMon D) → Unique (A ⟶ CategoryTheory.AddMon.trivial D) | true |
_private.Mathlib.NumberTheory.Padics.PadicNumbers.0.PadicSeq.norm_eq_of_equiv | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {f g : PadicSeq p} (hf : ¬f ≈ 0) (hg : ¬g ≈ 0),
f ≈ g → padicNorm p (↑f (PadicSeq.stationaryPoint hf)) = padicNorm p (↑g (PadicSeq.stationaryPoint hg)) | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transform_map_whiskerRight | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {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} {A₁ : Type u₄} {B₁ : Type u₅} {C₁ : Type u₆}
[inst_3 : CategoryTheor... | true |
Mathlib.Tactic.BicategoryLike.NormalExpr.brecOn.eq | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | ∀ {motive : Mathlib.Tactic.BicategoryLike.NormalExpr → Sort u} (t : Mathlib.Tactic.BicategoryLike.NormalExpr)
(F_1 : (t : Mathlib.Tactic.BicategoryLike.NormalExpr) → Mathlib.Tactic.BicategoryLike.NormalExpr.below t → motive t),
Mathlib.Tactic.BicategoryLike.NormalExpr.brecOn t F_1 =
F_1 t (Mathlib.Tactic.Bicate... | true |
Function.locallyFinsuppWithin.closedSupport | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [T1Space X] [inst_2 : Zero Y]
(D : Function.locallyFinsuppWithin U Y), IsClosed U → IsClosed D.support | true |
Lean.StructureResolutionState.ctorIdx | Lean.Structure | Lean.StructureResolutionState → ℕ | false |
CategoryTheory.CostructuredArrow.mk_hom_eq_self | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{T : D} {Y : C} {S : CategoryTheory.Functor C D} (f : S.obj Y ⟶ T), (CategoryTheory.CostructuredArrow.mk f).hom = f | true |
SubNegMonoid.sub._default | Mathlib.Algebra.Group.Defs | {G : Type u} →
(add : G → G → G) →
(∀ (a b c : G), a + b + c = a + (b + c)) →
(zero : G) →
(∀ (a : G), 0 + a = a) →
(∀ (a : G), a + 0 = a) →
(nsmul : ℕ → G → G) →
(∀ (x : G), nsmul 0 x = 0) → (∀ (n : ℕ) (x : G), nsmul (n + 1) x = nsmul n x + x) → (G → G) → G → G →... | false |
sub_eq_add_zero_sub | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : SubNegMonoid G] (a b : G), a - b = a + (0 - b) | true |
DiffeologicalSpace.mkOfClosure._proof_1 | Mathlib.Geometry.Diffeology.Basic | ∀ {X : Type u_1} (g : Set ((n : ℕ) × (EuclideanSpace ℝ (Fin n) → X))) {u : Set X},
TopologicalSpace.IsOpen u ↔ ∀ {n : ℕ}, ∀ p ∈ {p | ⟨n, p⟩ ∈ g}, IsOpen (p ⁻¹' u) | false |
DiscreteQuotient.comp_finsetClopens.match_1 | Mathlib.Topology.DiscreteQuotient | (X : Type u_1) →
[inst : TopologicalSpace X] →
(motive : DiscreteQuotient X → Sort u_2) →
(x : DiscreteQuotient X) →
((f : Setoid X) →
(isOpen_setOf_rel : ∀ (x : X), IsOpen (setOf (f x))) →
motive { toSetoid := f, isOpen_setOf_rel := isOpen_setOf_rel }) →
motive x | false |
iSupIndep.comp' | Mathlib.Order.SupIndep | ∀ {α : Type u_1} [inst : CompleteLattice α] {ι : Sort u_5} {ι' : Sort u_6} {t : ι → α} {f : ι' → ι},
iSupIndep (t ∘ f) → Function.Surjective f → iSupIndep t | true |
PrimeSpectrum.isIrreducible_iff_vanishingIdeal_isPrime | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u} [inst : CommSemiring R] {s : Set (PrimeSpectrum R)},
IsIrreducible s ↔ (PrimeSpectrum.vanishingIdeal s).IsPrime | true |
bddAbove_preimage_toDual | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {s : Set αᵒᵈ}, BddAbove (⇑OrderDual.toDual ⁻¹' s) ↔ BddBelow s | true |
ENNReal.le_of_forall_nnreal_lt | Mathlib.Data.ENNReal.Inv | ∀ {x y : ENNReal}, (∀ (r : NNReal), ↑r < x → ↑r ≤ y) → x ≤ y | true |
CategoryTheory.FreeBicategory.Hom.ctorElimType | Mathlib.CategoryTheory.Bicategory.Free | {B : Type u} →
[inst : Quiver B] →
{motive : (a a_1 : B) → CategoryTheory.FreeBicategory.Hom a a_1 → Sort u_1} →
ℕ →
Sort
(max 1 (imax (u + 1) u_1) (imax (u + 1) (u + 1) (u + 1) (max (u + 1) (v + 1)) (max (u + 1) (v + 1)) u_1)
(imax (u + 1) (u + 1) (v + 1) u_1)) | false |
LieIdeal.coe_toLieSubalgebra | Mathlib.Algebra.Lie.Ideal | ∀ (R : Type u) (L : Type v) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (I : LieIdeal R L),
↑(LieIdeal.toLieSubalgebra R L I) = ↑I | true |
instAssociativeUInt64HXor | Init.Data.UInt.Bitwise | Std.Associative fun x1 x2 => x1 ^^^ x2 | true |
TopCat.instNegHomObjTopCommRingCatForget₂SubtypeRingHomαContinuousCoeContinuousMapCarrier | Mathlib.Topology.Sheaves.CommRingCat | (X : TopCat) → (R : TopCommRingCat) → Neg (X ⟶ (CategoryTheory.forget₂ TopCommRingCat TopCat).obj R) | true |
_private.Mathlib.Combinatorics.Extremal.RuzsaSzemeredi.0.mem_triangleIndices._simp_1 | Mathlib.Combinatorics.Extremal.RuzsaSzemeredi | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : CommRing α] {s : Finset α} {x : α × α × α},
(x ∈ triangleIndices✝ s) = ∃ y, ∃ a ∈ s, (y, y + a, y + 2 * a) = x | false |
Lean.Meta.Grind.Context | Lean.Meta.Tactic.Grind.Types | Type | true |
Std.DHashMap.Internal.Raw.getKey?_eq | Std.Data.DHashMap.Internal.Raw | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} (h : m.WF) {a : α},
m.getKey? a = Std.DHashMap.Internal.Raw₀.getKey? ⟨m, ⋯⟩ a | true |
_private.Mathlib.Algebra.Module.LocalizedModule.Submodule.0.IsLocalizedModule.toLocalizedQuotient'._simp_1 | Mathlib.Algebra.Module.LocalizedModule.Submodule | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Submodule R M)
{S : Type u_3} [inst_3 : SMul S R] [inst_4 : SMul S M] [inst_5 : IsScalarTower S R M] (r : S) (x : M),
r • Submodule.Quotient.mk x = Submodule.Quotient.mk (r • x) | false |
_private.Init.Data.String.Basic.0.String.Pos.Raw.utf8GetAux.match_1.splitter | Init.Data.String.Basic | (motive : List Char → String.Pos.Raw → String.Pos.Raw → Sort u_1) →
(x : List Char) →
(x_1 x_2 : String.Pos.Raw) →
((x x_3 : String.Pos.Raw) → motive [] x x_3) →
((c : Char) → (cs : List Char) → (i p : String.Pos.Raw) → motive (c :: cs) i p) → motive x x_1 x_2 | true |
_private.Mathlib.MeasureTheory.Measure.AEDisjoint.0.MeasureTheory.exists_null_pairwise_disjoint_diff._simp_1_8 | Mathlib.MeasureTheory.Measure.AEDisjoint | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | false |
gcdMonoidOfGCD._proof_1 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : DecidableEq α] (gcd : α → α → α)
(gcd_dvd_left : ∀ (a b : α), gcd a b ∣ a) (a b : α),
Associated (gcd a b * if a = 0 then 0 else Classical.choose ⋯) (a * b) | false |
Lean.Widget.RpcEncodablePacket.«_@».Lean.Server.FileWorker.WidgetRequests.2734021171._hygCtx._hyg.1.noConfusion | Lean.Server.FileWorker.WidgetRequests | {P : Sort u} →
{t t' : Lean.Widget.RpcEncodablePacket✝} →
t = t' →
Lean.Widget.RpcEncodablePacket.«_@».Lean.Server.FileWorker.WidgetRequests.2734021171._hygCtx._hyg.1.noConfusionType
P t t' | false |
ConvexCone.pointed_positive | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid M]
[inst_3 : PartialOrder M] [inst_4 : IsOrderedAddMonoid M] [inst_5 : Module R M] [inst_6 : PosSMulMono R M],
(ConvexCone.positive R M).Pointed | true |
_private.Lean.Meta.Tactic.Simp.Simproc.0.Lean.Meta.Simp.getSimprocFromDeclImpl.match_6 | Lean.Meta.Tactic.Simp.Simproc | (motive : Option Lean.ConstantInfo → Sort u_1) →
(x : Option Lean.ConstantInfo) → (Unit → motive none) → ((info : Lean.ConstantInfo) → motive (some info)) → motive x | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.le_min_iff._simp_1_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.OrientedCmp cmp] {a b : α},
(cmp a b = Ordering.gt) = (cmp b a = Ordering.lt) | false |
ModuleCat.biprodIsoProd_inv_comp_snd_apply | Mathlib.Algebra.Category.ModuleCat.Biproducts | ∀ {R : Type u} [inst : Ring R] (M N : ModuleCat R) (x : ↑M × ↑N),
(CategoryTheory.ConcreteCategory.hom CategoryTheory.Limits.biprod.snd)
((CategoryTheory.ConcreteCategory.hom (M.biprodIsoProd N).inv) x) =
x.2 | true |
BitVec.reduceHShiftLeft | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | Lean.Meta.Simp.DSimproc | true |
LocallyLipschitz.const_min | Mathlib.Topology.MetricSpace.Lipschitz | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {f : α → ℝ},
LocallyLipschitz f → ∀ (a : ℝ), LocallyLipschitz fun x => min a (f x) | true |
Int.Linear.Poly | Init.Data.Int.Linear | Type | true |
Lean.Elab.liftMacroM | Lean.Elab.Util | {m : Type → Type} →
{α : Type} →
[Monad m] →
[Lean.Elab.MonadMacroAdapter m] →
[Lean.MonadEnv m] →
[Lean.MonadRecDepth m] →
[Lean.MonadError m] →
[Lean.MonadResolveName m] →
[Lean.MonadTrace m] →
[Lean.MonadOptions m] → [Lean.AddM... | true |
CategoryTheory.Pseudofunctor.hasCoeToLax | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] → Coe (CategoryTheory.Pseudofunctor B C) (CategoryTheory.LaxFunctor B C) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.