name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Meta.Sym.Arith.ClassifyResult.nonCommSemiring.elim | Lean.Meta.Sym.Arith.Types | {motive : Lean.Meta.Sym.Arith.ClassifyResult → Sort u} →
(t : Lean.Meta.Sym.Arith.ClassifyResult) →
t.ctorIdx = 3 → ((id : ℕ) → motive (Lean.Meta.Sym.Arith.ClassifyResult.nonCommSemiring id)) → motive t | null | false |
CategoryTheory.Bicategory.Adj.Hom.noConfusion | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | {P : Sort u_1} →
{B : Type u} →
{inst : CategoryTheory.Bicategory B} →
{a b : B} →
{t : CategoryTheory.Bicategory.Adj.Hom a b} →
{B' : Type u} →
{inst' : CategoryTheory.Bicategory B'} →
{a' b' : B'} →
{t' : CategoryTheory.Bicategory.Adj.Hom a' b'} ... | null | false |
Hypergraph.EAdj.inter_nonempty | Mathlib.Combinatorics.Hypergraph.Basic | ∀ {α : Type u_1} {e f : Set α} {H : Hypergraph α}, H.EAdj e f → (e ∩ f).Nonempty | null | true |
Algebra.FormallyUnramified.isRadical_map_isMaximal | Mathlib.RingTheory.Unramified.Field | ∀ (A : Type u_2) [inst : CommRing A] (B : Type u_4) [inst_1 : CommRing B] [inst_2 : Algebra A B]
[Algebra.EssFiniteType A B] [Algebra.FormallyUnramified A B] (p : Ideal A) [p.IsMaximal],
(Ideal.map (algebraMap A B) p).IsRadical | null | true |
Lean.Expr.isAppOfArity._f | Lean.Expr | (x : Lean.Expr) → Lean.Expr.below (motive := fun x => Lean.Name → ℕ → Bool) x → Lean.Name → ℕ → Bool | null | false |
Configuration.HasPoints.hasLines._proof_1 | Mathlib.Combinatorics.Configuration | ∀ {P : Type u_2} {L : Type u_1} [inst : Fintype P] [inst_1 : Fintype L],
Fintype.card P = Fintype.card L → Fintype.card L = Fintype.card P | null | false |
IsNonarchimedeanLocalField.instCompleteSpace | Mathlib.NumberTheory.LocalField.Basic | ∀ (K : Type u_1) [inst : Field K] [inst_1 : ValuativeRel K] [inst_2 : UniformSpace K] [IsUniformAddGroup K]
[IsNonarchimedeanLocalField K], CompleteSpace K | null | true |
CategoryTheory.CartesianMonoidalCategory.lift_comp_fst_snd | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{X Y Z : C} (f : X ⟶ CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z),
CategoryTheory.CartesianMonoidalCategory.lift
(CategoryTheory.CategoryStruct.comp f (CategoryTheory.SemiCartesianMonoidalCat... | null | true |
Subrel.inclusionEmbedding._proof_1 | Mathlib.Order.RelIso.Set | ∀ {α : Type u_1} {s t : Set α} (h : s ⊆ t) (x x_1 : { x // x ∈ s }), Set.inclusion h x = Set.inclusion h x_1 → x = x_1 | null | false |
Lean.Grind.CommRing.instBEqPoly.beq._sunfold | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Bool | null | false |
NormedSpace.casesOn | Mathlib.Analysis.Normed.Module.Basic | {𝕜 : Type u_6} →
{E : Type u_7} →
[inst : NormedField 𝕜] →
[inst_1 : SeminormedAddCommGroup E] →
{motive : NormedSpace 𝕜 E → Sort u} →
(t : NormedSpace 𝕜 E) →
([toModule : Module 𝕜 E] →
(norm_smul_le : ∀ (a : 𝕜) (b : E), ‖a • b‖ ≤ ‖a‖ * ‖b‖) →
... | null | false |
Ideal.stableFiltration_N | Mathlib.RingTheory.Filtration | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (I : Ideal R)
(N : Submodule R M) (i : ℕ), (I.stableFiltration N).N i = I ^ i • N | null | true |
CategoryTheory.Adjunction.conesIsoComponentHom._proof_1 | Mathlib.CategoryTheory.Adjunction.Limits | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : F ⊣ G) {J : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} J] {K : CategoryTheory.Functor J D}
(X : Cᵒᵖ) (t... | null | false |
AddConstMap._aux_Mathlib_Algebra_AddConstMap_Basic___unexpand_AddConstMap_1 | Mathlib.Algebra.AddConstMap.Basic | Lean.PrettyPrinter.Unexpander | null | false |
ENNReal.natCast_lt_top | Mathlib.Data.ENNReal.Basic | ∀ (n : ℕ), ↑n < ⊤ | null | true |
primorial_one | Mathlib.NumberTheory.Primorial | primorial 1 = 1 | null | true |
Nat.doubleFactorial.eq_3 | Mathlib.Data.Nat.Factorial.DoubleFactorial | ∀ (k : ℕ), k.succ.succ.doubleFactorial = (k + 2) * k.doubleFactorial | null | true |
UpperHalfPlane.instContinuousSMulSL2R | Mathlib.Analysis.Complex.UpperHalfPlane.ProperAction | ContinuousSMul (Matrix.SpecialLinearGroup (Fin 2) ℝ) UpperHalfPlane | The action of `SL(2, ℝ)` on `ℍ` is jointly continuous. | true |
ENormedAddMonoid.enorm_eq_zero | Mathlib.Analysis.Normed.Group.Defs | ∀ {E : Type u_8} {inst : TopologicalSpace E} [self : ENormedAddMonoid E] (x : E), ‖x‖ₑ = 0 ↔ x = 0 | null | true |
List.next_getLast_eq_head | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] (l : List α) (h : l ≠ []), l.Nodup → l.next (l.getLast h) ⋯ = l.head h | null | true |
_private.Init.Data.UInt.Bitwise.0.UInt32.shiftLeft_add._proof_1_2 | Init.Data.UInt.Bitwise | ∀ {b c : UInt32}, b.toNat < 32 → c.toNat < 32 → ¬b.toNat + c.toNat < 4294967296 → False | null | false |
Algebra.IsAlgebraic.algEquivEquivAlgHom._proof_2 | Mathlib.RingTheory.Algebraic.Basic | ∀ (K : Type u_2) (L : Type u_1) [inst : CommRing K] [inst_1 : IsDomain K] [inst_2 : Field L] [inst_3 : Algebra K L]
[inst_4 : Module.IsTorsionFree K L] [inst_5 : Algebra.IsAlgebraic K L],
Function.RightInverse (fun ϕ => AlgEquiv.ofBijective ϕ ⋯) fun ϕ => ↑ϕ | null | false |
Lean.Meta.Omega.OmegaConfig.mk | Init.Meta.Defs | Bool → Bool → Bool → Bool → Lean.Meta.Omega.OmegaConfig | null | true |
Std.ExtTreeMap.isSome_maxKey?_modify_eq_isSome | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{f : β → β}, (t.modify k f).maxKey?.isSome = t.maxKey?.isSome | null | true |
CategoryTheory.ULift.equivalence_functor | Mathlib.CategoryTheory.Category.ULift | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C],
CategoryTheory.ULift.equivalence.functor = CategoryTheory.ULift.upFunctor | null | true |
ContinuousLinearMap.flipMultilinear._proof_6 | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u_3} {ι : Type u_4} {E : ι → Type u_5} {G : Type u_1} {G' : Type u_2} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : SeminormedAddCommGroup G']
[i... | null | false |
_private.Mathlib.RingTheory.MvPolynomial.Symmetric.FundamentalTheorem.0.MvPolynomial.supDegree_monic_esymm._simp_1_2 | Mathlib.RingTheory.MvPolynomial.Symmetric.FundamentalTheorem | ∀ {α : Type u_1} {M : Type u_8} [inst : AddCommMonoid M] (s : Finset α) (f : α → M),
(∑ x ∈ s, fun₀ | x => f x) = Finsupp.indicator s fun x x_1 => f x | null | false |
Lean.ImportArtifacts.ofArray | Lean.Setup | Array System.FilePath → Lean.ImportArtifacts | null | true |
MonCat.of | Mathlib.Algebra.Category.MonCat.Basic | (M : Type u) → [Monoid M] → MonCat | Construct a bundled `MonCat` from the underlying type and typeclass. | true |
Std.DTreeMap.Raw.getKey!_diff_of_not_mem_right | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [inst : Inhabited α]
[Std.TransCmp cmp], t₁.WF → t₂.WF → ∀ {k : α}, k ∉ t₂ → (t₁ \ t₂).getKey! k = t₁.getKey! k | null | true |
CategoryTheory.HasShift.noConfusion | Mathlib.CategoryTheory.Shift.Basic | {P : Sort u_1} →
{C : Type u} →
{A : Type u_2} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : AddMonoid A} →
{t : CategoryTheory.HasShift C A} →
{C' : Type u} →
{A' : Type u_2} →
{inst' : CategoryTheory.Category.{v, u} C'} →
... | null | false |
StrictConcaveOn.lt_slope_of_hasDerivWithinAt | Mathlib.Analysis.Convex.Deriv | ∀ {S : Set ℝ} {f : ℝ → ℝ} {x y f' : ℝ},
StrictConcaveOn ℝ S f → x ∈ S → y ∈ S → x < y → HasDerivWithinAt f f' S y → f' < slope f x y | null | true |
Int16.toBitVec_div | Init.Data.SInt.Lemmas | ∀ {a b : Int16}, (a / b).toBitVec = a.toBitVec.sdiv b.toBitVec | null | true |
Filter.not_bddBelow_of_tendsto_atBot | Mathlib.Order.Filter.AtTopBot.Basic | ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder β] {l : Filter α} [l.NeBot] {f : α → β} [NoMinOrder β],
Filter.Tendsto f l Filter.atBot → ¬BddBelow (Set.range f) | null | true |
Finsupp.instSemigroupWithZero._proof_1 | Mathlib.Data.Finsupp.Pointwise | ∀ {α : Type u_1} {β : Type u_2} [inst : SemigroupWithZero β], Function.Injective DFunLike.coe | null | false |
Lean.Meta.Grind.Arith.isNatType | Lean.Meta.Tactic.Grind.Arith.Util | Lean.Expr → Bool | Returns `true` if `e` is of the form `Nat` | true |
entourageProd.match_1 | Mathlib.Topology.UniformSpace.Basic | {α : Type u_2} →
{β : Type u_1} →
(motive : (α × β) × α × β → Sort u_3) →
(x : (α × β) × α × β) → ((a₁ : α) → (b₁ : β) → (a₂ : α) → (b₂ : β) → motive ((a₁, b₁), a₂, b₂)) → motive x | null | false |
Lean.Elab.Term.withoutHeedElabAsElim | Lean.Elab.Term.TermElabM | {m : Type → Type u_1} → {α : Type} → [MonadFunctorT Lean.Elab.TermElabM m] → m α → m α | Execute `x` without heeding the `elab_as_elim` attribute. Useful when there is
no expected type (so `elabAppArgs` would fail), but expect that the user wants
to use such constants.
| true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree.0.WeierstrassCurve.natDegree_coeff_ΨSq_ofNat | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) (n : ℕ),
(W.ΨSq ↑n).natDegree ≤ n ^ 2 - 1 ∧ (W.ΨSq ↑n).coeff (n ^ 2 - 1) = ↑(↑n ^ 2) | null | true |
MeasureTheory.Measure.NullMeasurableSet.const_smul | Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E]
[FiniteDimensional ℝ E] {μ : MeasureTheory.Measure E} [μ.IsAddHaarMeasure] {s : Set E},
MeasureTheory.NullMeasurableSet s μ → ∀ (r : ℝ), MeasureTheory.NullMeasurableSet (r • s) μ | null | true |
CategoryTheory.Enriched.FunctorCategory.functorEnrichedCategory._proof_2 | Mathlib.CategoryTheory.Enriched.FunctorCategory | ∀ (V : Type u_6) [inst : CategoryTheory.Category.{u_5, u_6} V] [inst_1 : CategoryTheory.MonoidalCategory V]
(C : Type u_4) [inst_2 : CategoryTheory.Category.{u_2, u_4} C] (J : Type u_3)
[inst_3 : CategoryTheory.Category.{u_1, u_3} J] [inst_4 : CategoryTheory.EnrichedOrdinaryCategory V C]
[inst_5 :
∀ (F₁ F₂ : ... | null | false |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.assemble₃_eq_some_of_toBitVec._simp_1_9 | Init.Data.String.Decode | ∀ {n : ℕ} {x y : BitVec n}, (x = y) = (x.toNat = y.toNat) | null | false |
Lean.Lsp.RpcCallParams.mk._flat_ctor | Lean.Data.Lsp.Extra | Lean.Lsp.TextDocumentIdentifier → Lean.Lsp.Position → UInt64 → Lean.Name → Lean.Json → Lean.Lsp.RpcCallParams | null | false |
Int.tdiv_dvd_tdiv | Init.Data.Int.DivMod.Lemmas | ∀ {a b c : ℤ}, a ∣ b → b ∣ c → b.tdiv a ∣ c.tdiv a | null | true |
Std.Tactic.BVDecide.BVBinPred.ult | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | Std.Tactic.BVDecide.BVBinPred | Unsigned Less Than
| true |
_private.Lean.Meta.Basic.0.Lean.Meta.exposeRelevantUniverses._sparseCasesOn_1 | Lean.Meta.Basic | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((u : Lean.Level) → motive (Lean.Expr.sort u)) → (Nat.hasNotBit 24 t.ctorIdx → motive t) → motive t | null | false |
Std.DTreeMap.Raw.Const.forInUncurried_eq_forIn_toArray | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {δ : Type w} {m : Type w → Type w'} {β : Type v}
{t : Std.DTreeMap.Raw α (fun x => β) cmp} [inst : Monad m] [LawfulMonad m] {f : α × β → δ → m (ForInStep δ)}
{init : δ}, Std.DTreeMap.Raw.Const.forInUncurried f init t = forIn (Std.DTreeMap.Raw.Const.toArray t) init f | null | true |
GroupCone.mk.injEq | Mathlib.Algebra.Order.Group.Cone | ∀ {G : Type u_1} [inst : CommGroup G] (toSubmonoid : Submonoid G)
(eq_one_of_mem_of_inv_mem' : ∀ {a : G}, a ∈ toSubmonoid.carrier → a⁻¹ ∈ toSubmonoid.carrier → a = 1)
(toSubmonoid_1 : Submonoid G)
(eq_one_of_mem_of_inv_mem'_1 : ∀ {a : G}, a ∈ toSubmonoid_1.carrier → a⁻¹ ∈ toSubmonoid_1.carrier → a = 1),
({ toSu... | null | true |
IsAlgClosed.exists_root | Mathlib.FieldTheory.IsAlgClosed.Basic | ∀ {k : Type u} [inst : Field k] [IsAlgClosed k] (p : Polynomial k), p.degree ≠ 0 → ∃ x, p.IsRoot x | If `k` is algebraically closed, then every nonconstant polynomial has a root.
| true |
Set.BijOn.ncard_eq | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β} {t : Set β}, Set.BijOn f s t → s.ncard = t.ncard | null | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc.0.CategoryTheory.Limits._aux_Mathlib_CategoryTheory_Limits_Shapes_Pullback_Assoc___macroRules__private_Mathlib_CategoryTheory_Limits_Shapes_Pullback_Assoc_0_CategoryTheory_Limits_termF₂_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc | Lean.Macro | null | false |
YoungDiagram.transpose_eq_iff | Mathlib.Combinatorics.Young.YoungDiagram | ∀ {μ ν : YoungDiagram}, μ.transpose = ν.transpose ↔ μ = ν | null | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.getMatchEqCondForAux.handleEnumWithDefault.intersperseDefault | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums | Lean.InductiveVal →
Lean.Expr → List Lean.Level → List (ℕ × Lean.Expr) → ℕ → List (ℕ × Lean.Expr) → Lean.MetaM (List (ℕ × Lean.Expr)) | null | true |
CategoryTheory.IsHomLift.instIsHomLiftIdObj | Mathlib.CategoryTheory.FiberedCategory.HomLift | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₂} 𝒳] [inst_1 : CategoryTheory.Category.{v₂, u₁} 𝒮]
(p : CategoryTheory.Functor 𝒳 𝒮) (a : 𝒳),
p.IsHomLift (CategoryTheory.CategoryStruct.id (p.obj a)) (CategoryTheory.CategoryStruct.id a) | null | true |
_private.Mathlib.Data.Nat.Digits.Defs.0.Nat.ofDigits_inj_of_len_eq._simp_1_2 | Mathlib.Data.Nat.Digits.Defs | ∀ {G : Type u_1} [inst : Add G] [IsLeftCancelAdd G] (a : G) {b c : G}, (a + b = a + c) = (b = c) | null | false |
Nat.floor_sub_ofNat | Mathlib.Algebra.Order.Floor.Semiring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] [IsStrictOrderedRing R]
[inst_4 : Sub R] [OrderedSub R] [ExistsAddOfLE R] (a : R) (n : ℕ) [inst_7 : n.AtLeastTwo],
⌊a - OfNat.ofNat n⌋₊ = ⌊a⌋₊ - OfNat.ofNat n | null | true |
HahnSeries.single_zero_ratCast | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {Γ : Type u_1} {R : Type u_3} [inst : Zero Γ] [inst_1 : PartialOrder Γ] [inst_2 : Zero R] [inst_3 : RatCast R]
(q : ℚ), (HahnSeries.single 0) ↑q = ↑q | null | true |
WeierstrassCurve.Ψ₂Sq._proof_1 | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | (3 + 1).AtLeastTwo | null | false |
Aesop.SafeRulesResult.ctorElimType | Aesop.Search.Expansion | {motive : Aesop.SafeRulesResult → Sort u} → ℕ → Sort (max 1 u) | null | false |
Std.Rcc.pairwise_toList_le | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rcc α} [inst : LE α] [inst_1 : DecidableLE α] [LT α] [inst_3 : Std.PRange.UpwardEnumerable α]
[inst_4 : Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLE α]
[inst_6 : Std.Rxc.IsAlwaysFinite α], List.Pairwise (fun a b => a ≤ b) r.toList | null | true |
Vector.uset.congr_simp | Batteries.Data.Vector.Basic | ∀ {α : Type u_1} {n : ℕ} (xs xs_1 : Vector α n),
xs = xs_1 →
∀ (i i_1 : USize) (e_i : i = i_1) (v v_1 : α), v = v_1 → ∀ (h : i.toNat < n), xs.uset i v h = xs_1.uset i_1 v_1 ⋯ | null | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rio.toList_succ_eq_map._simp_1_10 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerable α]
[inst_2 : Std.PRange.InfinitelyUpwardEnumerable α] [Std.PRange.LinearlyUpwardEnumerable α] {a b : α},
Std.PRange.UpwardEnumerable.LT (Std.PRange.succ a) (Std.PRange.succ b) = Std.PRange.UpwardEnumerable.LT a b | null | false |
Std.Tactic.BVDecide.BVExpr.shiftLeft._override | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {m n : ℕ} → Std.Tactic.BVDecide.BVExpr m → Std.Tactic.BVDecide.BVExpr n → Std.Tactic.BVDecide.BVExpr m | null | false |
Batteries.Tactic._aux_Batteries_Tactic_Init___macroRules_Batteries_Tactic_tacticSplit_ands_1 | Batteries.Tactic.Init | Lean.Macro | null | false |
String.Slice.Pattern.Model.NoSuffixPatternModel.recOn | Init.Data.String.Lemmas.Pattern.Basic | {ρ : Type} →
{pat : ρ} →
[inst : String.Slice.Pattern.Model.PatternModel pat] →
{motive : String.Slice.Pattern.Model.NoSuffixPatternModel pat → Sort u} →
(t : String.Slice.Pattern.Model.NoSuffixPatternModel pat) →
((eq_empty :
∀ (s t : String),
String.Slic... | null | false |
Mathlib.Ineq.WithStrictness.casesOn | Mathlib.Tactic.LinearCombination.Lemmas | {motive : Mathlib.Ineq.WithStrictness → Sort u} →
(t : Mathlib.Ineq.WithStrictness) →
motive Mathlib.Ineq.WithStrictness.eq →
motive Mathlib.Ineq.WithStrictness.le →
((strict : Bool) → motive (Mathlib.Ineq.WithStrictness.lt strict)) → motive t | null | false |
ContinuousAddMonoidHom.instAddCommMonoid.eq_1 | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {A : Type u_2} {E : Type u_6} [inst : AddMonoid A] [inst_1 : TopologicalSpace A] [inst_2 : AddCommMonoid E]
[inst_3 : TopologicalSpace E] [inst_4 : ContinuousAdd E],
ContinuousAddMonoidHom.instAddCommMonoid =
{ add := fun f g => (ContinuousAddMonoidHom.add E).comp (f.prod g), add_assoc := ⋯,
toZero := C... | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Circle.0.Circle.angleDiff_nonneg._proof_1_2 | Mathlib.Analysis.SpecialFunctions.Complex.Circle | NormOneClass ℂ | null | false |
_private.Std.Http.Transport.0.Std.Http.Internal.Mock.SharedState._sizeOf_1 | Std.Http.Transport | Std.Http.Internal.Mock.SharedState✝ → ℕ | null | false |
CategoryTheory.Arrow.isIso_iff_isIso_of_isIso | Mathlib.CategoryTheory.Comma.Arrow | ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] {W X Y Z : T} {f : W ⟶ X} {g : Y ⟶ Z}
(sq : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk g) [CategoryTheory.IsIso sq],
CategoryTheory.IsIso f ↔ CategoryTheory.IsIso g | null | true |
CategoryTheory.CommGrp._sizeOf_inst | Mathlib.CategoryTheory.Monoidal.CommGrp_ | (C : Type u₁) →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.CartesianMonoidalCategory C} →
{inst_2 : CategoryTheory.BraidedCategory C} → [SizeOf C] → SizeOf (CategoryTheory.CommGrp C) | null | false |
List.dropSlice_eq_dropSliceTR | Batteries.Data.List.Basic | @List.dropSlice = @List.dropSliceTR | null | true |
Option.forM_map | Init.Data.Option.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_4} [inst : Monad m] [LawfulMonad m] (o : Option α) (g : α → β)
(f : β → m PUnit.{u_1 + 1}), forM (Option.map g o) f = forM o fun a => f (g a) | null | true |
CategoryTheory.Bicategory.Lan.CommuteWith.lanCompIso_inv | Mathlib.CategoryTheory.Bicategory.Kan.HasKan | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} (f : a ⟶ b) (g : a ⟶ c)
[inst_1 : CategoryTheory.Bicategory.HasLeftKanExtension f g] {x : B} (h : c ⟶ x)
[inst_2 : CategoryTheory.Bicategory.Lan.CommuteWith f g h],
(CategoryTheory.Bicategory.Lan.CommuteWith.lanCompIso f g h).inv =
(CategoryTheor... | null | true |
Nat.ceil_ofNat | Mathlib.Algebra.Order.Floor.Semiring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] [IsStrictOrderedRing R] (n : ℕ)
[inst_4 : n.AtLeastTwo], ⌈OfNat.ofNat n⌉₊ = OfNat.ofNat n | null | true |
_private.Init.System.FilePath.0.System.FilePath.posOfLastSep | Init.System.FilePath | (p : System.FilePath) → Option p.toString.Pos | null | true |
ModuleCat.CoextendScalars.distribMulAction._proof_4 | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : Ring S] (f : R →+* S) (M : Type u_3)
[inst_2 : AddCommMonoid M] [inst_3 : Module R M] (s : S)
(g h : ↑((ModuleCat.restrictScalars f).obj (ModuleCat.of S S)) →ₗ[R] M), s • (g + h) = s • g + s • h | null | false |
TopologicalSpace.NonemptyCompacts.instNontrivial | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] [Nontrivial α], Nontrivial (TopologicalSpace.NonemptyCompacts α) | null | true |
SimplexCategory.orderIsoOfIso._proof_1 | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {x y : SimplexCategory} (e : x ≅ y) (i : Fin (x.len + 1)),
(SimplexCategory.Hom.toOrderHom e.inv) ((SimplexCategory.Hom.toOrderHom e.hom) i) = i | null | false |
MulRingNormClass.mk | Mathlib.Algebra.Order.Hom.Basic | ∀ {F : Type u_7} {α : outParam (Type u_8)} {β : outParam (Type u_9)} [inst : NonAssocRing α] [inst_1 : Semiring β]
[inst_2 : PartialOrder β] [inst_3 : FunLike F α β] [toMulRingSeminormClass : MulRingSeminormClass F α β],
(∀ (f : F) {a : α}, f a = 0 → a = 0) → MulRingNormClass F α β | null | true |
CategoryTheory.SubmonoidFunctor._sizeOf_inst | Mathlib.CategoryTheory.Subfunctor.SubmonoidFunctor | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
(M : CategoryTheory.Functor C MonCat) → [SizeOf C] → SizeOf (CategoryTheory.SubmonoidFunctor M) | null | false |
Submonoid.LocalizationMap.isCancelMul | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : CommMonoid M] {S : Submonoid M} [inst_1 : CommMonoid N]
(f : S.LocalizationMap N) [IsCancelMul M], IsCancelMul N | null | true |
Fintype.truncRecEmptyOption | Mathlib.Data.Fintype.Option | {P : Type u → Sort v} →
({α β : Type u} → α ≃ β → P α → P β) →
P PEmpty.{u + 1} →
({α : Type u} → [Fintype α] → [DecidableEq α] → P α → P (Option α)) →
(α : Type u) → [Fintype α] → [DecidableEq α] → Trunc (P α) | A recursor principle for finite types, analogous to `Nat.rec`. It effectively says
that every `Fintype` is either `Empty` or `Option α`, up to an `Equiv`. | true |
Encodable.encode_prod_val | Mathlib.Logic.Encodable.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Encodable α] [inst_1 : Encodable β] (a : α) (b : β),
Encodable.encode (a, b) = Nat.pair (Encodable.encode a) (Encodable.encode b) | null | true |
Exists.snd | Mathlib.Logic.Basic | ∀ {b : Prop} {p : b → Prop} (h : Exists p), p ⋯ | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.String.0.String.reduceListChar._unsafe_rec | Lean.Meta.Tactic.Simp.BuiltinSimprocs.String | Lean.Expr → String → Lean.Meta.SimpM Lean.Meta.Simp.DStep | null | false |
Lean.Meta.Sym.ApplyResult.ctorElimType | Lean.Meta.Sym.Apply | {motive : Lean.Meta.Sym.ApplyResult → Sort u} → ℕ → Sort (max 1 u) | null | false |
Relator.RightTotal.rel_forall | Mathlib.Logic.Relator | ∀ {α : Sort u₁} {β : Sort u₂} {R : α → β → Prop},
Relator.RightTotal R →
Relator.LiftFun (Relator.LiftFun R fun x1 x2 => ∀ (a : x1), x2) (fun x1 x2 => ∀ (a : x1), x2)
(fun p => (i : α) → p i) fun q => ∀ (i : β), q i | null | true |
_private.Lean.Elab.Tactic.Grind.BuiltinTactic.0.Lean.Elab.Tactic.Grind.evalFinish._regBuiltin._private.Lean.Elab.Tactic.Grind.BuiltinTactic.0.Lean.Elab.Tactic.Grind.evalFinish_1 | Lean.Elab.Tactic.Grind.BuiltinTactic | IO Unit | null | false |
posMulMono_iff | Mathlib.Algebra.Order.GroupWithZero.Defs | ∀ (α : Type u_1) [inst : Mul α] [inst_1 : Zero α] [inst_2 : Preorder α],
PosMulMono α ↔ ∀ ⦃a : α⦄, 0 ≤ a → ∀ ⦃b c : α⦄, b ≤ c → a * b ≤ a * c | null | true |
Relation.ReflGen.rec | Mathlib.Logic.Relation | ∀ {α : Sort u_1} {r : α → α → Prop} {a : α} {motive : (a_1 : α) → Relation.ReflGen r a a_1 → Prop},
motive a ⋯ → (∀ {b : α} (a_1 : r a b), motive b ⋯) → ∀ {a_1 : α} (t : Relation.ReflGen r a a_1), motive a_1 t | null | false |
UniformEquiv.range_coe | Mathlib.Topology.UniformSpace.Equiv | ∀ {α : Type u} {β : Type u_1} [inst : UniformSpace α] [inst_1 : UniformSpace β] (h : α ≃ᵤ β), Set.range ⇑h = Set.univ | null | true |
CategoryTheory.typeEquiv._proof_2 | Mathlib.CategoryTheory.Sites.Types | ∀ (_α : Type u_1),
CategoryTheory.CategoryStruct.comp (TypeCat.ofHom fun f => (TypeCat.Hom.hom f) PUnit.unit)
(TypeCat.ofHom fun x => TypeCat.ofHom fun x_1 => x) =
CategoryTheory.CategoryStruct.id
((CategoryTheory.yoneda'.comp
((CategoryTheory.sheafToPresheaf CategoryTheory.typesGrothendie... | null | false |
Filter.HasBasis.prod | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} {β : Type u_2} {la : Filter α} {lb : Filter β} {ι : Type u_6} {ι' : Type u_7} {pa : ι → Prop}
{sa : ι → Set α} {pb : ι' → Prop} {sb : ι' → Set β},
la.HasBasis pa sa → lb.HasBasis pb sb → (la ×ˢ lb).HasBasis (fun i => pa i.1 ∧ pb i.2) fun i => sa i.1 ×ˢ sb i.2 | null | true |
_private.Mathlib.Algebra.Polynomial.CoeffMem.0.Polynomial.coeff_divModByMonicAux_mem_span_pow_mul_span._simp_1_4 | Mathlib.Algebra.Polynomial.CoeffMem | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, (p.degree = ⊥) = (p = 0) | null | false |
Function.Injective.sumElim | Mathlib.Data.Sum.Basic | ∀ {α : Type u} {β : Type v} {γ : Sort u_3} {f : α → γ} {g : β → γ},
Function.Injective f → Function.Injective g → (∀ (a : α) (b : β), f a ≠ g b) → Function.Injective (Sum.elim f g) | null | true |
_private.Mathlib.Data.Fin.SuccPred.0.Fin.cast_eq_cast._proof_1_6 | Mathlib.Data.Fin.SuccPred | ∀ {n m : ℕ} (h : n = m), Fin.cast h = cast ⋯ | null | false |
_private.Mathlib.Data.EReal.Operations.0.EReal.mul_bot_of_neg.match_1_1 | Mathlib.Data.EReal.Operations | ∀ (motive : (x : EReal) → x < 0 → Prop) (x : EReal) (x_1 : x < 0),
(∀ (x : ⊥ < 0), motive none x) →
(∀ (x : ℝ) (h : ↑x < 0), motive (some (some x)) h) → (∀ (h : ⊤ < 0), motive (some none) h) → motive x x_1 | null | false |
_private.Init.Data.String.Basic.0.String.Pos.Raw.isValid_iff_exists_append._simp_1_2 | Init.Data.String.Basic | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ ≤ i₂) = (i₁.byteIdx ≤ i₂.byteIdx) | null | false |
Turing.TM0to1.tr.eq_3 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} [inst : Inhabited Λ] (M : Turing.TM0.Machine Γ Λ) (a : Γ) (q : Λ),
Turing.TM0to1.tr M (Turing.TM0to1.Λ'.act (Turing.TM0.Stmt.write a) q) =
Turing.TM1.Stmt.write (fun x x_1 => a) (Turing.TM1.Stmt.goto fun x x_1 => Turing.TM0to1.Λ'.normal q) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.