name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_srem._proof_1_1 | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} {x : BitVec w}, x.toInt < 0 → 0 ≤ x.toInt → False | false |
Lean.Compiler.LCNF.specExtension | Lean.Compiler.LCNF.SpecInfo | Lean.SimplePersistentEnvExtension Lean.Compiler.LCNF.SpecEntry Lean.Compiler.LCNF.SpecState | true |
Bipointed.swapEquiv_functor_map_toFun | Mathlib.CategoryTheory.Category.Bipointed | ∀ {X Y : Bipointed} (f : X ⟶ Y) (a : X.X), (Bipointed.swapEquiv.functor.map f).toFun a = f.toFun a | true |
Batteries.RBNode.foldr.match_1 | Batteries.Data.RBMap.Basic | {α : Type u_1} →
{σ : Sort u_3} →
(motive : Batteries.RBNode α → σ → Sort u_2) →
(x : Batteries.RBNode α) →
(x_1 : σ) →
((b : σ) → motive Batteries.RBNode.nil b) →
((c : Batteries.RBColor) →
(l : Batteries.RBNode α) →
(v : α) → (r : Batteries.RBNode α) → (b : σ) → motive (Batteries.RBNode.node c l v r) b) →
motive x x_1 | false |
Nat.greatestFib.eq_1 | Mathlib.Data.Nat.Fib.Zeckendorf | ∀ (n : ℕ), n.greatestFib = Nat.findGreatest (fun k => Nat.fib k ≤ n) (n + 1) | true |
_private.Lean.Elab.Structure.0.Lean.Elab.Command.Structure.getFieldDefaultValue? | Lean.Elab.Structure | Lean.Name → Array Lean.Expr → Lean.Name → Lean.Elab.Command.Structure.StructElabM✝ (Option Lean.Expr) | true |
surjOn_Icc_of_monotone_surjective | Mathlib.Order.Interval.Set.SurjOn | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : PartialOrder β] {f : α → β},
Monotone f → Function.Surjective f → ∀ {a b : α}, a ≤ b → Set.SurjOn f (Set.Icc a b) (Set.Icc (f a) (f b)) | true |
MeasureTheory.JordanDecomposition.zero_posPart | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | ∀ {α : Type u_1} [inst : MeasurableSpace α], MeasureTheory.JordanDecomposition.posPart 0 = 0 | true |
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem._proof_1_14 | Mathlib.Data.List.Triplewise | ∀ {α : Type u_1} (tail : List α) (i j k : ℕ), i < j → j < k → k < tail.length + 1 → i < tail.length | false |
MapClusterPt.prodMap | Mathlib.Topology.Constructions | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {α : Type u_5} {β : Type u_6}
{f : α → X} {g : β → Y} {la : Filter α} {lb : Filter β} {x : X} {y : Y},
MapClusterPt x la f → MapClusterPt y lb g → MapClusterPt (x, y) (la ×ˢ lb) (Prod.map f g) | true |
Std.Tactic.BVDecide.Normalize.BitVec.zero_ult' | Std.Tactic.BVDecide.Normalize.BitVec | ∀ {w : ℕ} (a : BitVec w), (0#w).ult a = !a == 0#w | true |
GroupExtension.Splitting.semidirectProductMulEquiv | Mathlib.GroupTheory.GroupExtension.Basic | {N : Type u_1} →
{G : Type u_2} →
[inst : Group N] →
[inst_1 : Group G] →
{E : Type u_3} → [inst_2 : Group E] → {S : GroupExtension N E G} → (s : S.Splitting) → N ⋊[s.conjAct] G ≃* E | true |
CompTriple.IsId.rec | Mathlib.Logic.Function.CompTypeclasses | {M : Type u_1} →
{σ : M → M} →
{motive : CompTriple.IsId σ → Sort u} → ((eq_id : σ = id) → motive ⋯) → (t : CompTriple.IsId σ) → motive t | false |
_private.Lean.Data.Array.0.Array.mask.match_1 | Lean.Data.Array | {α : Type u_1} →
(motive : Option (α × Subarray α) → Sort u_2) →
(x : Option (α × Subarray α)) →
(Unit → motive none) → ((x : α) → (s' : Subarray α) → motive (some (x, s'))) → motive x | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeftConst.go._unary._proof_3 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (input : aig.RefVec w)
(distance curr : ℕ) (hcurr : curr ≤ w) (s : aig.RefVec curr) (hidx : curr < w) (hdist : ¬curr < distance),
InvImage (fun x1 x2 => x1 < x2)
(fun x => PSigma.casesOn x fun curr hcurr => PSigma.casesOn hcurr fun hcurr s => w - curr)
⟨curr + 1, ⟨⋯, s.push (input.get (curr - distance) ⋯)⟩⟩ ⟨curr, ⟨hcurr, s⟩⟩ | false |
neg_add_cancel_comm_assoc | Mathlib.Algebra.Group.Defs | ∀ {G : Type u_1} [inst : AddCommGroup G] (a b : G), -a + (b + a) = b | true |
Set.countable_setOf_finite_subset | Mathlib.Data.Set.Countable | ∀ {α : Type u} {s : Set α}, s.Countable → {t | t.Finite ∧ t ⊆ s}.Countable | true |
CategoryTheory.Pi.μ_def | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type w₁} {C : I → Type u₁} [inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] (i : I) (X Y : (i : I) → C i),
CategoryTheory.Functor.LaxMonoidal.μ (CategoryTheory.Pi.eval C i) X Y =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorObj (X i) (Y i)) | true |
IntervalIntegrable.mono_set | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {ε : Type u_3} [inst : TopologicalSpace ε] [inst_1 : ENormedAddMonoid ε] {f : ℝ → ε} {a b c d : ℝ}
{μ : MeasureTheory.Measure ℝ} [TopologicalSpace.PseudoMetrizableSpace ε],
IntervalIntegrable f μ a b → Set.uIcc c d ⊆ Set.uIcc a b → IntervalIntegrable f μ c d | true |
Set.restrict_ite_compl | Mathlib.Data.Set.Restrict | ∀ {α : Type u_1} {β : Type u_2} (f g : α → β) (s : Set α) [inst : (x : α) → Decidable (x ∈ s)],
(sᶜ.restrict fun a => if a ∈ s then f a else g a) = sᶜ.restrict g | true |
CategoryTheory.LocalizerMorphism.IsRightDerivabilityStructure.Constructor.fromRightResolution_map | Mathlib.CategoryTheory.Localization.DerivabilityStructure.Constructor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} (Φ : CategoryTheory.LocalizerMorphism W₁ W₂) {D : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, u_3} D] (L : CategoryTheory.Functor C₂ D) [inst_3 : L.IsLocalization W₂]
{X₂ : C₂} {X₃ : D} (y : L.obj X₂ ⟶ X₃) {R R' : Φ.RightResolution X₂} (φ : R ⟶ R'),
(CategoryTheory.LocalizerMorphism.IsRightDerivabilityStructure.Constructor.fromRightResolution Φ L y).map φ =
CategoryTheory.CostructuredArrow.homMk (CategoryTheory.StructuredArrow.homMk φ.f ⋯) ⋯ | true |
descPochhammer_eval_eq_descFactorial | Mathlib.RingTheory.Polynomial.Pochhammer | ∀ (R : Type u) [inst : Ring R] (n k : ℕ), Polynomial.eval (↑n) (descPochhammer R k) = ↑(n.descFactorial k) | true |
ONote.NFBelow | Mathlib.SetTheory.Ordinal.Notation | ONote → Ordinal.{0} → Prop | true |
Units.instDecidableEq | Mathlib.Algebra.Group.Units.Defs | {α : Type u} → [inst : Monoid α] → [DecidableEq α] → DecidableEq αˣ | true |
_private.Mathlib.Analysis.Complex.Convex.0.Complex.instPathConnectedSpaceUnits._simp_3 | Mathlib.Analysis.Complex.Convex | ∀ {a b : Prop}, (¬(a ∧ b)) = (¬a ∨ ¬b) | false |
OneHomClass | Mathlib.Algebra.Group.Hom.Defs | (F : Type u_10) → (M : outParam (Type u_11)) → (N : outParam (Type u_12)) → [One M] → [One N] → [FunLike F M N] → Prop | true |
Std.Do.«term_∧ₚ_» | Std.Do.PostCond | Lean.TrailingParserDescr | true |
R0Space.closure_singleton | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] [R0Space X] (x : X), closure {x} = (nhds x).ker | true |
Fin.val_natCast | Mathlib.Data.Fin.Basic | ∀ (a n : ℕ) [inst : NeZero n], ↑↑a = a % n | true |
OneHom.coe_id | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_10} [inst : One M], ⇑(OneHom.id M) = id | true |
Std.DHashMap.Const.getKey!_unitOfList_of_contains_eq_false | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [EquivBEq α] [LawfulHashable α] [inst : Inhabited α] {l : List α} {k : α},
l.contains k = false → (Std.DHashMap.Const.unitOfList l).getKey! k = default | true |
Finset.SupIndep.le_sup_iff | Mathlib.Order.SupIndep | ∀ {α : Type u_1} {ι : Type u_3} [inst : Lattice α] [inst_1 : OrderBot α] {s t : Finset ι} {f : ι → α} {i : ι},
s.SupIndep f → t ⊆ s → i ∈ s → (∀ (i : ι), f i ≠ ⊥) → (f i ≤ t.sup f ↔ i ∈ t) | true |
_private.Mathlib.Dynamics.TopologicalEntropy.CoverEntropy.0.Dynamics.nonempty_inter_of_coverMincard._simp_1_1 | Mathlib.Dynamics.TopologicalEntropy.CoverEntropy | ∀ {α : Type u} {s t : Set α} (x : α), (x ∈ s \ t) = (x ∈ s ∧ x ∉ t) | false |
_private.Mathlib.MeasureTheory.Integral.Bochner.L1.0.MeasureTheory.SimpleFunc.integral_mono_measure._simp_1_1 | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {f : MeasureTheory.SimpleFunc α β} {p : β → Prop},
(∀ y ∈ f.range, p y) = ∀ (x : α), p (f x) | false |
_private.Mathlib.RingTheory.PowerSeries.Derivative.0.PowerSeries.derivativeFun_coe_mul_coe | Mathlib.RingTheory.PowerSeries.Derivative | ∀ {R : Type u_1} [inst : CommSemiring R] (f g : Polynomial R),
(↑f * ↑g).derivativeFun = ↑f * ↑(Polynomial.derivative g) + ↑g * ↑(Polynomial.derivative f) | true |
TensorProduct.LieModule.map._proof_1 | Mathlib.Algebra.Lie.TensorProduct | ∀ {R : Type u_3} [inst : CommRing R] {L : Type u_6} {M : Type u_5} {N : Type u_4} {P : Type u_1} {Q : Type u_2}
[inst_1 : LieRing L] [inst_2 : LieAlgebra R L] [inst_3 : AddCommGroup M] [inst_4 : Module R M]
[inst_5 : LieRingModule L M] [inst_6 : LieModule R L M] [inst_7 : AddCommGroup N] [inst_8 : Module R N]
[inst_9 : LieRingModule L N] [inst_10 : LieModule R L N] [inst_11 : AddCommGroup P] [inst_12 : Module R P]
[inst_13 : LieRingModule L P] [inst_14 : LieModule R L P] [inst_15 : AddCommGroup Q] [inst_16 : Module R Q]
[inst_17 : LieRingModule L Q] [inst_18 : LieModule R L Q] (f : M →ₗ⁅R,L⁆ P) (g : N →ₗ⁅R,L⁆ Q) {x : L}
{t : TensorProduct R M N}, (TensorProduct.map ↑f ↑g).toFun ⁅x, t⁆ = ⁅x, (TensorProduct.map ↑f ↑g).toFun t⁆ | false |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.PartialMatch.isValidForSlice | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {pat s : String.Slice},
pat.isEmpty = false →
∀ {pos : String.Pos.Raw},
String.Slice.Pattern.Model.ForwardSliceSearcher.PartialMatch✝ pat.copy.toByteArray s.copy.toByteArray
pat.utf8ByteSize pos.byteIdx →
String.Pos.Raw.IsValidForSlice s (pos.unoffsetBy pat.rawEndPos) → String.Pos.Raw.IsValidForSlice s pos | true |
FreeGroup.mulEquivIntOfUnique._proof_2 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u_1} [inst : Unique α] (x : Multiplicative ℤ),
(⇑Multiplicative.ofAdd ∘ ⇑FreeGroup.equivIntOfUnique) ((⇑FreeGroup.equivIntOfUnique.symm ∘ ⇑Multiplicative.toAdd) x) =
x | false |
ZeroHom.mk.noConfusion | Mathlib.Algebra.Group.Hom.Defs | {M : Type u_10} →
{N : Type u_11} →
{inst : Zero M} →
{inst_1 : Zero N} →
{P : Sort u} →
{toFun : M → N} →
{map_zero' : toFun 0 = 0} →
{toFun' : M → N} →
{map_zero'' : toFun' 0 = 0} →
{ toFun := toFun, map_zero' := map_zero' } = { toFun := toFun', map_zero' := map_zero'' } →
(toFun ≍ toFun' → P) → P | false |
_private.Init.Data.SInt.Lemmas.0.Int8.le_iff_lt_or_eq._simp_1_3 | Init.Data.SInt.Lemmas | ∀ {x y : Int8}, (x < y) = (x.toInt < y.toInt) | false |
_private.Batteries.Data.UnionFind.Basic.0.Batteries.UnionFind.findAux.match_1.splitter | Batteries.Data.UnionFind.Basic | (self : Batteries.UnionFind) →
(motive : Batteries.UnionFind.FindAux self.size → Sort u_1) →
(x : Batteries.UnionFind.FindAux self.size) →
((arr₁ : Array Batteries.UFNode) →
(root : Fin self.size) → (H : arr₁.size = self.size) → motive { s := arr₁, root := root, size_eq := H }) →
motive x | true |
CategoryTheory.WithInitial.equivComma._proof_12 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_4, u_2} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} D]
{X Y : CategoryTheory.Comma (CategoryTheory.Functor.const C) (CategoryTheory.Functor.id (CategoryTheory.Functor C D))}
(f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(({ obj := CategoryTheory.WithInitial.ofCommaObject,
map := fun {X Y} => CategoryTheory.WithInitial.ofCommaMorphism, map_id := ⋯, map_comp := ⋯ }.comp
{ obj := CategoryTheory.WithInitial.mkCommaObject,
map := fun {X Y} => CategoryTheory.WithInitial.mkCommaMorphism, map_id := ⋯, map_comp := ⋯ }).map
f)
((fun F =>
CategoryTheory.Iso.refl
(({ obj := CategoryTheory.WithInitial.ofCommaObject,
map := fun {X Y} => CategoryTheory.WithInitial.ofCommaMorphism, map_id := ⋯,
map_comp := ⋯ }.comp
{ obj := CategoryTheory.WithInitial.mkCommaObject,
map := fun {X Y} => CategoryTheory.WithInitial.mkCommaMorphism, map_id := ⋯, map_comp := ⋯ }).obj
F))
Y).hom =
CategoryTheory.CategoryStruct.comp
((fun F =>
CategoryTheory.Iso.refl
(({ obj := CategoryTheory.WithInitial.ofCommaObject,
map := fun {X Y} => CategoryTheory.WithInitial.ofCommaMorphism, map_id := ⋯,
map_comp := ⋯ }.comp
{ obj := CategoryTheory.WithInitial.mkCommaObject,
map := fun {X Y} => CategoryTheory.WithInitial.mkCommaMorphism, map_id := ⋯, map_comp := ⋯ }).obj
F))
X).hom
((CategoryTheory.Functor.id
(CategoryTheory.Comma (CategoryTheory.Functor.const C)
(CategoryTheory.Functor.id (CategoryTheory.Functor C D)))).map
f) | false |
RatFunc.wrapped._@.Mathlib.FieldTheory.RatFunc.Basic.870781102._hygCtx._hyg.2 | Mathlib.FieldTheory.RatFunc.Basic | Subtype (Eq @RatFunc.definition✝) | false |
Aesop.RuleBuilderOptions.indexingMode? | Aesop.Builder.Basic | Aesop.RuleBuilderOptions → Option Aesop.IndexingMode | true |
Units.inv_mul_of_eq | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α] {u : αˣ} {a : α}, ↑u = a → ↑u⁻¹ * a = 1 | true |
Nonneg.mk_smul | Mathlib.Algebra.Order.Nonneg.Module | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : SMul R S] (a : R) (ha : 0 ≤ a)
(x : S), ⟨a, ha⟩ • x = a • x | true |
Set.preimage_singleton_eq_empty | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {y : β}, f ⁻¹' {y} = ∅ ↔ y ∉ Set.range f | true |
Set.isSimpleOrder_Iic_iff_isAtom | Mathlib.Order.Atoms | ∀ {α : Type u_2} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, IsSimpleOrder ↑(Set.Iic a) ↔ IsAtom a | true |
CategoryTheory.MonoidalCategory.fullSubcategory._proof_11 | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(P : CategoryTheory.ObjectProperty C)
(tensorObj : ∀ (X Y : C), P X → P Y → P (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y))
{X₁ X₂ X₃ Y₁ Y₂ Y₃ : P.FullSubcategory} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (f₃ : X₃ ⟶ Y₃),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.ObjectProperty.homMk
(CategoryTheory.MonoidalCategoryStruct.tensorHom
(CategoryTheory.ObjectProperty.homMk (CategoryTheory.MonoidalCategoryStruct.tensorHom f₁.hom f₂.hom)).hom
f₃.hom))
(P.fullyFaithfulι.preimageIso (CategoryTheory.MonoidalCategoryStruct.associator Y₁.obj Y₂.obj Y₃.obj)).hom =
CategoryTheory.CategoryStruct.comp
(P.fullyFaithfulι.preimageIso (CategoryTheory.MonoidalCategoryStruct.associator X₁.obj X₂.obj X₃.obj)).hom
(CategoryTheory.ObjectProperty.homMk
(CategoryTheory.MonoidalCategoryStruct.tensorHom f₁.hom
(CategoryTheory.ObjectProperty.homMk (CategoryTheory.MonoidalCategoryStruct.tensorHom f₂.hom f₃.hom)).hom)) | false |
_private.Mathlib.RingTheory.MvPowerSeries.Rename.0.MvPowerSeries.killCompl_X._simp_1_1 | Mathlib.RingTheory.MvPowerSeries.Rename | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : Zero M] (f : α ↪ β) (a : α) (m : M),
(fun₀ | f a => m) = Finsupp.embDomain f fun₀ | a => m | false |
Lean.Elab.Tactic.Conv.PatternMatchState.rec | Lean.Elab.Tactic.Conv.Pattern | {motive : Lean.Elab.Tactic.Conv.PatternMatchState → Sort u} →
((subgoals : Array Lean.MVarId) → motive (Lean.Elab.Tactic.Conv.PatternMatchState.all subgoals)) →
((subgoals : Array (ℕ × Lean.MVarId)) →
(idx : ℕ) →
(remaining : List (ℕ × ℕ)) → motive (Lean.Elab.Tactic.Conv.PatternMatchState.occs subgoals idx remaining)) →
(t : Lean.Elab.Tactic.Conv.PatternMatchState) → motive t | false |
OrderMonoidHom.inrₗ | Mathlib.Algebra.Order.Monoid.Lex | (α : Type u_1) →
(β : Type u_2) →
[inst : Monoid α] → [inst_1 : PartialOrder α] → [inst_2 : Monoid β] → [inst_3 : Preorder β] → β →*o Lex (α × β) | true |
selfAdjoint.instField._proof_12 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : Field R] [inst_1 : StarRing R] (x : ℤ), ↑↑x = ↑↑x | false |
WithBot.map_zero | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : Zero α] {β : Type u_1} (f : α → β), WithBot.map f 0 = ↑(f 0) | true |
ZeroHom.instModule._proof_1 | Mathlib.Algebra.Module.Hom | ∀ {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : Semiring R] [inst_1 : AddMonoid A] [inst_2 : AddCommMonoid B]
[inst_3 : Module R B] (r : R), r • 0 = 0 | false |
_private.Init.Data.Range.Polymorphic.IntLemmas.0.Int.map_add_toList_rcc._proof_1_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {n k : ℤ}, ¬n + 1 + k = n + k + 1 → False | false |
ConvexOn.lt_left_of_right_lt' | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommMonoid β] [inst_4 : LinearOrder β] [IsOrderedCancelAddMonoid β] [inst_6 : Module 𝕜 E]
[inst_7 : Module 𝕜 β] [PosSMulStrictMono 𝕜 β] {s : Set E} {f : E → β},
ConvexOn 𝕜 s f →
∀ {x y : E},
x ∈ s → y ∈ s → ∀ {a b : 𝕜}, 0 < a → 0 < b → a + b = 1 → f y < f (a • x + b • y) → f (a • x + b • y) < f x | true |
MonoidAlgebra.mapAlgHom_apply | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ {R : Type u_1} {A : Type u_4} {B : Type u_5} {M : Type u_7} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : Monoid M] (f : A →ₐ[R] B)
(x : MonoidAlgebra A M) (m : M), ((MonoidAlgebra.mapAlgHom M f) x) m = f (x m) | true |
Except.ctorIdx | Init.Prelude | {ε : Type u} → {α : Type v} → Except ε α → ℕ | false |
_private.Mathlib.Algebra.Divisibility.Prod.0.pi_dvd_iff._simp_1_2 | Mathlib.Algebra.Divisibility.Prod | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x | false |
AlgebraicGeometry.Scheme.basicOpen_le | Mathlib.AlgebraicGeometry.Scheme | ∀ (X : AlgebraicGeometry.Scheme) {U : X.Opens} (f : ↑(X.presheaf.obj (Opposite.op U))), X.basicOpen f ≤ U | true |
CategoryTheory.Precoverage.mem_coverings_of_isIso | Mathlib.CategoryTheory.Sites.Precoverage | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {J : CategoryTheory.Precoverage C} [self : J.HasIsos] {S T : C}
(f : S ⟶ T) [CategoryTheory.IsIso f], CategoryTheory.Presieve.singleton f ∈ J.coverings T | true |
Primrec.PrimrecBounded | Mathlib.Computability.Primrec.Basic | {α : Type u_1} → {β : Type u_2} → [Primcodable α] → [Primcodable β] → (α → β) → Prop | true |
Order.Ideal.toLowerSet_injective | Mathlib.Order.Ideal | ∀ {P : Type u_1} [inst : LE P], Function.Injective Order.Ideal.toLowerSet | true |
SimpleGraph.cliqueFinset_eq_empty_iff | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {G : SimpleGraph α} [inst : Fintype α] [inst_1 : DecidableEq α] [inst_2 : DecidableRel G.Adj] {n : ℕ},
G.cliqueFinset n = ∅ ↔ G.CliqueFree n | true |
LieAlgebra.IsExtension.range_eq_top | Mathlib.Algebra.Lie.Extension | ∀ {R : Type u_1} {N : Type u_2} {L : Type u_3} {M : Type u_4} {inst : CommRing R} {inst_1 : LieRing L}
{inst_2 : LieAlgebra R L} {inst_3 : LieRing N} {inst_4 : LieAlgebra R N} {inst_5 : LieRing M}
{inst_6 : LieAlgebra R M} (i : N →ₗ⁅R⁆ L) {p : L →ₗ⁅R⁆ M} [self : LieAlgebra.IsExtension i p], p.range = ⊤ | true |
CategoryTheory.OverPresheafAux.restrictedYoneda._proof_3 | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (A : CategoryTheory.Functor Cᵒᵖ (Type u_2))
{X Y : CategoryTheory.Over A} (ε : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id (CategoryTheory.Functor Cᵒᵖ (Type u_2))).map ε.left)
Y.hom =
CategoryTheory.CategoryStruct.comp X.hom ((CategoryTheory.Functor.fromPUnit A).map ε.right) | false |
Finset.Colex.toColex_sdiff_lt_toColex_sdiff' | Mathlib.Combinatorics.Colex | ∀ {α : Type u_1} [inst : PartialOrder α] {s t : Finset α} [inst_1 : DecidableEq α],
toColex (s \ t) < toColex (t \ s) ↔ toColex s < toColex t | true |
Lean.Parser.ParserResolution.alias | Lean.Parser.Extension | Lean.Parser.ParserAliasValue → Lean.Parser.ParserResolution | true |
HasSubset.noConfusion | Init.Core | {P : Sort u_1} →
{α : Type u} →
{t : HasSubset α} → {α' : Type u} → {t' : HasSubset α'} → α = α' → t ≍ t' → HasSubset.noConfusionType P t t' | false |
_private.Lean.Meta.LazyDiscrTree.0.Lean.Meta.LazyDiscrTree.blacklistInsertion.match_1 | Lean.Meta.LazyDiscrTree | (motive : Lean.Name → Sort u_1) →
(declName : Lean.Name) → ((pre : Lean.Name) → motive (pre.str "inj")) → ((x : Lean.Name) → motive x) → motive declName | false |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.LetValue.updateArgsImp | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.LetValue pu → Array (Lean.Compiler.LCNF.Arg pu) → Lean.Compiler.LCNF.LetValue pu | true |
CategoryTheory.IsDiscrete.sum | Mathlib.CategoryTheory.Discrete.SumsProducts | ∀ (C : Type u_1) (C' : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C'] [CategoryTheory.IsDiscrete C] [CategoryTheory.IsDiscrete C'],
CategoryTheory.IsDiscrete (C ⊕ C') | true |
USize.toNat_sub_of_le | Init.Data.UInt.Lemmas | ∀ (a b : USize), b ≤ a → (a - b).toNat = a.toNat - b.toNat | true |
Lean.Compiler.CSimp.replaceConstant | Lean.Compiler.CSimpAttr | Lean.Environment → Lean.Expr → Lean.CoreM Lean.Expr | true |
_private.Init.Data.Array.BinSearch.0.Array.binSearchAux._proof_3 | Init.Data.Array.BinSearch | ∀ {α : Type u_1} (as : Array α) (lo : Fin (as.size + 1)) (hi : Fin as.size),
↑lo ≤ ↑hi → ¬(↑lo + ↑hi) / 2 < as.size → False | false |
PNat.XgcdType.flip_b | Mathlib.Data.PNat.Xgcd | ∀ (u : PNat.XgcdType), u.flip.b = u.a | true |
Lean.Lsp.LeanIleanInfoParams.recOn | Lean.Data.Lsp.Internal | {motive : Lean.Lsp.LeanIleanInfoParams → Sort u} →
(t : Lean.Lsp.LeanIleanInfoParams) →
((version : ℕ) →
(references : Lean.Lsp.ModuleRefs) →
(decls : Lean.Lsp.Decls) → motive { version := version, references := references, decls := decls }) →
motive t | false |
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.Poly.combine_k_eq_combine._simp_1_8 | Init.Grind.Ring.CommSolver | ∀ (m₁ m₂ : Lean.Grind.CommRing.Mon), m₁.grevlex m₂ = m₁.grevlex_k m₂ | false |
Complex.isOpen_im_lt_EReal | Mathlib.Analysis.Complex.HalfPlane | ∀ (x : EReal), IsOpen {z | ↑z.im < x} | true |
CategoryTheory.Bundled.mk.noConfusion | Mathlib.CategoryTheory.ConcreteCategory.Bundled | {c : Type u → Type v} →
{P : Sort u_1} →
{α : Type u} →
{str : autoParam (c α) CategoryTheory.Bundled.str._autoParam} →
{α' : Type u} →
{str' : autoParam (c α') CategoryTheory.Bundled.str._autoParam} →
{ α := α, str := str } = { α := α', str := str' } → (α = α' → str ≍ str' → P) → P | false |
Std.ExtDTreeMap.size_le_size_erase | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{k : α}, t.size ≤ (t.erase k).size + 1 | true |
_private.Mathlib.Algebra.Homology.ExactSequenceFour.0.CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles._proof_8 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {n : ℕ} (k : ℕ) (hk : autoParam (k ≤ n) CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles._auto_1),
⟨k, ⋯⟩ ≤ ⟨k + 1, ⋯⟩ | false |
riemannZeta.eq_1 | Mathlib.NumberTheory.LSeries.RiemannZeta | riemannZeta = HurwitzZeta.hurwitzZetaEven 0 | true |
CategoryTheory.ProjectivePresentation.noConfusionType | Mathlib.CategoryTheory.Preadditive.Projective.Basic | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} →
CategoryTheory.ProjectivePresentation X →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →
{X' : C'} → CategoryTheory.ProjectivePresentation X' → Sort u_1 | false |
_private.Mathlib.MeasureTheory.Measure.HasOuterApproxClosed.0.MeasureTheory.measure_of_cont_bdd_of_tendsto_filter_indicator._simp_1_1 | Mathlib.MeasureTheory.Measure.HasOuterApproxClosed | ∀ {α : Type u_1} {m : MeasurableSpace α}, MeasurableSet Set.univ = True | false |
Filter.comk.congr_simp | Mathlib.Order.Filter.Basic | ∀ {α : Type u_1} (p p_1 : Set α → Prop) (e_p : p = p_1) (he : p ∅) (hmono : ∀ (t : Set α), p t → ∀ s ⊆ t, p s)
(hunion : ∀ (s : Set α), p s → ∀ (t : Set α), p t → p (s ∪ t)), Filter.comk p he hmono hunion = Filter.comk p_1 ⋯ ⋯ ⋯ | true |
CategoryTheory.Pretriangulated.Triangle.epi₃ | Mathlib.CategoryTheory.Triangulated.Pretriangulated | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [hC : CategoryTheory.Pretriangulated C],
∀ T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles, T.mor₁ = 0 → CategoryTheory.Epi T.mor₃ | true |
AddSemigroupIdeal.fg_iff | Mathlib.Algebra.Group.Ideal | ∀ {M : Type u_1} [inst : Add M] {I : AddSemigroupIdeal M}, I.FG ↔ ∃ s, I = AddSemigroupIdeal.closure ↑s | true |
Std.ExtTreeMap.isEmpty_eq_size_beq_zero | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp}, t.isEmpty = (t.size == 0) | true |
NormedAddGroupHom.incl._proof_3 | Mathlib.Analysis.Normed.Group.Hom | ∀ {V : Type u_1} [inst : SeminormedAddCommGroup V] (s : AddSubgroup V), ∃ C, ∀ (v : ↥s), ‖↑v‖ ≤ C * ‖v‖ | false |
Part.Mem | Mathlib.Data.Part | {α : Type u_1} → Part α → α → Prop | true |
Lean.Server.Watchdog.WorkerEvent.casesOn | Lean.Server.Watchdog | {motive : Lean.Server.Watchdog.WorkerEvent → Sort u} →
(t : Lean.Server.Watchdog.WorkerEvent) →
motive Lean.Server.Watchdog.WorkerEvent.terminated →
motive Lean.Server.Watchdog.WorkerEvent.importsChanged →
((exitCode : UInt32) → motive (Lean.Server.Watchdog.WorkerEvent.crashed exitCode)) →
((e : IO.Error) → motive (Lean.Server.Watchdog.WorkerEvent.ioError e)) → motive t | false |
Acc.ndrec | Init.WF | {α : Sort u2} →
{r : α → α → Prop} →
{C : α → Sort u1} →
((x : α) → (∀ (y : α), r y x → Acc r y) → ((y : α) → r y x → C y) → C x) → {a : α} → Acc r a → C a | true |
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.MkNameM | Lean.Elab.DeclNameGen | Type → Type | true |
Std.DTreeMap.Const.get!_modify_self | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} {k : α}
[inst : Inhabited β] {f : β → β},
Std.DTreeMap.Const.get! (Std.DTreeMap.Const.modify t k f) k = (Option.map f (Std.DTreeMap.Const.get? t k)).get! | true |
Prod.instCoheytingAlgebra._proof_2 | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CoheytingAlgebra α] [inst_1 : CoheytingAlgebra β] (a : α × β), ⊤ \ a = ￢a | false |
SSet.StrictSegal.ofIsStrictSegal._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | ∀ (X : SSet) [inst : X.IsStrictSegal] (n : ℕ), (Equiv.ofBijective (X.spine n) ⋯).invFun ∘ X.spine n = id | false |
CoalgHom.mk._flat_ctor | Mathlib.RingTheory.Coalgebra.Hom | {R : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid A] →
[inst_2 : Module R A] →
[inst_3 : AddCommMonoid B] →
[inst_4 : Module R B] →
[inst_5 : CoalgebraStruct R A] →
[inst_6 : CoalgebraStruct R B] →
(toFun : A → B) →
(map_add' : ∀ (x y : A), toFun (x + y) = toFun x + toFun y) →
(map_smul' : ∀ (m : R) (x : A), toFun (m • x) = (RingHom.id R) m • toFun x) →
CoalgebraStruct.counit ∘ₗ { toFun := toFun, map_add' := map_add', map_smul' := map_smul' } =
CoalgebraStruct.counit →
TensorProduct.map { toFun := toFun, map_add' := map_add', map_smul' := map_smul' }
{ toFun := toFun, map_add' := map_add', map_smul' := map_smul' } ∘ₗ
CoalgebraStruct.comul =
CoalgebraStruct.comul ∘ₗ
{ toFun := toFun, map_add' := map_add', map_smul' := map_smul' } →
A →ₗc[R] B | false |
vectorSpan_mono | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ (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₁ s₂ : Set P}, s₁ ⊆ s₂ → vectorSpan k s₁ ≤ vectorSpan k s₂ | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.