name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Finset.prod_Ioc_succ_top | Mathlib.Algebra.BigOperators.Intervals | ∀ {M : Type u_3} [inst : CommMonoid M] {a b : ℕ},
a ≤ b → ∀ (f : ℕ → M), ∏ k ∈ Finset.Ioc a (b + 1), f k = (∏ k ∈ Finset.Ioc a b, f k) * f (b + 1) | true |
Finset.biUnion_image_sup_left | Mathlib.Data.Finset.Sups | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : SemilatticeSup α] (s t : Finset α),
(s.biUnion fun a => Finset.image (fun x => a ⊔ x) t) = s ⊻ t | true |
_private.Lean.Elab.DeclNameGen.0.PSum.casesOn._arg_pusher | Lean.Elab.DeclNameGen | ∀ {α : Sort u} {β : Sort v} {motive : α ⊕' β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝) (f : (x : α_1) → β_1 x)
(rel : α ⊕' β → α_1 → Prop) (t : α ⊕' β)
(inl : (val : α) → ((y : α_1) → rel (PSum.inl val) y → β_1 y) → motive (PSum.inl val))
(inr : (val : β) → ((y : α_1) → rel (PSum.inr val) y → β_1 y) → mot... | false |
Real.tendsto_logb_atTop_of_base_lt_one | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {b : ℝ}, 0 < b → b < 1 → Filter.Tendsto (Real.logb b) Filter.atTop Filter.atBot | true |
tensorKaehlerQuotKerSqEquiv._proof_3 | Mathlib.RingTheory.Smooth.Kaehler | ∀ (R : Type u_1) (P : Type u_2) (S : Type u_3) [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : CommRing S]
[inst_3 : Algebra R P] [inst_4 : Algebra P S],
SMulCommClass R (P ⧸ RingHom.ker (algebraMap P S) ^ 2) (P ⧸ RingHom.ker (algebraMap P S) ^ 2) | false |
Lean.Compiler.LCNF.JoinPointFinder.find | Lean.Compiler.LCNF.JoinPoints | Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure →
Lean.Compiler.LCNF.CompilerM Lean.Compiler.LCNF.JoinPointFinder.FindState | true |
Asymptotics.IsEquivalent | Mathlib.Analysis.Asymptotics.Defs | {α : Type u_1} → {E' : Type u_6} → [SeminormedAddCommGroup E'] → Filter α → (α → E') → (α → E') → Prop | true |
AffineSubspace.subtype_linear | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] (s : AffineSubspace k P) [inst_4 : Nonempty ↥s], s.subtype.linear = s.direction.subtype | true |
_private.Batteries.Data.List.Basic.0.List.next?.match_1.eq_2 | Batteries.Data.List.Basic | ∀ {α : Type u_1} (motive : List α → Sort u_2) (a : α) (l : List α) (h_1 : Unit → motive [])
(h_2 : (a : α) → (l : List α) → motive (a :: l)),
(match a :: l with
| [] => h_1 ()
| a :: l => h_2 a l) =
h_2 a l | true |
Set.mulIndicator_eq_one_or_self | Mathlib.Algebra.Notation.Indicator | ∀ {α : Type u_1} {M : Type u_3} [inst : One M] (s : Set α) (f : α → M) (a : α),
s.mulIndicator f a = 1 ∨ s.mulIndicator f a = f a | true |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.ErrorContext.recOn | Mathlib.Tactic.Linter.TextBased | {motive : Mathlib.Linter.TextBased.ErrorContext✝ → Sort u} →
(t : Mathlib.Linter.TextBased.ErrorContext✝¹) →
((error : Mathlib.Linter.TextBased.StyleError✝) →
(lineNumber : ℕ) →
(path : System.FilePath) → motive { error := error, lineNumber := lineNumber, path := path }) →
motive t | false |
_private.Init.Data.Nat.ToString.0.Nat.length_toDigits_le_iff._simp_1_4 | Init.Data.Nat.ToString | ∀ {n : ℕ}, (n ≠ 0) = (0 < n) | false |
Lean.Elab.Tactic.RCases.instCoeIdentTSyntaxConsSyntaxNodeKindMkStr1Nil_lean | Lean.Elab.Tactic.RCases | Coe Lean.Ident (Lean.TSyntax `rcasesPat) | true |
ContinuousMultilinearMap.norm_mkPiAlgebraFin_zero | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {A : Type u_1} [inst_1 : SeminormedRing A]
[inst_2 : NormedAlgebra 𝕜 A], ‖ContinuousMultilinearMap.mkPiAlgebraFin 𝕜 0 A‖ = ‖1‖ | true |
FirstOrder.Ring.genericPolyMap.eq_1 | Mathlib.RingTheory.MvPolynomial.FreeCommRing | ∀ {ι : Type u_1} {κ : Type u_2} (monoms : ι → Finset (κ →₀ ℕ)) (i : ι),
FirstOrder.Ring.genericPolyMap monoms i =
∑ m ∈ (monoms i).attach, FreeCommRing.of (Sum.inl ⟨i, m⟩) * (↑m).prod fun j n => FreeCommRing.of (Sum.inr j) ^ n | true |
_private.Mathlib.Algebra.Order.Ring.WithTop.0.WithTop.pow_right_strictMono.match_1_1 | Mathlib.Algebra.Order.Ring.WithTop | ∀ (motive : (x : ℕ) → x ≠ 0 → Prop) (x : ℕ) (x_1 : x ≠ 0),
(∀ (h : 0 ≠ 0), motive 0 h) →
(∀ (x : 1 ≠ 0), motive 1 x) → (∀ (n : ℕ) (x : n + 2 ≠ 0), motive n.succ.succ x) → motive x x_1 | false |
Sylow.normal_of_normalizerCondition | Mathlib.GroupTheory.Sylow | ∀ {G : Type u} [inst : Group G],
NormalizerCondition G → ∀ {p : ℕ} [Fact (Nat.Prime p)] [Finite (Sylow p G)] (P : Sylow p G), (↑P).Normal | true |
NNReal.instOrderBot._proof_3 | Mathlib.Data.NNReal.Defs | ∀ (a : NNReal), ⊥ ≤ a | false |
ContinuousAddMonoidHom.instAddCommMonoid._proof_1 | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {A : Type u_1} {E : Type u_2} [inst : AddMonoid A] [inst_1 : TopologicalSpace A] [inst_2 : AddCommMonoid E]
[inst_3 : TopologicalSpace E] [inst_4 : ContinuousAdd E] (x : A →ₜ+ E), nsmulRecAuto 0 x = 0 | false |
NNReal.coe_real_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ↑NNReal.pi = Real.pi | true |
FiniteDimensional.RCLike.properSpace_submodule | Mathlib.Analysis.RCLike.Lemmas | ∀ (K : Type u_1) {E : Type u_2} [inst : RCLike K] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace K E]
(S : Submodule K E) [FiniteDimensional K ↥S], ProperSpace ↥S | true |
IsPrimitiveRoot.neZero' | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {R : Type u_4} {ζ : R} [inst : CommRing R] [IsDomain R] {n : ℕ} [NeZero n], IsPrimitiveRoot ζ n → NeZero ↑n | true |
MeasureTheory.setIntegral_indicatorConstLp | Mathlib.MeasureTheory.Integral.Bochner.Set | ∀ {X : Type u_1} {E : Type u_3} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
{s t : Set X} {μ : MeasureTheory.Measure X} [CompleteSpace E] {p : ENNReal},
MeasurableSet s →
∀ (ht : MeasurableSet t) (hμt : μ t ≠ ⊤) (e : E),
∫ (x : X) in s, ↑↑(MeasureTheory.indicatorConst... | true |
Polynomial.degree_map_le | Mathlib.Algebra.Polynomial.Eval.Degree | ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] {f : R →+* S} {p : Polynomial R},
(Polynomial.map f p).degree ≤ p.degree | true |
LinearMap.flip._proof_5 | Mathlib.LinearAlgebra.BilinearMap | ∀ {R : Type u_6} [inst : Semiring R] {S : Type u_3} [inst_1 : Semiring S] {R₂ : Type u_7} [inst_2 : Semiring R₂]
{S₂ : Type u_4} [inst_3 : Semiring S₂] {M : Type u_5} {N : Type u_2} {P : Type u_1} [inst_4 : AddCommMonoid M]
[inst_5 : AddCommMonoid N] [inst_6 : AddCommMonoid P] [inst_7 : Module R M] [inst_8 : Module... | false |
AddSemiconjBy.map._simp_1 | Mathlib.Algebra.Group.Commute.Hom | ∀ {F : Type u_1} {M : Type u_2} {N : Type u_3} [inst : Add M] [inst_1 : Add N] {a x y : M} [inst_2 : FunLike F M N]
[AddHomClass F M N], AddSemiconjBy a x y → ∀ (f : F), AddSemiconjBy (f a) (f x) (f y) = True | false |
_private.Mathlib.Data.List.Cycle.0.List.prev_eq_getElem?_idxOf_pred_of_ne_head._proof_1_14 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {a : α} (x y : α) (tail : List α), a ∈ x :: y :: tail → x :: y :: tail ≠ [] | false |
_private.Lean.Meta.Tactic.Replace.0.Lean.MVarId.withReverted.match_1 | Lean.Meta.Tactic.Replace | (motive : Option Lean.FVarId → Sort u_1) →
(x? : Option Lean.FVarId) → ((x : Lean.FVarId) → motive (some x)) → ((x : Option Lean.FVarId) → motive x) → motive x? | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.toList_eq._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 |
Order.IsPredLimit.ne_top | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a : α} [inst : Preorder α] [inst_1 : OrderTop α], Order.IsPredLimit a → a ≠ ⊤ | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.size_left_le_size_union._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion.0.aux_IsBigO_mul | Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion | ∀ (k l : ℕ) (p : ℝ) {f : ℕ → ℂ},
(f =O[Filter.atTop] fun n => ↑n ^ l) →
(fun n => f n * (2 * ↑Real.pi * Complex.I * ↑n / ↑p) ^ k) =O[Filter.atTop] fun n => ↑(n ^ (l + k)) | true |
ProbabilityTheory.Kernel.compProd_prodMkLeft_eq_comp | Mathlib.Probability.Kernel.Composition.KernelLemmas | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} {mX : MeasurableSpace X} {mY : MeasurableSpace Y}
{mZ : MeasurableSpace Z} (κ : ProbabilityTheory.Kernel X Y) [ProbabilityTheory.IsSFiniteKernel κ]
(η : ProbabilityTheory.Kernel Y Z) [ProbabilityTheory.IsSFiniteKernel η],
κ.compProd (ProbabilityTheory.Kernel.prodMkLe... | true |
_private.Mathlib.MeasureTheory.Measure.Lebesgue.Basic.0.nullMeasurableSet_region_between_co._simp_1_2 | Mathlib.MeasureTheory.Measure.Lebesgue.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | false |
MonadSatisfying.instStateRefT'._proof_2 | Batteries.Classes.SatisfiesM | ∀ {m : Type → Type} {ω σ : Type} [inst : Monad m] [LawfulMonad m], LawfulFunctor (StateRefT' ω σ m) | false |
BEq.rfl | Init.Core | ∀ {α : Type u_1} [inst : BEq α] [ReflBEq α] {a : α}, (a == a) = true | true |
IsLUB | Mathlib.Order.Bounds.Defs | {α : Type u_1} → [LE α] → Set α → α → Prop | true |
_private.Lean.Meta.CongrTheorems.0.Lean.Meta.mkCongrSimpCore?.mkProof.go._unsafe_rec | Lean.Meta.CongrTheorems | Array Lean.Meta.CongrArgKind → ℕ → Lean.Expr → Lean.MetaM Lean.Expr | false |
Multiset.instDistribLattice | Mathlib.Data.Multiset.UnionInter | {α : Type u_1} → [DecidableEq α] → DistribLattice (Multiset α) | true |
_private.Mathlib.RingTheory.AdjoinRoot.0.AdjoinRoot.map._simp_1 | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u} {S : Type v} {T : Type w} [inst : Semiring R] {p : Polynomial R} [inst_1 : Semiring S] (f : R →+* S)
[inst_2 : Semiring T] (g : S →+* T) (x : T),
Polynomial.eval₂ (g.comp f) x p = Polynomial.eval₂ g x (Polynomial.map f p) | false |
ENat.smul_sSup | Mathlib.Data.ENat.Lattice | ∀ {R : Type u_4} [inst : SMul R ℕ∞] [IsScalarTower R ℕ∞ ℕ∞] (s : Set ℕ∞) (c : R), c • sSup s = ⨆ a ∈ s, c • a | true |
Preorder.piCongrLeft_comp_restrictLe | Mathlib.Order.Restriction | ∀ {α : Type u_1} [inst : Preorder α] {π : α → Type u_2} [inst_1 : LocallyFiniteOrderBot α] {a : α},
⇑(Equiv.piCongrLeft (fun i => π ↑i) (Equiv.IicFinsetSet a).symm) ∘ Preorder.restrictLe a = Preorder.frestrictLe a | true |
Part.get_eq_get_of_eq | Mathlib.Data.Part | ∀ {α : Type u_1} (a : Part α) (ha : a.Dom) {b : Part α} (h : a = b), a.get ha = b.get ⋯ | true |
_private.Lean.Elab.Import.0.Lean.Elab.printImports.match_1 | Lean.Elab.Import | (motive : Array Lean.Import × Lean.Position × Lean.MessageLog → Sort u_1) →
(__discr : Array Lean.Import × Lean.Position × Lean.MessageLog) →
((deps : Array Lean.Import) → (fst : Lean.Position) → (snd : Lean.MessageLog) → motive (deps, fst, snd)) →
motive __discr | false |
CategoryTheory.Arrow.leftFunc_obj | Mathlib.CategoryTheory.Comma.Arrow | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(X : CategoryTheory.Comma (CategoryTheory.Functor.id C) (CategoryTheory.Functor.id C)),
CategoryTheory.Arrow.leftFunc.obj X = X.left | true |
Filter.Realizer.ofEquiv_F | Mathlib.Data.Analysis.Filter | ∀ {α : Type u_1} {τ : Type u_4} {f : Filter α} (F : f.Realizer) (E : F.σ ≃ τ) (s : τ),
(F.ofEquiv E).F.f s = F.F.f (E.symm s) | true |
CategoryTheory.GrothendieckTopology.PreservesSheafification.transport | Mathlib.CategoryTheory.Sites.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] (K : CategoryTheory.GrothendieckTopology D)
(G : CategoryTheory.Functor D C) {A : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} A] (B : Type u₄)
... | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone.0.CochainComplex.mappingCocone.δ_descCochain._proof_1_7 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} (φ : K ⟶ L) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ] {M : CochainComplex C ℤ}
{m : ℤ} (α : CochainComplex.HomComplex.Cochain K M m) (p q : ℤ) (β : CochainComplex.HomComplex.Coc... | false |
CategoryTheory.RanIsSheafOfIsCocontinuous.liftAux._proof_1 | Mathlib.CategoryTheory.Sites.CoverLifting | ∀ {C : Type u_1} {D : Type u_4} [inst : CategoryTheory.Category.{u_2, u_1} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {G : CategoryTheory.Functor C D}
{J : CategoryTheory.GrothendieckTopology C} {K : CategoryTheory.GrothendieckTopology D} [G.IsCocontinuous J K] {X : D}
{S : K.Cover X} {Y : C} (f : G.obj Y... | false |
IntermediateField.lift_relrank_comap_comap_eq_lift_relrank_of_surjective | Mathlib.FieldTheory.Relrank | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {L : Type w} [inst_3 : Field L]
[inst_4 : Algebra F L] (A B : IntermediateField F E) (f : L →ₐ[F] E),
Function.Surjective ⇑f →
Cardinal.lift.{v, w} ((IntermediateField.comap f A).relrank (IntermediateField.comap f B)) =
... | true |
_private.Mathlib.Data.Set.Image.0.Set.imageFactorization_surjective.match_1_1 | Mathlib.Data.Set.Image | ∀ {α : Type u_2} {β : Type u_1} {f : α → β} {s : Set α} (motive : ↑(f '' s) → Prop) (x : ↑(f '' s)),
(∀ (a : α) (ha : a ∈ s), motive ⟨f a, ⋯⟩) → motive x | false |
iSup_inf_eq | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} {ι : Sort w} [inst : Order.Frame α] (f : ι → α) (a : α), (⨆ i, f i) ⊓ a = ⨆ i, f i ⊓ a | true |
Lean.Parser.Term.throwNamedErrorMacro | Lean.Parser.Term | Lean.Parser.Parser | true |
QuaternionAlgebra.coe_natCast | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} {c₁ c₂ c₃ : R} [inst : AddCommGroupWithOne R] (n : ℕ), ↑↑n = ↑n | true |
CategoryTheory.IndParallelPairPresentation.parallelPairIsoParallelPairCompYoneda._proof_4 | Mathlib.CategoryTheory.Limits.Indization.ParallelPair | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {A B : CategoryTheory.Functor Cᵒᵖ (Type u_1)}
{f g : A ⟶ B} (P : CategoryTheory.IndParallelPairPresentation f g),
CategoryTheory.Limits.HasColimit
(((CategoryTheory.Functor.whiskeringRight P.I C (CategoryTheory.Functor Cᵒᵖ (Type u_1))).obj
... | false |
Std.Sat.AIG.RefVec.MapTarget.recOn | Std.Sat.AIG.RefVecOperator.Map | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{len : ℕ} →
{motive : Std.Sat.AIG.RefVec.MapTarget aig len → Sort u} →
(t : Std.Sat.AIG.RefVec.MapTarget aig len) →
((vec : aig.RefVec len) →
(func : (aig : Std... | false |
Std.DTreeMap.Internal.Impl.getKeyD_union!_of_contains_eq_false_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
m₁.WF →
m₂.WF →
∀ {k fallback : α},
Std.DTreeMap.Internal.Impl.contains k m₁ = false → (m₁.union! m₂).getKeyD k fallback = m₂.getKeyD k fallback | true |
Sat.Fmla.reify.mk | Mathlib.Tactic.Sat.FromLRAT | ∀ {v : Sat.Valuation} {f : Sat.Fmla} {p : Prop}, (¬v.satisfies_fmla f → p) → Sat.Fmla.reify v f p | true |
Std.ExtHashMap.ext_getKey_getElem?_iff | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{m₁ m₂ : Std.ExtHashMap α β},
m₁ = m₂ ↔ (∀ (k : α) (hk : k ∈ m₁) (hk' : k ∈ m₂), m₁.getKey k hk = m₂.getKey k hk') ∧ ∀ (k : α), m₁[k]? = m₂[k]? | true |
CategoryTheory.Limits.spanCompIso._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z)
{X_1 Y_1 : CategoryTheory.Limits.WalkingSpan} (f_1 : X_1 ⟶ Y_1),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.L... | false |
Lean.Elab.TerminationMeasure.mk.noConfusion | Lean.Elab.PreDefinition.TerminationMeasure | {P : Sort u} →
{ref : Lean.Syntax} →
{structural : Bool} →
{fn : Lean.Expr} →
{ref' : Lean.Syntax} →
{structural' : Bool} →
{fn' : Lean.Expr} →
{ ref := ref, structural := structural, fn := fn } =
{ ref := ref', structural := structural', fn := f... | false |
Lean.Elab.MonadParentDecl.noConfusionType | Lean.Elab.InfoTree.Types | Sort u → {m : Type → Type} → Lean.Elab.MonadParentDecl m → {m' : Type → Type} → Lean.Elab.MonadParentDecl m' → Sort u | false |
CategoryTheory.Abelian.Ext.bilinearComp | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
[inst_2 : CategoryTheory.HasExt C] →
(X Y Z : C) →
(a b c : ℕ) →
a + b = c →
CategoryTheory.Abelian.Ext X Y a →+ CategoryTheory.Abelian.Ext Y Z b →+ CategoryTheory.Abe... | true |
Lean.Meta.Match.State.mk.injEq | Lean.Meta.Match.Match | ∀ (used : Std.HashSet ℕ) (overlaps : Lean.Meta.Match.Overlaps) (counterExamples : List (List Lean.Meta.Match.Example))
(used_1 : Std.HashSet ℕ) (overlaps_1 : Lean.Meta.Match.Overlaps)
(counterExamples_1 : List (List Lean.Meta.Match.Example)),
({ used := used, overlaps := overlaps, counterExamples := counterExampl... | true |
CategoryTheory.Limits.preservesProduct_of_preservesBiproduct | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u'}
[inst_2 : CategoryTheory.Category.{v', u'} D] [inst_3 : CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D)
[inst_4 : F.PreservesZeroMorphisms] {J : Type u_1} [Finite J] {f : J → C}
[CategoryT... | true |
_private.Lean.Meta.CtorRecognizer.0.Lean.Meta.isConstructorApp'?.match_5 | Lean.Meta.CtorRecognizer | (motive : Option (Lean.Expr × ℕ) → Sort u_1) →
(__do_lift : Option (Lean.Expr × ℕ)) →
((fst : Lean.Expr) → (k : ℕ) → motive (some (fst, k))) →
((x : Option (Lean.Expr × ℕ)) → motive x) → motive __do_lift | false |
_private.Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme.0.AlgebraicGeometry.Scheme.IdealSheafData.glueDataT._proof_1 | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} (U V : ↑X.affineOpens), ↑U ⊓ ↑V ≤ ↑V | false |
ENat.coe_lt_coe | Mathlib.Data.ENat.Basic | ∀ {n m : ℕ}, ↑n < ↑m ↔ n < m | true |
CategoryTheory.CountableAB4Star.of_hasExactLimitsOfShape_nat | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[CategoryTheory.Limits.HasFiniteBiproducts C] [CategoryTheory.Limits.HasFiniteColimits C]
[inst_4 : CategoryTheory.Limits.HasCountableProducts C]
[CategoryTheory.HasExactLimitsOfShape (CategoryTheory.Discr... | true |
Std.ExtHashMap.getElem?_filter' | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : LawfulBEq α]
{f : α → β → Bool} {k : α}, (Std.ExtHashMap.filter f m)[k]? = Option.filter (f k) m[k]? | true |
Holor.instAddMonoid._aux_3 | Mathlib.Data.Holor | {α : Type} → {ds : List ℕ} → [AddMonoid α] → ℕ → Holor α ds → Holor α ds | false |
IsAzumaya.recOn | Mathlib.Algebra.Azumaya.Defs | {R : Type u_1} →
{A : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Algebra R A] →
{motive : IsAzumaya R A → Sort u} →
(t : IsAzumaya R A) →
([toProjective : Module.Projective R A] →
[toFaithfulSMul : FaithfulSMul R A] →... | false |
CommMonoidWithZero.zero_mul | Mathlib.Algebra.GroupWithZero.Defs | ∀ {M₀ : Type u_2} [self : CommMonoidWithZero M₀] (a : M₀), 0 * a = 0 | true |
Frm.hom_ext_iff | Mathlib.Order.Category.Frm | ∀ {X Y : Frm} {f g : X ⟶ Y}, f = g ↔ Frm.Hom.hom f = Frm.Hom.hom g | true |
Nat.choose_mul_factorial_mul_factorial | Mathlib.Data.Nat.Choose.Basic | ∀ {n k : ℕ}, k ≤ n → n.choose k * k.factorial * (n - k).factorial = n.factorial | true |
Subring.op_top | Mathlib.Algebra.Ring.Subring.MulOpposite | ∀ {R : Type u_2} [inst : NonAssocRing R], ⊤.op = ⊤ | true |
_private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.0.PeriodPair.mem_lattice._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x y z : M},
(z ∈ Submodule.span R {x, y}) = ∃ a b, a • x + b • y = z | false |
ZFSet.Definable | Mathlib.SetTheory.ZFC.Basic | (n : ℕ) → ((Fin n → ZFSet.{u}) → ZFSet.{u}) → Type (u + 1) | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.toFunctorToCategoricalPullback._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u_3} {B : Type u_6} {C : Type u_4} [inst : CategoryTheory.Category.{u_1, u_3} A]
[inst_1 : CategoryTheory.Category.{u_5, u_6} B] [inst_2 : CategoryTheory.Category.{u_2, u_4} C]
(F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C B) (X : Type u_8)
[inst_3 : CategoryTheory.Category.{u_7, u_8}... | false |
Finset.notMem_singleton | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {a b : α}, a ∉ {b} ↔ a ≠ b | true |
Plausible.SampleableExt.sample | Plausible.Sampleable | {α : Sort u} → [self : Plausible.SampleableExt α] → Plausible.Arbitrary (Plausible.SampleableExt.proxy α) | true |
NNReal.coe_sInf | Mathlib.Data.NNReal.Defs | ∀ (s : Set NNReal), ↑(sInf s) = sInf (NNReal.toReal '' s) | true |
Measurable.of_discrete | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] [DiscreteMeasurableSpace α]
{f : α → β}, Measurable f | true |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.instRxcLawfulHasSize.match_5 | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ (motive : (n : ℕ) → BitVec n → BitVec n → BitVec n → Prop) (n : ℕ) (lo hi lo_1 : BitVec n),
(∀ (lo hi lo_2 : BitVec 0), motive 0 lo hi lo_2) →
(∀ (n : ℕ) (lo hi lo_2 : BitVec (n + 1)), motive n.succ lo hi lo_2) → motive n lo hi lo_1 | false |
LinearEquiv.toContinuousLinearEquivOfBounds | Mathlib.Analysis.Normed.Operator.ContinuousLinearMap | {𝕜 : Type u_1} →
{𝕜₂ : Type u_2} →
{E : Type u_3} →
{F : Type u_4} →
[inst : Ring 𝕜] →
[inst_1 : Ring 𝕜₂] →
[inst_2 : SeminormedAddCommGroup E] →
[inst_3 : SeminormedAddCommGroup F] →
[inst_4 : Module 𝕜 E] →
[inst_5 : Module ... | true |
_private.Mathlib.Analysis.SumIntegralComparisons.0.integral_le_sum_mul_Ico_of_antitone_monotone._proof_1_3 | Mathlib.Analysis.SumIntegralComparisons | ∀ {a b : ℕ} (i : ℕ), a ≤ i ∧ i < b → i + 1 ≤ b | false |
Lean.Compiler.LCNF.Simp.ConstantFold.Folder.leftRightAnnihilator._auto_1 | Lean.Compiler.LCNF.Simp.ConstantFold | Lean.Syntax | false |
UniformEquiv.piCongrRight | Mathlib.Topology.UniformSpace.Equiv | {ι : Type u_4} →
{β₁ : ι → Type u_5} →
{β₂ : ι → Type u_6} →
[inst : (i : ι) → UniformSpace (β₁ i)] →
[inst_1 : (i : ι) → UniformSpace (β₂ i)] → ((i : ι) → β₁ i ≃ᵤ β₂ i) → ((i : ι) → β₁ i) ≃ᵤ ((i : ι) → β₂ i) | true |
AlgebraicGeometry.Scheme.isAffine_affineBasisCover | Mathlib.AlgebraicGeometry.AffineScheme | ∀ (X : AlgebraicGeometry.Scheme) (i : X.affineBasisCover.I₀), AlgebraicGeometry.IsAffine (X.affineBasisCover.X i) | true |
Array.append_inj_left' | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs₁ xs₂ ys₁ ys₂ : Array α}, xs₁ ++ ys₁ = xs₂ ++ ys₂ → ys₁.size = ys₂.size → xs₁ = xs₂ | true |
RingHomInvPair.mk._flat_ctor | Mathlib.Algebra.Ring.CompTypeclasses | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ : R₁ →+* R₂}
{σ' : outParam (R₂ →+* R₁)}, σ'.comp σ = RingHom.id R₁ → σ.comp σ' = RingHom.id R₂ → RingHomInvPair σ σ' | false |
MeasureTheory.AddQuotientMeasureEqMeasurePreimage.addHaarMeasure_quotient | Mathlib.MeasureTheory.Measure.Haar.Quotient | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : MeasurableSpace G] [inst_2 : TopologicalSpace G]
[IsTopologicalAddGroup G] [BorelSpace G] [PolishSpace G] {Γ : AddSubgroup G} [inst_6 : Γ.Normal] [T2Space (G ⧸ Γ)]
[SecondCountableTopology (G ⧸ Γ)] {μ : MeasureTheory.Measure (G ⧸ Γ)} [Countable ↥Γ] (ν : MeasureTheory.M... | true |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.isDefEqArgs._sparseCasesOn_1 | Lean.Meta.ExprDefEq | {motive : Lean.Meta.DefEqArgsFirstPassResult → Sort u} →
(t : Lean.Meta.DefEqArgsFirstPassResult) →
((postponedImplicit postponedHO : Array ℕ) →
motive (Lean.Meta.DefEqArgsFirstPassResult.ok postponedImplicit postponedHO)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
LightDiagram.diagram | Mathlib.Topology.Category.LightProfinite.Basic | LightDiagram → CategoryTheory.Functor ℕᵒᵖ FintypeCat | true |
_private.Mathlib.LinearAlgebra.TensorAlgebra.Basic.0.instSMulCommClassTensorAlgebra._proof_1 | Mathlib.LinearAlgebra.TensorAlgebra.Basic | ∀ {R : Type u_1} {S : Type u_2} {A : Type u_4} {M : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring S]
[inst_2 : AddCommMonoid M] [inst_3 : CommSemiring A] [inst_4 : Algebra R A] [inst_5 : Algebra S A]
[inst_6 : Module R M] [inst_7 : Module S M] [inst_8 : Module A M] [inst_9 : IsScalarTower R A M]
[inst_... | false |
_private.Mathlib.Combinatorics.Additive.VerySmallDoubling.0.Finset.doubling_lt_golden_ratio._simp_1_21 | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a) | false |
DifferentiableAt.smul_const | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {x : E}
{𝕜' : Type u_5} [inst_5 : NormedRing 𝕜'] [inst_6 : NormedAlgebra 𝕜 𝕜'] [inst_7 : Module 𝕜' F] [IsBo... | true |
InitialSeg.mem_range_of_rel' | Mathlib.Order.InitialSeg | ∀ {α : Type u_4} {β : Type u_5} {r : α → α → Prop} {s : β → β → Prop} (self : InitialSeg r s) (a : α) (b : β),
s b (self.toRelEmbedding a) → b ∈ Set.range ⇑self.toRelEmbedding | true |
Std.DHashMap.Internal.List.HashesTo.mk | Std.Data.DHashMap.Internal.Defs | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {l : List ((a : α) × β a)} {i size : ℕ},
(∀ (h : 0 < size), ∀ p ∈ l, (↑(Std.DHashMap.Internal.mkIdx size h (hash p.fst))).toNat = i) →
Std.DHashMap.Internal.List.HashesTo l i size | true |
MonCat.instConcreteCategoryMonoidHomCarrier._proof_1 | Mathlib.Algebra.Category.MonCat.Basic | ∀ {X Y : MonCat} (f : ↑X →* ↑Y), { hom' := f }.hom' = f | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.