name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
IsCoveringMap.exists_path_lifts | Mathlib.Topology.Homotopy.Lifting | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {p : E → X},
IsCoveringMap p → ∀ (γ : C(↑unitInterval, X)) (e : E), γ 0 = p e → ∃ Γ, p ∘ ⇑Γ = ⇑γ ∧ Γ 0 = e | true |
MvPolynomial.algebraTensorAlgEquiv_symm_monomial | Mathlib.RingTheory.TensorProduct.MvPolynomial | ∀ (R : Type u) [inst : CommSemiring R] {σ : Type u_1} (A : Type u_4) [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
(m : σ →₀ ℕ) (a : A),
(MvPolynomial.algebraTensorAlgEquiv R A).symm ((MvPolynomial.monomial m) a) = a ⊗ₜ[R] (MvPolynomial.monomial m) 1 | true |
Nat.doubleFactorial.eq_2 | Mathlib.Data.Nat.Factorial.DoubleFactorial | Nat.doubleFactorial 1 = 1 | true |
PresentedGroup.mk_eq_mk_of_inv_mul_mem | Mathlib.GroupTheory.PresentedGroup | ∀ {α : Type u_1} {rels : Set (FreeGroup α)} {x y : FreeGroup α},
x⁻¹ * y ∈ rels → (PresentedGroup.mk rels) x = (PresentedGroup.mk rels) y | true |
Std.Ric.LawfulRcoIntersection.mk | Init.Data.Range.Polymorphic.PRange | ∀ {α : Type w} [inst : LT α] [inst_1 : LE α] [inst_2 : Std.Ric.HasRcoIntersection α],
(∀ {a : α} {r : Std.Ric α} {s : Std.Rco α}, a ∈ Std.Ric.HasRcoIntersection.intersection r s ↔ a ∈ r ∧ a ∈ s) →
Std.Ric.LawfulRcoIntersection α | true |
CategoryTheory.MorphismProperty.RightFraction.rec | Mathlib.CategoryTheory.Localization.CalculusOfFractions | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{W : CategoryTheory.MorphismProperty C} →
{X Y : C} →
{motive : W.RightFraction X Y → Sort u} →
({X' : C} → (s : X' ⟶ X) → (hs : W s) → (f : X' ⟶ Y) → motive { X' := X', s := s, hs := hs, f := f }) →
(t : W.RightF... | false |
CategoryTheory.ObjectProperty.ContainsUnit.mk | Mathlib.CategoryTheory.Monoidal.Subcategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{P : CategoryTheory.ObjectProperty C}, P (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) → P.ContainsUnit | true |
MeasureTheory.Measure.ext_prod₃_iff' | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_4} {β : Type u_5} {γ : Type u_6} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} {μ ν : MeasureTheory.Measure ((α × β) × γ)} [MeasureTheory.IsFiniteMeasure μ],
μ = ν ↔
∀ {s : Set α} {t : Set β} {u : Set γ},
MeasurableSet s → MeasurableSet t → MeasurableSet u → μ ((... | true |
Std.Iterators.Types.Map | Init.Data.Iterators.Combinators.Monadic.FilterMap | Type w →
{β γ : Type w} →
(m : Type w → Type w') →
(n : Type w → Type w'') →
(⦃α : Type w⦄ → m α → n α) → [Functor n] → (β → Std.Iterators.PostconditionT n γ) → Type w | true |
Qq.SortLocalDecls.Context | Qq.SortLocalDecls | Type | true |
Std.TreeSet.max!_erase_eq_of_not_compare_max!_eq | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α] {k : α},
(t.erase k).isEmpty = false → ¬cmp k t.max! = Ordering.eq → (t.erase k).max! = t.max! | true |
List.length_sym._unary | Mathlib.Data.List.Sym | ∀ {α : Type u_1} (_x : (_ : ℕ) ×' List α), (List.sym _x.1 _x.2).length = _x.2.length.multichoose _x.1 | false |
Lean.Elab.WF.GuessLex.RecCallWithContext.mk.injEq | Lean.Elab.PreDefinition.WF.GuessLex | ∀ (ref : Lean.Syntax) (caller : ℕ) (params : Array Lean.Expr) (callee : ℕ) (args : Array Lean.Expr)
(ctxt : Lean.Elab.WF.GuessLex.SavedLocalContext) (ref_1 : Lean.Syntax) (caller_1 : ℕ) (params_1 : Array Lean.Expr)
(callee_1 : ℕ) (args_1 : Array Lean.Expr) (ctxt_1 : Lean.Elab.WF.GuessLex.SavedLocalContext),
({ re... | true |
Fin.add.match_1 | Init.Data.Fin.Basic | {n : ℕ} →
(motive : Fin n → Fin n → Sort u_1) →
(x x_1 : Fin n) → ((a : ℕ) → (h : a < n) → (b : ℕ) → (isLt : b < n) → motive ⟨a, h⟩ ⟨b, isLt⟩) → motive x x_1 | false |
_private.Lean.Data.RArray.0.Lean.RArray.ofFn.go | Lean.Data.RArray | {α : Type u_1} → {n : ℕ} → (Fin n → α) → (lb ub : ℕ) → lb < ub → ub ≤ n → Lean.RArray α | true |
Polynomial.Chebyshev.coeff_le_of_forall_abs_le_one | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Extremal | ∀ {n : ℕ} {P : Polynomial ℝ},
P.degree ≤ ↑n → (∀ x ∈ Set.Icc (-1) 1, |Polynomial.eval x P| ≤ 1) → P.coeff n ≤ 2 ^ (n - 1) | true |
Lean.instReprBinderInfo | Lean.Expr | Repr Lean.BinderInfo | true |
CategoryTheory.Arrow.augmentedCechNerve._proof_2 | Mathlib.AlgebraicTopology.CechNerve | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (f : CategoryTheory.Arrow C)
[inst_1 : ∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom]
⦃X Y : SimplexCategoryᵒᵖ⦄ (f_1 : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Functor.id (CategoryT... | false |
Mathlib.Meta.FunProp.Mor.isCoeFunName | Mathlib.Tactic.FunProp.Mor | Lean.Name → Lean.CoreM Bool | true |
BitVec._sizeOf_1 | Init.SizeOf | {w : ℕ} → BitVec w → ℕ | false |
QuadraticModuleCat.mk | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat | {R : Type u} → [inst : CommRing R] → (toModuleCat : ModuleCat R) → QuadraticForm R ↑toModuleCat → QuadraticModuleCat R | true |
_private.Lean.Class.0.Lean.addClass._sparseCasesOn_1 | Lean.Class | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.InductiveVal) → motive (Lean.ConstantInfo.inductInfo val)) →
((val : Lean.AxiomVal) → motive (Lean.ConstantInfo.axiomInfo val)) →
(Nat.hasNotBit 33 t.ctorIdx → motive t) → motive t | false |
irrational_sqrt_of_multiplicity_odd | Mathlib.NumberTheory.Real.Irrational | ∀ (m : ℤ), 0 < m → ∀ (p : ℕ) [hp : Fact (Nat.Prime p)], multiplicity (↑p) m % 2 = 1 → Irrational √↑m | true |
PosNum.cast_to_num | Mathlib.Data.Num.Lemmas | ∀ (n : PosNum), ↑n = Num.pos n | true |
_private.Lean.Meta.Sym.Simp.DiscrTree.0.Lean.Meta.Sym.getMatchLoop._proof_5 | Lean.Meta.Sym.Simp.DiscrTree | ∀ {α : Type} (cs : Array (Lean.Meta.DiscrTree.Key × Lean.Meta.DiscrTree.Trie α)), ¬cs.size = 0 → ¬0 < cs.size → False | false |
Lean.Lsp.DidOpenTextDocumentParams.recOn | Lean.Data.Lsp.TextSync | {motive : Lean.Lsp.DidOpenTextDocumentParams → Sort u} →
(t : Lean.Lsp.DidOpenTextDocumentParams) →
((textDocument : Lean.Lsp.TextDocumentItem) → motive { textDocument := textDocument }) → motive t | false |
Filter.instCountableInterFilterCountableGenerate | Mathlib.Order.Filter.CountableInter | ∀ {α : Type u_1} (g : Set (Set α)), CountableInterFilter (Filter.countableGenerate g) | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Defs.0.CategoryTheory.IsPullback.isoIsPullback_inv_fst._simp_1_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Defs | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
(CategoryTheory.CategoryStruct.comp α.inv f = g) = (f = CategoryTheory.CategoryStruct.comp α.hom g) | false |
Aesop.EqualUpToIds.readAllowAssignmentDiff | Aesop.Util.EqualUpToIds | Aesop.EqualUpToIdsM Bool | true |
_private.Init.Core.0.dif_pos.match_1_1 | Init.Core | ∀ {c : Prop} (motive : Decidable c → Prop) (h : Decidable c),
(∀ (h : c), motive (isTrue h)) → (∀ (hnc : ¬c), motive (isFalse hnc)) → motive h | false |
Seminorm._sizeOf_inst | Mathlib.Analysis.Seminorm | (𝕜 : Type u_12) →
(E : Type u_13) →
{inst : SeminormedRing 𝕜} →
{inst_1 : AddGroup E} → {inst_2 : SMul 𝕜 E} → [SizeOf 𝕜] → [SizeOf E] → SizeOf (Seminorm 𝕜 E) | false |
Matrix.exp_nsmul | Mathlib.Analysis.Normed.Algebra.MatrixExponential | ∀ {m : Type u_1} {𝔸 : Type u_4} [inst : Fintype m] [inst_1 : DecidableEq m] [inst_2 : NormedRing 𝔸] [NormedAlgebra ℚ 𝔸]
[CompleteSpace 𝔸] (n : ℕ) (A : Matrix m m 𝔸), NormedSpace.exp (n • A) = NormedSpace.exp A ^ n | true |
Module.Finite.of_localizationSpan_finite | Mathlib.RingTheory.Localization.Finiteness | ∀ {R : Type u} [inst : CommRing R] {M : Type w} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (t : Finset R),
Ideal.span ↑t = ⊤ →
(∀ (g : ↥t), Module.Finite (Localization.Away ↑g) (LocalizedModule (Submonoid.powers ↑g) M)) → Module.Finite R M | true |
MvPFunctor.M.Path._sizeOf_inst | Mathlib.Data.PFunctor.Multivariate.M | {n : ℕ} → (P : MvPFunctor.{u} (n + 1)) → (a : P.last.M) → (a_1 : Fin2 n) → SizeOf (MvPFunctor.M.Path P a a_1) | false |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.delabLit.match_1 | Lean.PrettyPrinter.Delaborator.Builtins | (motive : Lean.Literal → Sort u_1) →
(l : Lean.Literal) →
((n : ℕ) → motive (Lean.Literal.natVal n)) → ((s : String) → motive (Lean.Literal.strVal s)) → motive l | false |
MulHom.coeFn | Mathlib.Algebra.Group.Pi.Lemmas | (α : Type u_4) → (β : Type u_5) → [inst : Mul α] → [inst_1 : CommSemigroup β] → (α →ₙ* β) →ₙ* α → β | true |
Polynomial.Chebyshev.roots_U_real_nodup | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.RootsExtrema | ∀ (n : ℕ), (Multiset.map (fun k => Real.cos ((↑k + 1) * Real.pi / (↑n + 1))) (Multiset.range n)).Nodup | true |
TopCat.Sheaf.objSupIsoProdEqLocus_inv_fst | Mathlib.Topology.Sheaves.CommRingCat | ∀ {X : TopCat} (F : TopCat.Sheaf CommRingCat X) (U V : TopologicalSpace.Opens ↑X)
(x :
↑(CommRingCat.of
↥(((CommRingCat.Hom.hom (F.obj.map (CategoryTheory.homOfLE ⋯).op)).comp
(RingHom.fst ↑(F.obj.obj (Opposite.op U)) ↑(F.obj.obj (Opposite.op V)))).eqLocus
((CommRingCat.Hom.hom... | true |
IsPrimitiveRoot.subOneIntegralPowerBasis_gen | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {n : ℕ} {K : Type u} [inst : Field K] {ζ : K} [inst_1 : NeZero n] [inst_2 : CharZero K]
[inst_3 : IsCyclotomicExtension {n} ℚ K] (hζ : IsPrimitiveRoot ζ n), hζ.subOneIntegralPowerBasis.gen = ⟨ζ - 1, ⋯⟩ | true |
Lean.Doc.Parser.bold | Lean.DocString.Parser | Lean.Doc.Parser.InlineCtxt → Lean.Parser.ParserFn | true |
Std.DHashMap.Internal.List.HashesTo.mk._flat_ctor | 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 | false |
ProbabilityTheory.integrable_rpow_abs_mul_exp_add_of_integrable_exp_mul | Mathlib.Probability.Moments.IntegrableExpMul | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω} {t v x : ℝ},
MeasureTheory.Integrable (fun ω => Real.exp ((v + t) * X ω)) μ →
MeasureTheory.Integrable (fun ω => Real.exp ((v - t) * X ω)) μ →
0 ≤ x →
x < |t| → ∀ {p : ℝ}, 0 ≤ p → MeasureTheory.Integrable (fun a => |X... | true |
Set.infinite_union._simp_1 | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {s t : Set α}, (s ∪ t).Infinite = (s.Infinite ∨ t.Infinite) | false |
Real.logb_lt_logb_iff_of_base_lt_one._simp_1 | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {b x y : ℝ}, 0 < b → b < 1 → 0 < x → 0 < y → (Real.logb b x < Real.logb b y) = (y < x) | false |
Std.DHashMap.Internal.Raw₀.Const.size_le_size_insertMany | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
{ρ : Type w} [inst_2 : ForIn Id ρ (α × β)] [EquivBEq α] [LawfulHashable α],
(↑m).WF → ∀ {l : ρ}, (↑m).size ≤ (↑↑(Std.DHashMap.Internal.Raw₀.Const.insertMany m l)).size | true |
GenContFract.IntFractPair.of_inv_fr_num_lt_num_of_pos | Mathlib.Algebra.ContinuedFractions.Computation.TerminatesIffRat | ∀ {q : ℚ}, 0 < q → (GenContFract.IntFractPair.of q⁻¹).fr.num < q.num | true |
Batteries.Tactic.CollectOpaques.M | Batteries.Tactic.PrintOpaques | Type → Type | true |
ProfiniteGrp.ofFiniteGrp._proof_2 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ (G : FiniteGrp.{u_1}), CompactSpace ↑G.toGrp | false |
differentiable_pow | Mathlib.Analysis.Calculus.FDeriv.Pow | ∀ {𝕜 : Type u_1} {𝔸 : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedRing 𝔸] [inst_2 : NormedAlgebra 𝕜 𝔸]
(n : ℕ), Differentiable 𝕜 fun x => x ^ n | true |
_private.Mathlib.Topology.Algebra.Valued.WithVal.0.WithVal.valueGroupOrderIso₀_restrict._simp_1_1 | Mathlib.Topology.Algebra.Valued.WithVal | ∀ {R : Type u_1} {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] [inst_1 : Ring R] (v : Valuation R Γ₀)
(r : WithVal v), Valued.v r = v r.ofVal | false |
Function.invFunOn_apply_mem._simp_1 | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β} {a : α} [inst : Nonempty α],
a ∈ s → (Function.invFunOn f s (f a) ∈ s) = True | false |
Std.Roo.size.eq_1 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : Std.Rxo.HasSize α] [inst_1 : Std.PRange.UpwardEnumerable α] (r : Std.Roo α),
r.size =
match Std.PRange.succ? r.lower with
| none => 0
| some lower => Std.Rxo.HasSize.size lower r.upper | true |
_private.Mathlib.Analysis.Analytic.IteratedFDeriv.0.HasFPowerSeriesOnBall.iteratedFDeriv_eq_sum_of_completeSpace._simp_1_2 | Mathlib.Analysis.Analytic.IteratedFDeriv | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{p : FormalMultilinearSeries 𝕜 E F} {x : E} {r : ENNReal},
HasFPowerSeriesOnBall f p x r = HasFPo... | false |
_private.Init.Grind.ToIntLemmas.0.Lean.Grind.ToInt.isNonempty._proof_1_2 | Init.Grind.ToIntLemmas | ∀ {α : Type u_1} (a : α) (lo hi : ℤ) [inst : Lean.Grind.ToInt α (Lean.Grind.IntInterval.co lo hi)],
lo ≤ ↑a ∧ ↑a < hi → ¬lo < hi → False | false |
Std.PRange.UpwardEnumerable.Map.lt_iff | Init.Data.Range.Polymorphic.Map | ∀ {α : Type u_1} {β : Type u_2} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.UpwardEnumerable β]
(f : Std.PRange.UpwardEnumerable.Map α β) {a b : α},
Std.PRange.UpwardEnumerable.LT a b ↔ Std.PRange.UpwardEnumerable.LT (f.toFun a) (f.toFun b) | true |
ProbabilityTheory.Kernel.fst | Mathlib.Probability.Kernel.Composition.MapComap | {α : Type u_1} →
{β : Type u_2} →
{γ : Type u_3} →
{mα : MeasurableSpace α} →
{mβ : MeasurableSpace β} →
{mγ : MeasurableSpace γ} → ProbabilityTheory.Kernel α (β × γ) → ProbabilityTheory.Kernel α β | true |
Order.Frame.MinimalAxioms.inf_sSup_eq | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} (minAx : Order.Frame.MinimalAxioms α) {s : Set α} {a : α}, a ⊓ sSup s = ⨆ b ∈ s, a ⊓ b | true |
_private.Init.Data.SInt.Lemmas.0.Int64.ne_of_lt._simp_1_2 | Init.Data.SInt.Lemmas | ∀ {x y : Int64}, (x = y) = (x.toInt = y.toInt) | false |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.Raw₀.Const.alterₘ.match_1.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {β : Type u_1} (motive : Option β → Sort u_2) (h_1 : Unit → motive none) (h_2 : (b : β) → motive (some b)),
(match none with
| none => h_1 ()
| some b => h_2 b) =
h_1 () | true |
CategoryTheory.MorphismProperty.isColocal_iff | Mathlib.CategoryTheory.ObjectProperty.Local | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C) (X : C),
W.isColocal X ↔ ∀ ⦃Y Z : C⦄ (g : Y ⟶ Z), W g → Function.Bijective fun f => CategoryTheory.CategoryStruct.comp f g | true |
CategoryTheory.Abelian.AbelianStruct.imageι_π._autoParam | Mathlib.CategoryTheory.Abelian.Basic | Lean.Syntax | false |
CategoryTheory.ObjectProperty.shift | Mathlib.CategoryTheory.ObjectProperty.Shift | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
CategoryTheory.ObjectProperty C →
{A : Type u_2} → [inst_1 : AddMonoid A] → [CategoryTheory.HasShift C A] → A → CategoryTheory.ObjectProperty C | true |
Lean.Linter.MissingDocs.checkMixfix | Lean.Linter.MissingDocs | Lean.Linter.MissingDocs.SimpleHandler | true |
Metric.isBounded_image_iff | Mathlib.Topology.MetricSpace.Bounded | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] {f : β → α} {s : Set β},
Bornology.IsBounded (f '' s) ↔ ∃ C, ∀ x ∈ s, ∀ y ∈ s, dist (f x) (f y) ≤ C | true |
AdjoinRoot.powerBasisAux'._proof_3 | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R] {g : Polynomial R} (hg : g.Monic) (f₁ : R) (f₂ : AdjoinRoot g)
(i : Fin g.natDegree),
((AdjoinRoot.modByMonicHom hg) (f₁ • f₂)).coeff ↑i =
((RingHom.id R) f₁ • fun i => ((AdjoinRoot.modByMonicHom hg) f₂).coeff ↑i) i | false |
AlgebraicGeometry.instCanonicallyOverSpecStalkCommRingCatPresheaf | Mathlib.AlgebraicGeometry.Stalk | (X : AlgebraicGeometry.Scheme) → (x : ↥X) → (AlgebraicGeometry.Spec (X.presheaf.stalk x)).CanonicallyOver X | true |
String.Slice.Pos.not_endPos_lt._simp_1 | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} {p : s.Pos}, (s.endPos < p) = False | false |
CategoryTheory.Functor.Elements.isInitialElementsMkShrinkYonedaObjObjEquivId._proof_1 | Mathlib.CategoryTheory.Limits.Presheaf | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.LocallySmall.{u_1, u_2, u_3} C]
(X : C) (u : (CategoryTheory.shrinkYoneda.{u_1, u_2, u_3}.flip.obj (Opposite.op X)).Elements),
(CategoryTheory.shrinkYoneda.{u_1, u_2, u_3}.flip.obj (Opposite.op X)).map
(CategoryTheory.shri... | false |
Subfield.comap_top | Mathlib.Algebra.Field.Subfield.Basic | ∀ {K : Type u} {L : Type v} [inst : DivisionRing K] [inst_1 : DivisionRing L] (f : K →+* L), Subfield.comap f ⊤ = ⊤ | true |
Lean.Compiler.LCNF.compile | Lean.Compiler.LCNF.Main | Array Lean.Name → Lean.CoreM (Array (Array Lean.IR.Decl)) | true |
Mathlib.Tactic.Order.orderCoreImp | Mathlib.Tactic.Order | Bool → Array Lean.Expr → Lean.Expr → Lean.MVarId → Mathlib.Tactic.AtomM Unit | true |
CategoryTheory.MonoidalCategory.DayConvolution.braidingInvCorepresenting._proof_1 | Mathlib.CategoryTheory.Monoidal.DayConvolution.Braided | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {V : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} V] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.BraidedCategory C] [inst_4 : CategoryTheory.MonoidalCategory V]
[inst_5 : CategoryTheory.BraidedCategory V] (F G : Cat... | false |
SSet.OneTruncation₂.ofNerve₂ | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | (C : Type u) →
[inst : CategoryTheory.Category.{u, u} C] →
CategoryTheory.ReflQuiv.of (SSet.OneTruncation₂ ((SSet.truncation 2).obj (CategoryTheory.nerve C))) ≅
CategoryTheory.ReflQuiv.of C | true |
Set.pairwise_univ | Mathlib.Data.Set.Pairwise.Basic | ∀ {α : Type u_1} {r : α → α → Prop}, Set.univ.Pairwise r ↔ Pairwise r | true |
StarSubalgebra.mem_top | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : Algebra R A] [inst_4 : StarRing A] [inst_5 : StarModule R A] {x : A}, x ∈ ⊤ | true |
neg_iff_pos_of_mul_neg | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : LinearOrder R] {a b : R} [ExistsAddOfLE R] [PosMulMono R] [MulPosMono R]
[AddRightMono R] [AddRightReflectLE R], a * b < 0 → (a < 0 ↔ 0 < b) | true |
FirstOrder.Language.Substructure.instInhabited_fg | Mathlib.ModelTheory.FinitelyGenerated | {L : FirstOrder.Language} → {M : Type u_1} → [inst : L.Structure M] → Inhabited { S // S.FG } | true |
LatticeCon.mk | Mathlib.Order.Lattice.Congruence | {α : Type u_2} →
[inst : Lattice α] →
(toSetoid : Setoid α) →
(∀ {w x y z : α}, toSetoid w x → toSetoid y z → toSetoid (w ⊓ y) (x ⊓ z)) →
(∀ {w x y z : α}, toSetoid w x → toSetoid y z → toSetoid (w ⊔ y) (x ⊔ z)) → LatticeCon α | true |
Nat.gcd_sub_self_right | Init.Data.Nat.Gcd | ∀ {m n : ℕ}, m ≤ n → m.gcd (n - m) = m.gcd n | true |
_private.Lean.Compiler.LCNF.PullLetDecls.0.Lean.Compiler.LCNF.Decl.pullInstances._sparseCasesOn_1 | Lean.Compiler.LCNF.PullLetDecls | {pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.LetValue pu → Sort u} →
(t : Lean.Compiler.LCNF.LetValue pu) →
((declName : Lean.Name) →
(us : List Lean.Level) →
(args : Array (Lean.Compiler.LCNF.Arg pu)) →
(h : pu = Lean.Compiler.LCNF.Purity.pure) →
... | false |
Lean.Meta.Simp.NormCastConfig.singlePass._inherited_default | Init.MetaTypes | Bool | false |
NonUnitalAlgebra.range_id | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A], NonUnitalAlgHom.range (NonUnitalAlgHom.id R A) = ⊤ | true |
Filter.Tendsto.finCons | Mathlib.Topology.Constructions | ∀ {Y : Type v} {n : ℕ} {A : Fin (n + 1) → Type u_9} [inst : (i : Fin (n + 1)) → TopologicalSpace (A i)] {f : Y → A 0}
{g : Y → (j : Fin n) → A j.succ} {l : Filter Y} {x : A 0} {y : (j : Fin n) → A j.succ},
Filter.Tendsto f l (nhds x) →
Filter.Tendsto g l (nhds y) → Filter.Tendsto (fun a => Fin.cons (f a) (g a))... | true |
WithTop.untop.congr_simp | Mathlib.Order.WithBot | ∀ {α : Type u_1} (x x_1 : WithTop α) (e_x : x = x_1) (a : x ≠ ⊤), x.untop a = x_1.untop ⋯ | true |
CategoryTheory.ComonadicLeftAdjoint.R | Mathlib.CategoryTheory.Monad.Adjunction | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{D : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} D} →
(L : CategoryTheory.Functor C D) → [self : CategoryTheory.ComonadicLeftAdjoint L] → CategoryTheory.Functor D C | true |
RootPairing.rootForm_symmetric | Mathlib.LinearAlgebra.RootSystem.Finite.CanonicalBilinear | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) [inst_5 : Fintype ι],
LinearMap.IsSymm P.RootForm | true |
_private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Relations.0.RootPairing.GeckConstruction.lie_h_e._simp_1_6 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Relations | ∀ {M : Type u_4} [inst : AddMonoid M] [IsRightCancelAdd M] {a b : M}, (b = a + b) = (a = 0) | false |
Fin.cast_eq_cast | Mathlib.Data.Fin.SuccPred | ∀ {n m : ℕ} (h : n = m), Fin.cast h = cast ⋯ | true |
Submodule.lTensorOne'._proof_1 | Mathlib.LinearAlgebra.TensorProduct.Submodule | ∀ {R : Type u_2} {S : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S]
(N : Submodule R S), ((Subalgebra.toSubmodule ⊥).mulMap N).range = N | false |
CategoryTheory.CostructuredArrow.toOver_obj_left | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor D T) (X : T)
(X_1 : CategoryTheory.Comma (F.comp (CategoryTheory.Functor.id T)) (CategoryTheory.Functor.fromPUnit X)),
((CategoryTheory.CostructuredArrow.toOver F X).... | true |
uniformContinuous_of_const | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] [inst_1 : UniformSpace β] {c : α → β},
(∀ (a b : α), c a = c b) → UniformContinuous c | true |
Lean.Lsp.TextDocumentIdentifier.uri | Lean.Data.Lsp.Basic | Lean.Lsp.TextDocumentIdentifier → Lean.Lsp.DocumentUri | true |
CategoryTheory.Functor.mapCommGrpNatTrans_app_hom_hom_hom | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u₂} [inst_3 : CategoryTheory.Category.{v₂, u₂} D]
[inst_4 : CategoryTheory.CartesianMonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D]
... | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.andFlatteningPass.processFVar._sparseCasesOn_1 | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
_private.Mathlib.CategoryTheory.WithTerminal.Cone.0.CategoryTheory.WithTerminal.coneBack._proof_9 | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] {X : C} {K : CategoryTheory.Functor J (CategoryTheory.Over X)}
{X_1 Y Z : CategoryTheory.Limits.Cone (CategoryTheory.WithTerminal.liftFromOver.obj K)} (f : X_1 ⟶ Y) (g : Y ⟶ Z)
(j : J),
... | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.ToMkOne.0.SimplexCategory.toMk₁_surjective._proof_1_8 | Mathlib.AlgebraicTopology.SimplexCategory.ToMkOne | ∀ {n : ℕ} (f : SimplexCategory.mk n ⟶ SimplexCategory.mk 1) (i : CategoryTheory.ToType (SimplexCategory.mk n)),
∀ j ∈ {i | (CategoryTheory.ConcreteCategory.hom f) i = 1}, j ≤ i → 1 = (CategoryTheory.ConcreteCategory.hom f) i | false |
Aesop.BuilderName.constructors.sizeOf_spec | Aesop.Rule.Name | sizeOf Aesop.BuilderName.constructors = 1 | true |
Nat.testBit_two_pow_sub_one | Init.Data.Nat.Bitwise.Lemmas | ∀ (n i : ℕ), (2 ^ n - 1).testBit i = decide (i < n) | true |
CategoryTheory.MorphismProperty.regularMono.respectsIso | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C], (CategoryTheory.MorphismProperty.regularMono C).RespectsIso | true |
_private.Mathlib.MeasureTheory.Function.SimpleFuncDense.0.HasCompactSupport.exists_simpleFunc_approx_of_prod.match_1_1 | Mathlib.MeasureTheory.Function.SimpleFuncDense | ∀ {X : Type u_1} {Y : Type u_2} {α : Type u_3} [inst : MeasurableSpace X] [inst_1 : MeasurableSpace Y]
[inst_2 : PseudoMetricSpace α] {f : X × Y → α} {ε : ℝ} ⦃t' : Set (X × Y)⦄
(motive : (∃ g s, MeasurableSet s ∧ t' ⊆ s ∧ ∀ x ∈ s, dist (f x) (g x) < ε) → Prop)
(h : ∃ g s, MeasurableSet s ∧ t' ⊆ s ∧ ∀ x ∈ s, dist ... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.