name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Finset.mem_coe | Mathlib.Data.Finset.Defs | ∀ {α : Type u_1} {a : α} {s : Finset α}, a ∈ ↑s ↔ a ∈ s | true |
Lean.SubExpr.Pos.pushAppFn | Lean.SubExpr | Lean.SubExpr.Pos → Lean.SubExpr.Pos | true |
_private.Mathlib.LinearAlgebra.LinearIndependent.Lemmas.0.exists_of_linearIndepOn_of_finite_span._simp_1_13 | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {α : Type u} {a b : Set α}, (a = b) = ∀ (x : α), x ∈ a ↔ x ∈ b | false |
MonoidAlgebra.liftNCAlgHom._proof_1 | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ {R : Type u_3} {A : Type u_1} {B : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B], RingHomClass (A →ₐ[R] B) A B | false |
ContDiffWithinAt.congr_of_mem | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f f₁ : E → F} {x : E} {n : WithTop ℕ∞},
ContDiffWithinAt 𝕜 n f s x → (∀ y ∈ s, f₁ y = f y) → x ∈ s → ContDiffWithinAt 𝕜 n f₁ s x | true |
isIntegral_algebraMap_iff | Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Ring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : Algebra A B] [IsScalarTower R A B] {x : A},
Function.Injective ⇑(algebraMap A B) → (IsIntegral R ((algebraMap A B) x) ↔ IsIntegral R x) | true |
AlgebraicGeometry.SheafedSpace.comp_hom_c_app' | Mathlib.Geometry.RingedSpace.SheafedSpace | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : AlgebraicGeometry.SheafedSpace C} (α : X ⟶ Y)
(β : Y ⟶ Z) (U : TopologicalSpace.Opens ↑↑Z.toPresheafedSpace),
(CategoryTheory.CategoryStruct.comp α β).hom.c.app (Opposite.op U) =
CategoryTheory.CategoryStruct.comp (β.hom.c.app (Opposite.op U))
(α.hom.c.app (Opposite.op ((TopologicalSpace.Opens.map β.hom.base).obj U))) | true |
_private.Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace.0.Besicovitch.SatelliteConfig.exists_normalized_aux3._simp_1_4 | Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | false |
inner_gradientWithin_left | Mathlib.Analysis.Calculus.Gradient.Basic | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup F] [inst_2 : InnerProductSpace 𝕜 F]
[inst_3 : CompleteSpace F] {f : F → 𝕜} {x y : F} {s : Set F},
DifferentiableWithinAt 𝕜 f s x →
UniqueDiffWithinAt 𝕜 s x → inner 𝕜 (gradientWithin f s x) y = (fderivWithin 𝕜 f s x) y | true |
dimH_orthogonalProjection_le | Mathlib.Topology.MetricSpace.HausdorffDimension | ∀ {𝕜 : Type u_6} {E : Type u_7} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K : Submodule 𝕜 E) [inst_3 : K.HasOrthogonalProjection] (s : Set E), dimH (⇑K.orthogonalProjection '' s) ≤ dimH s | true |
Nat.zero_shiftRight | Init.Data.Nat.Lemmas | ∀ (n : ℕ), 0 >>> n = 0 | true |
Mathlib.Meta.Positivity.evalAddNorm | Mathlib.Analysis.Normed.Group.Basic | Mathlib.Meta.Positivity.PositivityExt | true |
CategoryTheory.Limits.coconeEquivalenceOpConeOp._proof_1 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] (F : CategoryTheory.Functor J C)
{X Y : CategoryTheory.Limits.Cocone F} (f : X ⟶ Y) (j : Jᵒᵖ),
CategoryTheory.CategoryStruct.comp f.hom.op (X.op.π.app j) = Y.op.π.app j | false |
CategoryTheory.Limits.IsZero.isoZero | Mathlib.CategoryTheory.Limits.Shapes.ZeroObjects | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] → {X : C} → CategoryTheory.Limits.IsZero X → (X ≅ 0) | true |
FreeMonoid.length_eq_four | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {v : FreeMonoid α},
v.length = 4 ↔ ∃ a b c d, v = FreeMonoid.of a * FreeMonoid.of b * FreeMonoid.of c * FreeMonoid.of d | true |
Lean.instBEqReducibilityStatus.beq | Lean.ReducibilityAttrs | Lean.ReducibilityStatus → Lean.ReducibilityStatus → Bool | true |
Std.TreeMap.Raw.getElem!_ofList_of_contains_eq_false | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp] [inst : BEq α] [Std.LawfulBEqCmp cmp]
{l : List (α × β)} {k : α} [inst_2 : Inhabited β],
(List.map Prod.fst l).contains k = false → (Std.TreeMap.Raw.ofList l cmp)[k]! = default | true |
SemidirectProduct.congr'_apply_left | Mathlib.GroupTheory.SemidirectProduct | ∀ {N₁ : Type u_4} {G₁ : Type u_5} {N₂ : Type u_6} {G₂ : Type u_7} [inst : Group N₁] [inst_1 : Group G₁]
[inst_2 : Group N₂] [inst_3 : Group G₂] {φ₁ : G₁ →* MulAut N₁} (fn : N₁ ≃* N₂) (fg : G₁ ≃* G₂) (x : N₁ ⋊[φ₁] G₁),
((SemidirectProduct.congr' fn fg) x).left = fn x.left | true |
Booleanisation.instPartialOrder | Mathlib.Order.Booleanisation | {α : Type u_1} → [GeneralizedBooleanAlgebra α] → PartialOrder (Booleanisation α) | true |
Module.Relations.Solution.ofπ.congr_simp | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u} [inst : Ring A] {relations : Module.Relations A} {M : Type v} [inst_1 : AddCommGroup M]
[inst_2 : Module A M] (π π_1 : (relations.G →₀ A) →ₗ[A] M) (e_π : π = π_1)
(hπ : ∀ (r : relations.R), π (relations.relation r) = 0),
Module.Relations.Solution.ofπ π hπ = Module.Relations.Solution.ofπ π_1 ⋯ | true |
right_le_midpoint | Mathlib.LinearAlgebra.AffineSpace.Ordered | ∀ {k : Type u_1} {E : Type u_2} [inst : Field k] [inst_1 : LinearOrder k] [inst_2 : IsStrictOrderedRing k]
[inst_3 : AddCommGroup E] [inst_4 : PartialOrder E] [IsOrderedAddMonoid E] [inst_6 : Module k E]
[IsStrictOrderedModule k E] [PosSMulReflectLE k E] {a b : E}, b ≤ midpoint k a b ↔ b ≤ a | true |
CochainComplex.ιMapBifunctor.congr_simp | Mathlib.Algebra.Homology.BifunctorShift | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {D : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_3} D]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms C₁] [inst_4 : CategoryTheory.Limits.HasZeroMorphisms C₂]
(K₁ : CochainComplex C₁ ℤ) (K₂ : CochainComplex C₂ ℤ) [inst_5 : CategoryTheory.Preadditive D]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ D)) [inst_6 : F.PreservesZeroMorphisms]
[inst_7 : ∀ (X₁ : C₁), (F.obj X₁).PreservesZeroMorphisms] [inst_8 : K₁.HasMapBifunctor K₂ F] (n₁ n₂ n : ℤ)
(h : n₁ + n₂ = n), K₁.ιMapBifunctor K₂ F n₁ n₂ n h = K₁.ιMapBifunctor K₂ F n₁ n₂ n h | true |
OneHomClass.toOneHom.eq_1 | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : One M] [inst_1 : One N] [inst_2 : FunLike F M N]
[inst_3 : OneHomClass F M N] (f : F), ↑f = { toFun := ⇑f, map_one' := ⋯ } | true |
Lean.Meta.pp.showLetValues.threshold | Lean.Meta.PPGoal | Lean.Option ℕ | true |
BooleanAlgebra.lt._inherited_default | Mathlib.Order.BooleanAlgebra.Defs | {α : Type u} → (α → α → Prop) → α → α → Prop | false |
Finset.map_comp_coe_apply | Mathlib.Data.Finset.Functor | ∀ {α β : Type u} (h : α → β) (s : Multiset α), Finset.image h s.toFinset = (h <$> s).toFinset | true |
Algebra.SubmersivePresentation.jacobian_isUnit | Mathlib.RingTheory.Extension.Presentation.Submersive | ∀ {R : Type u} {S : Type v} {ι : Type w} {σ : Type t} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : Finite σ] (self : Algebra.SubmersivePresentation R S ι σ), IsUnit self.jacobian | true |
Pi.mulActionWithZero._proof_1 | Mathlib.Algebra.GroupWithZero.Action.Pi | ∀ {I : Type u_1} {f : I → Type u_2} (α : Type u_3) [inst : MonoidWithZero α] [inst_1 : (i : I) → Zero (f i)]
[inst_2 : (i : I) → MulActionWithZero α (f i)] (a : α), a • 0 = 0 | false |
ENNReal.holderTriple_coe_iff._simp_1 | Mathlib.Data.Real.ConjExponents | ∀ {p q r : NNReal}, r ≠ 0 → (↑p).HolderTriple ↑q ↑r = p.HolderTriple q r | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.append_assoc'._proof_1 | Init.Data.BitVec.Lemmas | ∀ {w₁ w₂ w₃ : ℕ}, ¬w₁ + w₂ + w₃ = w₁ + (w₂ + w₃) → False | false |
MulActionHom.congr_fun | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_2} {N : Type u_3} {φ : M → N} {X : Type u_5} [inst : SMul M X] {Y : Type u_6} [inst_1 : SMul N Y]
{f g : X →ₑ[φ] Y}, f = g → ∀ (x : X), f x = g x | true |
Partition.mk.inj | Mathlib.Order.Partition.Basic | ∀ {α : Type u_1} {inst : CompleteLattice α} {s : α} {parts : Set α} {sSupIndep' : sSupIndep parts}
{bot_notMem' : ⊥ ∉ parts} {sSup_eq' : sSup parts = s} {parts_1 : Set α} {sSupIndep'_1 : sSupIndep parts_1}
{bot_notMem'_1 : ⊥ ∉ parts_1} {sSup_eq'_1 : sSup parts_1 = s},
{ parts := parts, sSupIndep' := sSupIndep', bot_notMem' := bot_notMem', sSup_eq' := sSup_eq' } =
{ parts := parts_1, sSupIndep' := sSupIndep'_1, bot_notMem' := bot_notMem'_1, sSup_eq' := sSup_eq'_1 } →
parts = parts_1 | true |
ENNReal.eventuallyEq_of_toReal_eventuallyEq | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ {α : Type u_1} {l : Filter α} {f g : α → ENNReal},
(∀ᶠ (x : α) in l, f x ≠ ⊤) →
(∀ᶠ (x : α) in l, g x ≠ ⊤) → ((fun x => (f x).toReal) =ᶠ[l] fun x => (g x).toReal) → f =ᶠ[l] g | true |
PartialEquiv.symm | Mathlib.Logic.Equiv.PartialEquiv | {α : Type u_1} → {β : Type u_2} → PartialEquiv α β → PartialEquiv β α | true |
Std.ExtDHashMap.Const.contains_modify | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k k' : α} {f : β → β}, (Std.ExtDHashMap.Const.modify m k f).contains k' = m.contains k' | true |
deriv_fun_finset_prod | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {ι : Type u_2} [inst_1 : DecidableEq ι] {𝔸' : Type u_3}
[inst_2 : NormedCommRing 𝔸'] [inst_3 : NormedAlgebra 𝕜 𝔸'] {u : Finset ι} {f : ι → 𝕜 → 𝔸'},
(∀ i ∈ u, DifferentiableAt 𝕜 (f i) x) →
deriv (fun x => ∏ i ∈ u, f i x) x = ∑ i ∈ u, (∏ j ∈ u.erase i, f j x) • deriv (f i) x | true |
Wbtw.neg | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] {x y z : V}, Wbtw R x y z → Wbtw R (-x) (-y) (-z) | true |
Polynomial.map_modByMonic | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} {S : Type v} [inst : Ring R] {p q : Polynomial R} [inst_1 : Ring S] (f : R →+* S),
q.Monic → Polynomial.map f (p %ₘ q) = Polynomial.map f p %ₘ Polynomial.map f q | true |
_private.Mathlib.Tactic.Linter.FindDeprecations.0.Mathlib.Tactic.getDeprecatedInfo.match_1 | Mathlib.Tactic.Linter.FindDeprecations | (motive : Option Lean.Name → Sort u_1) →
(__do_lift : Option Lean.Name) →
((mod : Lean.Name) → motive (some mod)) → ((x : Option Lean.Name) → motive x) → motive __do_lift | false |
Lean.Elab.Tactic.Do.Context.simpCtx | Lean.Elab.Tactic.Do.VCGen.Basic | Lean.Elab.Tactic.Do.Context → Lean.Meta.Simp.Context | true |
RingCon.quotientKerEquivOfSurjective | Mathlib.RingTheory.Congruence.Hom | {M : Type u_1} →
{P : Type u_3} →
[inst : NonAssocSemiring M] →
[inst_1 : NonAssocSemiring P] → (f : M →+* P) → Function.Surjective ⇑f → (RingCon.ker f).Quotient ≃+* P | true |
InvariantBasisNumber.casesOn | Mathlib.LinearAlgebra.InvariantBasisNumber | {R : Type u} →
[inst : Semiring R] →
{motive : InvariantBasisNumber R → Sort u_1} →
(t : InvariantBasisNumber R) →
((eq_of_fin_equiv : ∀ {n m : ℕ} (a : (Fin n → R) ≃ₗ[R] Fin m → R), n = m) → motive ⋯) → motive t | false |
Pi.single_op₂ | Mathlib.Algebra.Notation.Pi.Basic | ∀ {ι : Type u_1} {M : ι → Type u_6} {N : ι → Type u_7} {O : ι → Type u_8} [inst : (i : ι) → Zero (M i)]
[inst_1 : (i : ι) → Zero (N i)] [inst_2 : (i : ι) → Zero (O i)] [inst_3 : DecidableEq ι]
(op : (i : ι) → M i → N i → O i),
(∀ (i : ι), op i 0 0 = 0) →
∀ (i : ι) (x : M i) (y : N i), Pi.single i (op i x y) = fun j => op j (Pi.single i x j) (Pi.single i y j) | true |
Std.DTreeMap.Internal.Impl.isEmpty_alter! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α],
t.WF →
∀ {k : α} {f : Option (β k) → Option (β k)},
(Std.DTreeMap.Internal.Impl.alter! k f t).isEmpty =
((t.isEmpty || t.size == 1 && Std.DTreeMap.Internal.Impl.contains k t) && (f (t.get? k)).isNone) | true |
_private.Mathlib.Data.Multiset.Sym.0.Multiset.setOf_mem_sym2._simp_1_1 | Mathlib.Data.Multiset.Sym | ∀ {α : Type u_1} {m : Multiset α} {a b : α}, (s(a, b) ∈ m.sym2) = (a ∈ m ∧ b ∈ m) | false |
ENNReal.inv_three_add_inv_three | Mathlib.Data.ENNReal.Inv | 3⁻¹ + 3⁻¹ + 3⁻¹ = 1 | true |
ULift.nonAssocSemiring._proof_2 | Mathlib.Algebra.Ring.ULift | ∀ {R : Type u_2} [inst : NonAssocSemiring R] (a : ULift.{u_1, u_2} R), a * 1 = a | false |
Aesop.Options'.generateScript | Aesop.Options.Internal | Aesop.Options' → Bool | true |
CategoryTheory.Preadditive.comp_sub_assoc | Mathlib.CategoryTheory.Preadditive.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {P Q R : C} (f : P ⟶ Q)
(g g' : Q ⟶ R) {Z : C} (h : R ⟶ Z),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp (g - g') h) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp f g - CategoryTheory.CategoryStruct.comp f g') h | true |
RingQuot.instSub | Mathlib.Algebra.RingQuot | {R : Type uR} → [inst : Ring R] → (r : R → R → Prop) → Sub (RingQuot r) | true |
_private.Mathlib.Algebra.Homology.Augment.0.ChainComplex.augment.match_3.eq_3 | Mathlib.Algebra.Homology.Augment | ∀ (motive : ℕ → ℕ → Sort u_1) (x x_1 : ℕ) (h_1 : Unit → motive 1 0) (h_2 : (i j : ℕ) → motive i.succ j.succ)
(h_3 : (x x_2 : ℕ) → motive x x_2),
(x = 1 → x_1 = 0 → False) →
(∀ (i j : ℕ), x = i.succ → x_1 = j.succ → False) →
(match x, x_1 with
| 1, 0 => h_1 ()
| i.succ, j.succ => h_2 i j
| x, x_4 => h_3 x x_4) =
h_3 x x_1 | true |
Lean.Order.instPartialOrderStateRefT' | Init.Internal.Order.Basic | {m : Type → Type} →
{ω σ α : Type} → [inst : Lean.Order.PartialOrder (m α)] → Lean.Order.PartialOrder (StateRefT' ω σ m α) | true |
getElem_congr_coll | Init.GetElem | ∀ {coll : Type u_1} {idx : Type u_2} {elem : Type u_3} {valid : coll → idx → Prop} [inst : GetElem coll idx elem valid]
{c d : coll} {i : idx} {w : valid c i} (h : c = d), c[i] = d[i] | true |
AlgebraicGeometry.RingedSpace.mem_top_basicOpen._simp_1 | Mathlib.Geometry.RingedSpace.Basic | ∀ (X : AlgebraicGeometry.RingedSpace) (f : ↑(X.presheaf.obj (Opposite.op ⊤))) (x : ↑↑X.toPresheafedSpace),
(x ∈ X.basicOpen f) = IsUnit ((CategoryTheory.ConcreteCategory.hom (X.presheaf.Γgerm x)) f) | false |
QuadraticMap.IsOrtho.symm | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {Q : QuadraticMap R M N} {x y : M}, Q.IsOrtho x y → Q.IsOrtho y x | true |
QuadraticMap.IsometryEquiv.map_negDef_iff | Mathlib.LinearAlgebra.QuadraticForm.Signature | ∀ {R : Type u_1} {M : Type u_2} {M' : Type u_3} [inst : AddCommGroup M] [inst_1 : AddCommGroup M'] [inst_2 : CommRing R]
[inst_3 : LinearOrder R] [inst_4 : Module R M] {Q : QuadraticForm R M} [inst_5 : Module R M']
{Q' : QuadraticForm R M'} {V : Submodule R M} (e : QuadraticMap.IsometryEquiv Q Q'),
(QuadraticMap.restrict (-Q') (Submodule.map (↑e.toLinearEquiv) V)).PosDef ↔ (QuadraticMap.restrict (-Q) V).PosDef | true |
Lean.Elab.Term.Quotation.HeadCheck._sizeOf_1 | Lean.Elab.Quotation | Lean.Elab.Term.Quotation.HeadCheck → ℕ | false |
Mathlib.Meta.FunProp.LambdaTheorems.mk.noConfusion | Mathlib.Tactic.FunProp.Theorems | {P : Sort u} →
{theorems theorems' :
Std.HashMap (Lean.Name × Mathlib.Meta.FunProp.LambdaTheoremType) (Array Mathlib.Meta.FunProp.LambdaTheorem)} →
{ theorems := theorems } = { theorems := theorems' } → (theorems = theorems' → P) → P | false |
Ideal.map_includeRight_eq | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} {B : Type u_3} [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (I : Ideal B),
Submodule.restrictScalars R (Ideal.map Algebra.TensorProduct.includeRight I) =
(LinearMap.lTensor A (Submodule.restrictScalars R I).subtype).range | true |
Hyperreal.termε | Mathlib.Analysis.Real.Hyperreal | Lean.ParserDescr | true |
Filter.map_mul | Mathlib.Order.Filter.Pointwise | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Mul α] [inst_1 : Mul β] {f₁ f₂ : Filter α}
[inst_2 : FunLike F α β] [MulHomClass F α β] (m : F),
Filter.map (⇑m) (f₁ * f₂) = Filter.map (⇑m) f₁ * Filter.map (⇑m) f₂ | true |
Pi.smulZeroClass._proof_1 | Mathlib.Algebra.GroupWithZero.Action.Pi | ∀ {I : Type u_1} {f : I → Type u_2} (α : Type u_3) {n : (i : I) → Zero (f i)} [inst : (i : I) → SMulZeroClass α (f i)]
(x : α), x • 0 = 0 | false |
Int.fdiv_nonneg | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, 0 ≤ a → 0 ≤ b → 0 ≤ a.fdiv b | true |
Affine.Simplex.incenter_mem_interior | Mathlib.Geometry.Euclidean.Incenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n), s.incenter ∈ s.interior | true |
_private.Lean.DocString.Extension.0.Lean.VersoModuleDocs.DocFrame | Lean.DocString.Extension | Type | true |
_private.Mathlib.Analysis.Complex.LocallyUniformLimit.0.TendstoLocallyUniformlyOn.deriv._simp_1_2 | Mathlib.Analysis.Complex.LocallyUniformLimit | ∀ (α : Sort u), (∀ (a : α), True) = True | false |
tprod_apply | Mathlib.Topology.Algebra.InfiniteSum.Constructions | ∀ {α : Type u_1} {ι : Type u_4} {X : α → Type u_5} [inst : (x : α) → CommMonoid (X x)]
[inst_1 : (x : α) → TopologicalSpace (X x)] {L : SummationFilter ι} [L.NeBot] [∀ (x : α), T2Space (X x)]
{f : ι → (x : α) → X x} {x : α}, Multipliable f L → (∏'[L] (i : ι), f i) x = ∏'[L] (i : ι), f i x | true |
CategoryTheory.Comonad.ForgetCreatesColimits'.liftedCoconeIsColimit._proof_1 | Mathlib.CategoryTheory.Monad.Limits | ∀ {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] {T : CategoryTheory.Comonad C}
(D : CategoryTheory.Functor J T.Coalgebra) (c : CategoryTheory.Limits.Cocone (D.comp T.forget))
(t : CategoryTheory.Limits.IsColimit c) (s : CategoryTheory.Limits.Cocone D) (j : J),
CategoryTheory.CategoryStruct.comp (c.ι.app j)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Comonad.ForgetCreatesColimits'.liftedCocone D c t).pt.a
(T.map (t.desc (T.forget.mapCocone s)))) =
CategoryTheory.CategoryStruct.comp (c.ι.app j)
(CategoryTheory.CategoryStruct.comp (t.desc (T.forget.mapCocone s)) s.pt.a) | false |
HahnSeries.coeff_zero | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] {a : Γ}, HahnSeries.coeff 0 a = 0 | true |
Combinatorics.Line.casesOn | Mathlib.Combinatorics.HalesJewett | {α : Type u_5} →
{ι : Type u_6} →
{motive : Combinatorics.Line α ι → Sort u} →
(t : Combinatorics.Line α ι) →
((idxFun : ι → Option α) → (proper : ∃ i, idxFun i = none) → motive { idxFun := idxFun, proper := proper }) →
motive t | false |
Descriptive.Tree.mem_pullSub_append._simp_1 | Mathlib.SetTheory.Descriptive.Tree | ∀ {A : Type u_1} {T : ↥(Descriptive.tree A)} {x y : List A}, (x ++ y ∈ Descriptive.Tree.pullSub T x) = (y ∈ T) | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.isEmpty_filter_key_eq_false_iff._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | false |
LinearMap.BilinForm.separatingLeft_toMatrix'_iff._simp_1 | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₂ : Type u_3} [inst : CommRing R₂] {ι : Type u_6} [inst_1 : DecidableEq ι] [inst_2 : Fintype ι]
{B : LinearMap.BilinForm R₂ (ι → R₂)}, (LinearMap.BilinForm.toMatrix' B).SeparatingLeft = LinearMap.SeparatingLeft B | false |
CategoryTheory.Limits.pushoutCoconeEquivBinaryCofan_functor_obj | Mathlib.CategoryTheory.Limits.Constructions.Over.Products | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z}
(c : CategoryTheory.Limits.PushoutCocone f g),
CategoryTheory.Limits.pushoutCoconeEquivBinaryCofan.functor.obj c =
CategoryTheory.Limits.BinaryCofan.mk (CategoryTheory.Under.homMk c.inl ⋯) (CategoryTheory.Under.homMk c.inr ⋯) | true |
GenLoop.apply_inl_apply_inr_eq_of_mem_boundary_sum | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {N : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] {M : Type u_3} (x : X)
(p : ↑(GenLoop M (↑(GenLoop N X x)) GenLoop.const)) {y : M ⊕ N → ↑unitInterval},
y ∈ Cube.boundary (M ⊕ N) → (p (y ∘ Sum.inl)) (y ∘ Sum.inr) = x | true |
Turing.ToPartrec.Cfg.ret.elim | Mathlib.Computability.TuringMachine.Config | {motive : Turing.ToPartrec.Cfg → Sort u} →
(t : Turing.ToPartrec.Cfg) →
t.ctorIdx = 1 → ((a : Turing.ToPartrec.Cont) → (a_1 : List ℕ) → motive (Turing.ToPartrec.Cfg.ret a a_1)) → motive t | false |
OrderType.ToType | Mathlib.Order.Types.Defs | OrderType.{u} → Type u | true |
R0Space.casesOn | Mathlib.Topology.Separation.Basic | {X : Type u} →
[inst : TopologicalSpace X] →
{motive : R0Space X → Sort u_1} →
(t : R0Space X) → ((specializes_symmetric : Symmetric Specializes) → motive ⋯) → motive t | false |
SimpleGraph.dist_eq_one_iff_adj._simp_1 | Mathlib.Combinatorics.SimpleGraph.Metric | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V}, (G.dist u v = 1) = G.Adj u v | false |
Lean.Compiler.LCNF.FloatLetIn.dontFloat | Lean.Compiler.LCNF.FloatLetIn | Lean.Compiler.LCNF.CodeDecl Lean.Compiler.LCNF.Purity.pure → Lean.Compiler.LCNF.FloatLetIn.FloatM Unit | true |
WithTop.instUniqueOfIsEmpty.eq_1 | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : IsEmpty α], WithTop.instUniqueOfIsEmpty = { toInhabited := WithTop.inhabited, uniq := ⋯ } | true |
LinearMap.coe_compAlternatingMap | Mathlib.LinearAlgebra.Alternating.Basic | ∀ {R : Type u_1} [inst : Semiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {ι : Type u_7} {N₂ : Type u_11} [inst_5 : AddCommMonoid N₂]
[inst_6 : Module R N₂] (g : N →ₗ[R] N₂) (f : M [⋀^ι]→ₗ[R] N), ⇑(g.compAlternatingMap f) = ⇑g ∘ ⇑f | true |
Lean.MonadLog.logMessage | Lean.Log | {m : Type → Type} → [self : Lean.MonadLog m] → Lean.Message → m Unit | true |
Topology.RelCWComplex.isClosed_inter_cellFrontier_succ_of_le_isClosed_inter_closedCell | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] {C D : Set X} [inst : Topology.RelCWComplex C D] [T2Space X] {A : Set X}
{n : ℕ},
(∀ m ≤ n, ∀ (j : Topology.RelCWComplex.cell C m), IsClosed (A ∩ Topology.RelCWComplex.closedCell m j)) →
∀ (j : Topology.RelCWComplex.cell C (n + 1)),
IsClosed (A ∩ D) → IsClosed (A ∩ Topology.RelCWComplex.cellFrontier (n + 1) j) | true |
CategoryTheory.Functor.CommShift₂.commShiftFlipObj | Mathlib.CategoryTheory.Shift.CommShiftTwo | {C₁ : Type u_1} →
{C₂ : Type u_3} →
{D : Type u_5} →
{inst : CategoryTheory.Category.{v_1, u_1} C₁} →
{inst_1 : CategoryTheory.Category.{v_3, u_3} C₂} →
{inst_2 : CategoryTheory.Category.{v_5, u_5} D} →
{M : Type u_6} →
{inst_3 : AddCommMonoid M} →
{inst_4 : CategoryTheory.HasShift C₁ M} →
{inst_5 : CategoryTheory.HasShift C₂ M} →
{inst_6 : CategoryTheory.HasShift D M} →
{G : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ D)} →
(h : CategoryTheory.CommShift₂Setup D M) →
[self : G.CommShift₂ h] → (X₂ : C₂) → (G.flip.obj X₂).CommShift M | true |
Std.Internal.IO.Async.Signal.Waiter._sizeOf_1 | Std.Internal.Async.Signal | Std.Internal.IO.Async.Signal.Waiter → ℕ | false |
_private.Mathlib.Order.KrullDimension.0.Order.krullDim_pos_iff._simp_1_1 | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, (∀ (b : α), ¬a < b) = IsMax a | false |
_private.Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable.0.cond.match_1.eq_2 | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ (motive : Bool → Sort u_1) (h_1 : Unit → motive true) (h_2 : Unit → motive false),
(match false with
| true => h_1 ()
| false => h_2 ()) =
h_2 () | true |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.toLCNF.etaIfUnderApplied | Lean.Compiler.LCNF.ToLCNF | Lean.Expr →
ℕ →
Lean.Compiler.LCNF.ToLCNF.M (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure) →
Lean.Compiler.LCNF.ToLCNF.M (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure) | true |
DFinsupp.Lex.addLeftStrictMono | Mathlib.Data.DFinsupp.Lex | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : LinearOrder ι] [inst_1 : (i : ι) → AddMonoid (α i)]
[inst_2 : (i : ι) → LinearOrder (α i)] [∀ (i : ι), AddLeftStrictMono (α i)], AddLeftStrictMono (Lex (Π₀ (i : ι), α i)) | true |
CategoryTheory.WithInitial.incl.eq_1 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C],
CategoryTheory.WithInitial.incl =
{ obj := CategoryTheory.WithInitial.of, map := fun {X Y} f => f, map_id := ⋯, map_comp := ⋯ } | true |
OrderIso.lowerBounds_image | Mathlib.Order.Bounds.OrderIso | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (f : α ≃o β) {s : Set α},
lowerBounds (⇑f '' s) = ⇑f '' lowerBounds s | true |
Int8.reduceGT._regBuiltin.Int8.reduceGT.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.3529513953._hygCtx._hyg.213 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | false |
Set.image_op_add | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Add α] {s t : Set α}, AddOpposite.op '' (s + t) = AddOpposite.op '' t + AddOpposite.op '' s | true |
Bool.instCommutativeAnd | Init.Data.Bool | Std.Commutative fun x1 x2 => x1 && x2 | true |
Std.Tactic.BVDecide.BVUnOp.rotateLeft.inj | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {n n_1 : ℕ}, Std.Tactic.BVDecide.BVUnOp.rotateLeft n = Std.Tactic.BVDecide.BVUnOp.rotateLeft n_1 → n = n_1 | true |
instFullPreordCatPreordToCat | Mathlib.Order.Category.Preord | preordToCat.Full | true |
Set.powersetCard.coe_addActionHom_of_embedding | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ (G : Type u_1) [inst : AddGroup G] (α : Type u_2) [inst_1 : AddAction G α] {n : ℕ} [inst_2 : DecidableEq α]
(f : Fin n ↪ α), ↑((Set.powersetCard.addActionHom_of_embedding G α n).toFun f) = Finset.map f Finset.univ | true |
_private.Mathlib.Combinatorics.Matroid.Map.0.Matroid.map_dual._simp_1_2 | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α} {t : Set β}, (t ⊆ f '' s) = ∃ u ⊆ s, f '' u = t | false |
_private.Mathlib.Data.Matrix.Basis.0.Matrix.single_mem_matrix._simp_1_1 | Mathlib.Data.Matrix.Basis | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} {S : Set α} {M : Matrix m n α},
(M ∈ S.matrix) = ∀ (i : m) (j : n), M i j ∈ S | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.