name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Parser.atomicFn | Lean.Parser.Basic | Lean.Parser.ParserFn → Lean.Parser.ParserFn | true |
instReprInt | Init.Data.Repr | Repr ℤ | true |
NonUnitalStarAlgebra.elemental | Mathlib.Topology.Algebra.NonUnitalStarAlgebra | (R : Type u_1) →
{A : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : StarRing R] →
[inst_2 : NonUnitalSemiring A] →
[inst_3 : StarRing A] →
[inst_4 : Module R A] →
[IsScalarTower R A A] →
[SMulCommClass R A A] →
[StarModule R A] ... | true |
inhomogeneousCochains.d._proof_3 | Mathlib.RepresentationTheory.Homological.GroupCohomology.Basic | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Monoid G] (A : Rep.{u_2, u_1, u_1} k G) (n : ℕ) (r : k)
(f : (Fin n → G) → ↑A),
(fun g =>
(A.ρ (g 0)) ((r • f) fun i => g i.succ) +
∑ j, (-1) ^ (↑j + 1) • (r • f) (j.contractNth (fun x1 x2 => x1 * x2) g)) =
(RingHom.id k) r • fun g =>
(A.ρ (g ... | false |
LinearRecurrence.mkSol._proof_3 | Mathlib.Algebra.LinearRecurrence | ∀ {R : Type u_1} [inst : CommSemiring R] (E : LinearRecurrence R) (a : ℕ) (k : Fin E.order),
a - E.order + ↑k < a → InvImage (fun x1 x2 => x1 < x2) (fun x => x) (a - E.order + ↑k) a | false |
Submodule.mul_le | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} [inst : Semiring R] {A : Type v} [inst_1 : Semiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] {M N P : Submodule R A}, M * N ≤ P ↔ ∀ m ∈ M, ∀ n ∈ N, m * n ∈ P | true |
Equiv.pSigmaAssoc._proof_2 | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u_1} {β : α → Sort u_2} (γ : (a : α) → β a → Sort u_3),
Function.RightInverse (fun x => ⟨⟨x.fst, x.snd.fst⟩, x.snd.snd⟩) fun x => ⟨x.fst.fst, ⟨x.fst.snd, x.snd⟩⟩ | false |
OpenPartialHomeomorph.univUnitBall_apply | Mathlib.Analysis.Normed.Module.Ball.Homeomorph | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] (x : E),
↑OpenPartialHomeomorph.univUnitBall x = (√(1 + ‖x‖ ^ 2))⁻¹ • x | true |
Int32.toISize_le | Init.Data.SInt.Lemmas | ∀ {a b : Int32}, a.toISize ≤ b.toISize ↔ a ≤ b | true |
ModuleCat.MonoidalCategory.instBraidedSemimoduleCatFunctorEquivalenceSemimoduleCat | Mathlib.Algebra.Category.ModuleCat.Monoidal.Symmetric | {R : Type u} → [inst : CommRing R] → ModuleCat.equivalenceSemimoduleCat.functor.Braided | true |
LSeries_one_mul_Lseries_moebius | Mathlib.NumberTheory.LSeries.Dirichlet | ∀ {s : ℂ}, 1 < s.re → LSeries 1 s * LSeries (fun n => ↑(ArithmeticFunction.moebius n)) s = 1 | true |
Std.DTreeMap.Internal.Impl.Const.toListModel_alter! | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
{t : Std.DTreeMap.Internal.Impl α fun x => β} {a : α} {f : Option β → Option β},
t.Balanced →
t.Ordered →
(Std.DTreeMap.Internal.Impl.Const.alter! a f t).toListModel.Perm
(Std.Internal.List.Const.alte... | true |
PFun.graph' | Mathlib.Data.PFun | {α : Type u_1} → {β : Type u_2} → (α →. β) → SetRel α β | true |
AlgebraicGeometry.Scheme.isoOfEq_inv_ι_assoc | Mathlib.AlgebraicGeometry.Restrict | ∀ (X : AlgebraicGeometry.Scheme) {U V : X.Opens} (e : U = V) {Z : AlgebraicGeometry.Scheme} (h : X ⟶ Z),
CategoryTheory.CategoryStruct.comp (X.isoOfEq e).inv (CategoryTheory.CategoryStruct.comp U.ι h) =
CategoryTheory.CategoryStruct.comp V.ι h | true |
CategoryTheory.GrpObj.lift_inv_left_eq | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{A B : C} [inst_2 : CategoryTheory.GrpObj B] (f g h : A ⟶ B),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CartesianMonoidalCategory.lift (CategoryTheory.CategoryStruct.comp f CategoryTheo... | true |
ModuleCat.HasColimit.reflectsColimit | Mathlib.Algebra.Category.ModuleCat.Colimits | ∀ {R : Type w} [inst : Ring R] {J : Type u} [inst_1 : CategoryTheory.Category.{v, u} J]
(F : CategoryTheory.Functor J (ModuleCat R))
[CategoryTheory.Limits.HasColimit (F.comp (CategoryTheory.forget₂ (ModuleCat R) AddCommGrpCat))],
CategoryTheory.Limits.ReflectsColimit F (CategoryTheory.forget₂ (ModuleCat R) AddCo... | true |
Std.TreeMap.getElem?_eq_some_getElem | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {a : α} (h : a ∈ t),
t[a]? = some t[a] | true |
Nat.compare_eq_ite_lt | Init.Data.Nat.Compare | ∀ (a b : ℕ), compare a b = if a < b then Ordering.lt else if b < a then Ordering.gt else Ordering.eq | true |
num_smul_one_lt_den_smul_add | Mathlib.Data.Real.Embedding | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [IsOrderedAddMonoid M] [inst_3 : One M] {u v : ℚ}
{x y : M}, u.num • 1 < u.den • x → v.num • 1 < v.den • y → (u + v).num • 1 < (u + v).den • (x + y) | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.MappingCone.0.CochainComplex.mappingCone.lift_f_snd_v._proof_1_1 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ (p q : ℤ), p + 0 = q → q = p | false |
Aesop.ForwardRuleMatch.mk.inj | Aesop.Forward.Match.Types | ∀ {rule : Aesop.ForwardRule} {«match» : Aesop.CompleteMatch} {rule_1 : Aesop.ForwardRule}
{match_1 : Aesop.CompleteMatch},
{ rule := rule, «match» := «match» } = { rule := rule_1, «match» := match_1 } → rule = rule_1 ∧ «match» = match_1 | true |
CategoryTheory.Limits.ChosenPullback.mk._flat_ctor | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X₁ X₂ S : C} →
{f₁ : X₁ ⟶ S} →
{f₂ : X₂ ⟶ S} →
(pullback : C) →
(p₁ : pullback ⟶ X₁) →
(p₂ : pullback ⟶ X₂) →
(condition : CategoryTheory.CategoryStruct.comp p₁ f₁ = CategoryTheory.Categor... | false |
List.nodup_permutations_iff | Mathlib.Data.List.Permutation | ∀ {α : Type u_1} {s : List α}, s.permutations.Nodup ↔ s.Nodup | true |
Plausible.TotalFunction.zeroDefault.eq_1 | Mathlib.Testing.Plausible.Functions | ∀ {α : Type u} {β : Type v} [inst : Zero β] (A : List ((_ : α) × β)) (a : β),
(Plausible.TotalFunction.withDefault A a).zeroDefault = Plausible.TotalFunction.withDefault A 0 | true |
Associates.one_or_eq_of_le_of_prime | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [IsCancelMulZero M] {p m : Associates M}, Prime p → m ≤ p → m = 1 ∨ m = p | true |
Set.infsep_of_fintype._proof_1 | Mathlib.Topology.MetricSpace.Infsep | ∀ {α : Type u_1} {s : Set α} [inst : Fintype ↑s], s.Nontrivial → s.offDiag.toFinset.Nonempty | false |
partialOrderOfSO.match_5 | Mathlib.Order.RelClasses | ∀ {α : Type u_1} (r : α → α → Prop) (x : α) (motive : (y : α) → x = y ∨ r x y → y = x ∨ r y x → Prop) (y : α)
(h₁ : x = y ∨ r x y) (h₂ : y = x ∨ r y x),
(∀ (x_1 : x = x ∨ r x x), motive x ⋯ x_1) →
(∀ (x_1 : x = x ∨ r x x), motive x x_1 ⋯) →
(∀ (x_1 : α) (h₁ : r x x_1) (h₂ : r x_1 x), motive x_1 ⋯ ⋯) → mot... | false |
Set.Finite.inter_of_left | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {s : Set α}, s.Finite → ∀ (t : Set α), (s ∩ t).Finite | true |
RingOfIntegers.exponent_eq_one_iff | Mathlib.NumberTheory.NumberField.Ideal.KummerDedekind | ∀ {K : Type u_1} [inst : Field K] {θ : NumberField.RingOfIntegers K}, RingOfIntegers.exponent θ = 1 ↔ ℤ[θ] = ⊤ | true |
GradedTensorProduct.instRing._proof_17 | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | ∀ {R : Type u_1} {ι : Type u_2} {A : Type u_3} {B : Type u_4} [inst : CommSemiring ι] [inst_1 : DecidableEq ι]
[inst_2 : CommRing R] [inst_3 : Ring A] [inst_4 : Ring B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
(𝒜 : ι → Submodule R A) (ℬ : ι → Submodule R B) [inst_7 : GradedAlgebra 𝒜] [inst_8 : GradedAlgebra ... | false |
Lean.Meta.Grind.Arith.CommRing.MonadRing.recOn | Lean.Meta.Tactic.Grind.Arith.CommRing.MonadRing | {m : Type → Type} →
{motive : Lean.Meta.Grind.Arith.CommRing.MonadRing m → Sort u} →
(t : Lean.Meta.Grind.Arith.CommRing.MonadRing m) →
((getRing : m Lean.Meta.Grind.Arith.CommRing.Ring) →
(modifyRing : (Lean.Meta.Grind.Arith.CommRing.Ring → Lean.Meta.Grind.Arith.CommRing.Ring) → m Unit) →
... | false |
_private.Mathlib.Algebra.Lie.Semisimple.Basic.0.LieAlgebra.IsSemisimple.isSimple_of_isAtom._simp_1_7 | Mathlib.Algebra.Lie.Semisimple.Basic | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' | false |
CauSeq.IsComplete.isComplete | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_1} {inst : Field α} {inst_1 : LinearOrder α} {inst_2 : IsStrictOrderedRing α} {β : Type u_2}
{inst_3 : Ring β} {abv : β → α} {inst_4 : IsAbsoluteValue abv} [self : CauSeq.IsComplete β abv] (s : CauSeq β abv),
∃ b, s ≈ CauSeq.const abv b | true |
SeparationQuotient.exists_out_continuousLinearMap | Mathlib.Topology.Algebra.SeparationQuotient.Section | ∀ (K : Type u_1) (E : Type u_2) [inst : DivisionRing K] [inst_1 : AddCommGroup E] [inst_2 : Module K E]
[inst_3 : TopologicalSpace E] [inst_4 : IsTopologicalAddGroup E] [inst_5 : ContinuousConstSMul K E],
∃ f, (SeparationQuotient.mkCLM K E).comp f = ContinuousLinearMap.id K (SeparationQuotient E) | true |
CategoryTheory.CoreSmallCategoryOfSet.functor | Mathlib.CategoryTheory.SmallRepresentatives | {Ω : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(h : CategoryTheory.CoreSmallCategoryOfSet Ω C) → CategoryTheory.Functor (↑h.smallCategoryOfSet.obj) C | true |
BoundedLatticeHom.dual._proof_4 | Mathlib.Order.Hom.BoundedLattice | ∀ {α : Type u_2} {β : Type u_1} [inst : Lattice α] [inst_1 : BoundedOrder α] [inst_2 : Lattice β]
[inst_3 : BoundedOrder β] (f : BoundedLatticeHom αᵒᵈ βᵒᵈ), f.toFun ⊤ = ⊤ | false |
CategoryTheory.Comonad.Coalgebra | Mathlib.CategoryTheory.Monad.Algebra | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → CategoryTheory.Comonad C → Type (max u₁ v₁) | true |
CategoryTheory.PreOneHypercover.IsStronglySheafFor.map_amalgamate | Mathlib.CategoryTheory.Sites.Hypercover.SheafOfTypes | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : C} {E : CategoryTheory.PreOneHypercover X}
{F : CategoryTheory.Functor Cᵒᵖ (Type u_2)} (h : E.IsStronglySheafFor F)
(x : (i : E.I₀) → F.obj (Opposite.op (E.X i)))
(hc : ∀ ⦃i j : E.I₀⦄ (k : E.I₁ i j), F.map (E.p₁ k).op (x i) = F.map (E.p₂ k).op (x... | true |
Std.HashMap.erase_emptyWithCapacity | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {a : α} {c : ℕ},
(Std.HashMap.emptyWithCapacity c).erase a = Std.HashMap.emptyWithCapacity c | true |
_private.Mathlib.Dynamics.Ergodic.Extreme.0.Ergodic.of_mem_extremePoints._simp_1_1 | Mathlib.Dynamics.Ergodic.Extreme | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α},
MeasureTheory.IsProbabilityMeasure μ = (μ Set.univ = 1) | false |
PseudoMetric.IsUltra.sup | Mathlib.Topology.MetricSpace.BundledFun | ∀ {X : Type u_1} {R : Type u_2} [inst : AddZeroClass R] [inst_1 : SemilatticeSup R] [inst_2 : AddLeftMono R]
[inst_3 : AddRightMono R] {d d' : PseudoMetric X R} [d.IsUltra] [d'.IsUltra], (d ⊔ d').IsUltra | true |
CategoryTheory.NatTrans.instCommShiftOppositeShiftHomFunctorNatIsoComp | Mathlib.CategoryTheory.Shift.Opposite | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (A : Type u_3) [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift C A] [inst_4 : CategoryTheory.HasShift D A] (F : CategoryTheory.Functor C D)
{E : Type u_4} [inst_5 : CategoryTheory... | true |
_private.Mathlib.Topology.Compactness.LocallyCompact.0.IsCompact.nhdsSet_basis_isCompact._proof_1_1 | Mathlib.Topology.Compactness.LocallyCompact | ∀ {X : Type u_1} [inst : TopologicalSpace X] {K : Set X} ⦃s t : Set X⦄,
s ⊆ t → (∃ r ∈ nhdsSet K, IsCompact r ∧ r ⊆ s) → ∃ r ∈ nhdsSet K, IsCompact r ∧ r ⊆ t | false |
Std.MaxEqOr.max_eq_or | Init.Data.Order.Classes | ∀ {α : Type u} {inst : Max α} [self : Std.MaxEqOr α] (a b : α), a ⊔ b = a ∨ a ⊔ b = b | true |
Lean.Widget.instToJsonRpcEncodablePacket._@.Lean.Widget.InteractiveGoal.1056429149._hygCtx._hyg.45 | Lean.Widget.InteractiveGoal | Lean.ToJson Lean.Widget.RpcEncodablePacket✝ | false |
IntermediateField.coe_algebraMap_over_bot | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E],
⇑(algebraMap (↥⊥) F) = ⇑(IntermediateField.botEquiv F E) | true |
CategoryTheory.Limits.prod.symmetry' | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P Q : C) [inst_1 : CategoryTheory.Limits.HasBinaryProduct P Q]
[inst_2 : CategoryTheory.Limits.HasBinaryProduct Q P],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.fst)
... | true |
Matrix.empty_vecAlt1 | Mathlib.Data.Fin.VecNotation | ∀ (α : Type u_1) {h : 0 = 0 + 0}, Matrix.vecAlt1 h ![] = ![] | true |
_private.Std.Sat.AIG.RefVecOperator.Fold.0.Std.Sat.AIG.RefVec.denote_fold_and._proof_1_1 | Std.Sat.AIG.RefVecOperator.Fold | ∀ {len : ℕ}, ¬0 ≤ len → False | false |
CategoryTheory.NatTrans.leftOp._proof_1 | Mathlib.CategoryTheory.Opposites | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {F G : CategoryTheory.Functor C Dᵒᵖ} (α : F ⟶ G) (X Y : Cᵒᵖ)
(f : X ⟶ Y),
(CategoryTheory.CategoryStruct.comp (G.leftOp.map f) (α.app (Opposite.unop Y)).unop).op =
(CategoryTheory.Cate... | false |
IsUnit.isUnit_iff_mulLeft_bijective | Mathlib.Algebra.Group.Units.Basic | ∀ {M : Type u_1} [inst : Monoid M] {a : M}, IsUnit a ↔ Function.Bijective fun x => a * x | true |
_private.Mathlib.Analysis.ODE.PicardLindelof.0.ContDiffAt.exists_eventually_eq_hasDerivAt._proof_1_1 | Mathlib.Analysis.ODE.PicardLindelof | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E], ContinuousSMul ℝ E | false |
UniformSpace.Completion.ring._proof_30 | Mathlib.Topology.Algebra.UniformRing | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : UniformSpace α] [inst_2 : IsUniformAddGroup α], ↑0 = 0 | false |
TopologicalSpace.Opens.comap._proof_4 | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_2} {β : Type u_1} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f : C(α, β))
(x x_1 : TopologicalSpace.Opens β),
{ carrier := ⇑f ⁻¹' ↑(x ⊓ x_1), is_open' := ⋯ } = { carrier := ⇑f ⁻¹' ↑(x ⊓ x_1), is_open' := ⋯ } | false |
Matrix.normedSpace | Mathlib.Analysis.Matrix.Normed | {R : Type u_1} →
{m : Type u_3} →
{n : Type u_4} →
{α : Type u_5} →
[inst : Fintype m] →
[inst_1 : Fintype n] →
[inst_2 : NormedField R] →
[inst_3 : SeminormedAddCommGroup α] → [NormedSpace R α] → NormedSpace R (Matrix m n α) | true |
Std.ExtTreeMap.diff.congr_simp | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] (t₁ t₁_1 : Std.ExtTreeMap α β cmp),
t₁ = t₁_1 → ∀ (t₂ t₂_1 : Std.ExtTreeMap α β cmp), t₂ = t₂_1 → t₁.diff t₂ = t₁_1.diff t₂_1 | true |
BoundedContinuousFunction.instFunLike | Mathlib.Topology.ContinuousMap.Bounded.Basic | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] → [inst_1 : PseudoMetricSpace β] → FunLike (BoundedContinuousFunction α β) α β | true |
CategoryTheory.Sheaf.isLocallySurjective_comp | Mathlib.CategoryTheory.Sites.LocallySurjective | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u'}
[inst_1 : CategoryTheory.Category.{v', u'} A] {FA : A → A → Type u_1} {CA : A → Type w'}
[inst_2 : (X Y : A) → FunLike (FA X Y) (CA X) (CA Y)] [inst_3 : CategoryTheory.ConcreteCategory A FA]
{F₁ F₂ F... | true |
unitInterval.sigmoid._proof_1 | Mathlib.Analysis.SpecialFunctions.Sigmoid | ∀ (x : ℝ), 0 ≤ x.sigmoid ∧ x.sigmoid ≤ 1 | false |
NormedSpace.restrictScalars._proof_1 | Mathlib.Analysis.Normed.Module.Basic | ∀ (𝕜 : Type u_2) (𝕜' : Type u_1) (E : Type u_3) [inst : NormedField 𝕜] [inst_1 : NormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] [inst_3 : SeminormedAddCommGroup E] (c : 𝕜) (x : E),
‖(algebraMap 𝕜 𝕜') c‖ * ‖x‖ = ‖c‖ * ‖x‖ | false |
CategoryTheory.FreeBicategory.Hom₂.whisker_right | Mathlib.CategoryTheory.Bicategory.Free | {B : Type u} →
[inst : Quiver B] →
{a b c : CategoryTheory.FreeBicategory B} →
{f g : a ⟶ b} →
(h : b ⟶ c) →
CategoryTheory.FreeBicategory.Hom₂ f g →
CategoryTheory.FreeBicategory.Hom₂ (CategoryTheory.FreeBicategory.Hom.comp f h)
(CategoryTheory.FreeBicategory.Hom... | true |
Lean.Core.instMonadLogCoreM | Lean.CoreM | Lean.MonadLog Lean.CoreM | true |
Algebra.trdeg | Mathlib.RingTheory.AlgebraicIndependent.Basic | (R : Type u_2) → (A : Type v) → [inst : CommRing R] → [inst_1 : CommRing A] → [Algebra R A] → Cardinal.{v} | true |
Function.Involutive.rightInverse | Mathlib.Logic.Function.Basic | ∀ {α : Sort u} {f : α → α}, Function.Involutive f → Function.RightInverse f f | true |
CliffordAlgebra.evenEquivEvenNeg._proof_1 | Mathlib.LinearAlgebra.CliffordAlgebra.EvenEquiv | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M), -Q = -Q | false |
smul_le_smul_iff_of_pos_left._simp_1 | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} {a : α} {b₁ b₂ : β} [inst : SMul α β] [inst_1 : Preorder α] [inst_2 : Preorder β]
[inst_3 : Zero α] [PosSMulMono α β] [PosSMulReflectLE α β], 0 < a → (a • b₁ ≤ a • b₂) = (b₁ ≤ b₂) | false |
CategoryTheory.GradedObject.single_map_singleObjApplyIsoOfEq_hom | Mathlib.CategoryTheory.GradedObject.Single | ∀ {J : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_2} C]
[inst_1 : CategoryTheory.Limits.HasInitial C] [inst_2 : DecidableEq J] (j : J) {X Y : C} (f : X ⟶ Y) (i : J)
(h : i = j),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.GradedObject.single j).map f i)
(CategoryTheory.GradedOb... | true |
Lean.Grind.NatModule.one_nsmul | Init.Grind.Module.Basic | ∀ {M : Type u} [inst : Lean.Grind.NatModule M] (a : M), 1 • a = a | true |
Module.Basis.constr_def | Mathlib.LinearAlgebra.Basis.Defs | ∀ {M' : Type u_7} [inst : AddCommMonoid M'] {ι : Type u_10} {R : Type u_11} {M : Type u_12} [inst_1 : Semiring R]
[inst_2 : AddCommMonoid M] [inst_3 : Module R M] (b : Module.Basis ι R M) [inst_4 : Module R M'] (S : Type u_13)
[inst_5 : Semiring S] [inst_6 : Module S M'] [inst_7 : SMulCommClass R S M'] (f : ι → M')... | true |
CategoryTheory.TransfiniteCompositionOfShape.ofComposableArrows_F | Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {n : ℕ} (G : CategoryTheory.ComposableArrows C n),
(CategoryTheory.TransfiniteCompositionOfShape.ofComposableArrows G).F = G | true |
_private.Mathlib.Geometry.Euclidean.Inversion.ImageHyperplane.0.EuclideanGeometry.inversion_mem_perpBisector_inversion_iff._simp_1_7 | Mathlib.Geometry.Euclidean.Inversion.ImageHyperplane | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | false |
AddChar.coe_compAddMonoidHom._simp_1 | Mathlib.Algebra.Group.AddChar | ∀ {A : Type u_1} {B : Type u_2} {M : Type u_3} [inst : AddMonoid A] [inst_1 : AddMonoid B] [inst_2 : Monoid M]
(φ : AddChar B M) (f : A →+ B), ⇑φ ∘ ⇑f = ⇑(φ.compAddMonoidHom f) | false |
CategoryTheory.MonoidalOpposite.mopMopEquivalenceFunctorMonoidal._proof_12 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{X Y : Cᴹᵒᵖᴹᵒᵖ} (f : X ⟶ Y) (X' : Cᴹᵒᵖᴹᵒᵖ),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.id
((CategoryTheory.MonoidalOpposite.mopMopEquivalence C).functor.obj
(Cat... | false |
Lean.Meta.Grind.Split.instInhabitedState | Lean.Meta.Tactic.Grind.Types | Inhabited Lean.Meta.Grind.Split.State | true |
Std.Roo.forIn'_congr | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerableLT α] [inst_4 : Std.Rxo.IsAlwaysFinite α]
[inst_5 : Std.PRange.LawfulUpwardEnumerable α] {m : Type u → Type w} [inst_6 : Monad m] {γ : Type u} {init init' : γ}
{r r' : Std.Roo ... | true |
controlled_closure_range_of_complete | Mathlib.Analysis.Normed.Group.ControlledClosure | ∀ {G : Type u_1} [inst : NormedAddCommGroup G] [CompleteSpace G] {H : Type u_2} [inst_2 : NormedAddCommGroup H]
{f : NormedAddGroupHom G H} {K : Type u_3} [inst_3 : SeminormedAddCommGroup K] {j : NormedAddGroupHom K H},
(∀ (x : K), ‖j x‖ = ‖x‖) →
∀ {C ε : ℝ},
0 < C →
0 < ε → (∀ (k : K), ∃ g, f g =... | true |
Int.closedBall_eq_Icc | Mathlib.Topology.Instances.Int | ∀ (x : ℤ) (r : ℝ), Metric.closedBall x r = Set.Icc ⌈↑x - r⌉ ⌊↑x + r⌋ | true |
BitVec.getLsbD_ofNatLT | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} (x : ℕ) (lt : x < 2 ^ n) (i : ℕ), (x#'lt).getLsbD i = x.testBit i | true |
Fin.get_take_eq_take_get_comp_cast | Mathlib.Data.Fin.Tuple.Take | ∀ {α : Type u_2} {m : ℕ} (l : List α) (h : m ≤ l.length), (List.take m l).get = Fin.take m h l.get ∘ Fin.cast ⋯ | true |
Filter.frequently_true_iff_neBot._simp_1 | Mathlib.Order.Filter.Basic | ∀ {α : Type u} (f : Filter α), (∃ᶠ (x : α) in f, True) = f.NeBot | false |
IsOfFinOrder.unit.eq_1 | Mathlib.GroupTheory.OrderOfElement | ∀ {M : Type u_6} [inst : Monoid M] {x : M} (hx : IsOfFinOrder x),
hx.unit = { val := x, inv := x ^ (orderOf x - 1), val_inv := ⋯, inv_val := ⋯ } | true |
CategoryTheory.MonoidalCategoryStruct.rightUnitor | Mathlib.CategoryTheory.Monoidal.Category | {C : Type u} →
{𝒞 : CategoryTheory.Category.{v, u} C} →
[self : CategoryTheory.MonoidalCategoryStruct C] →
(X : C) →
CategoryTheory.MonoidalCategoryStruct.tensorObj X (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) ≅ X | true |
CategoryTheory.Functor.toCostructuredArrow._proof_2 | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {E : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} E]
(G : CategoryTheory.Functor E C) (F : CategoryTheory.Functor C D) (X : D) (f : (Y : E) → F.obj (G.obj Y) ⟶ X)
(h : ∀ {Y Z : E... | false |
CategoryTheory.AddMon.forget_δ | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X Y : CategoryTheory.AddMon C),
CategoryTheory.Functor.OplaxMonoidal.δ (CategoryTheory.AddMon.forget C) X Y =
CategoryTheory.CategoryStruct.id (CategoryTheory.Mon... | true |
Std.ExtHashSet.getD_eq_fallback_of_contains_eq_false | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashSet α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{a fallback : α}, m.contains a = false → m.getD a fallback = fallback | true |
Mathlib.Tactic.BicategoryLike.Mor₂Iso.isStructural._unsafe_rec | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | Mathlib.Tactic.BicategoryLike.Mor₂Iso → Bool | false |
MeasureTheory.Egorov.notConvergentSeq_antitone | Mathlib.MeasureTheory.Function.Egorov | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : PseudoEMetricSpace β] {n : ℕ} {f : ι → α → β} {g : α → β}
[inst_1 : Preorder ι], Antitone (MeasureTheory.Egorov.notConvergentSeq f g n) | true |
_private.Init.Data.SInt.Lemmas.0.ISize.toInt_ofNat_of_lt_two_pow_numBits._proof_1_1 | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, n < 2147483648 → ¬↑n < 2147483648 → False | false |
_private.Mathlib.LinearAlgebra.Semisimple.0.LinearEquiv.isSemisimple_iff._simp_1_2 | Mathlib.LinearAlgebra.Semisimple | ∀ (R : Type u_2) [inst : Ring R] (M : Type u_4) [inst_1 : AddCommGroup M] [inst_2 : Module R M],
IsSemisimpleModule R M = ComplementedLattice (Submodule R M) | false |
Fin.lt_sub_iff | Mathlib.Algebra.Group.Fin.Basic | ∀ {n : ℕ} {a b : Fin n}, a < a - b ↔ a < b | true |
Function.Injective | Init.Data.Function | {α : Sort u_1} → {β : Sort u_2} → (α → β) → Prop | true |
Lean.Parser.Term.subst._regBuiltin.Lean.Parser.Term.subst.formatter_9 | Lean.Parser.Term | IO Unit | false |
Set.pairwise_iUnion₂ | Mathlib.Data.Set.Pairwise.Lattice | ∀ {α : Type u_1} {s : Set (Set α)},
DirectedOn (fun x1 x2 => x1 ⊆ x2) s → ∀ (r : α → α → Prop), (∀ a ∈ s, a.Pairwise r) → (⋃ a ∈ s, a).Pairwise r | true |
CategoryTheory.ObjectProperty.preservesLimit_iff | Mathlib.CategoryTheory.ObjectProperty.FunctorCategory.PreservesLimits | ∀ {J : Type u_1} {C : Type u_3} (K : Type u_5) [inst : CategoryTheory.Category.{v_1, u_5} K]
[inst_1 : CategoryTheory.Category.{v_3, u_1} J] [inst_2 : CategoryTheory.Category.{v_5, u_3} C]
(F : CategoryTheory.Functor K J) (G : CategoryTheory.Functor J C),
CategoryTheory.ObjectProperty.preservesLimit F G ↔ Categor... | true |
CategoryTheory.Limits.IsLimit.ofIsZero | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} D] →
[CategoryTheory.Limits.HasZeroMorphisms C] →
[CategoryTheory.Limits.HasZeroObject C] →
{F : CategoryTheory.Functor D C} →
(c : CategoryTheory... | true |
_private.Mathlib.Data.Nat.Totient.0.Mathlib.Meta.Positivity.evalNatTotient.match_4 | Mathlib.Data.Nat.Totient | (motive :
(u : Lean.Level) →
{α : Q(Type u)} →
(z : Q(Zero «$α»)) →
(p : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness z p e) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness z p e) → Sort u_1) →
(u : Lean.L... | false |
String.Slice.Pos.prevAux._proof_6 | Init.Data.String.Basic | ∀ {s : String.Slice} (off : ℕ), off + 1 < s.utf8ByteSize → off < s.utf8ByteSize | false |
_private.Mathlib.NumberTheory.Dioph.0.Dioph.diophFn_compn.match_1_1 | Mathlib.NumberTheory.Dioph | ∀ {α : Type} (motive : (x : ℕ) → (x_1 : Set (α ⊕ Fin2 x → ℕ)) → Dioph x_1 → Vector3 ((α → ℕ) → ℕ) x → Prop) (x : ℕ)
(x_1 : Set (α ⊕ Fin2 x → ℕ)) (x_2 : Dioph x_1) (x_3 : Vector3 ((α → ℕ) → ℕ) x),
(∀ (S : Set (α ⊕ Fin2 0 → ℕ)) (d : Dioph S) (f : Vector3 ((α → ℕ) → ℕ) 0), motive 0 S d f) →
(∀ (n : ℕ) (S : Set (α ... | false |
Std.DTreeMap.Internal.Impl.toListModel_interSmallerFn | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} [Std.TransOrd α] [inst : BEq α] [Std.LawfulBEqOrd α]
(m sofar : Std.DTreeMap.Internal.Impl α β),
m.WF →
∀ (h₂ : sofar.WF) (l : List ((a : α) × β a)) (k : α),
sofar.toListModel.Perm l →
(↑(m.interSmallerFn ⟨sofar, ⋯⟩ k)).toListModel.Perm (Std.Internal.Lis... | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.ShiftSequence.0.CochainComplex.instShiftSequenceHomologicalComplexIntUpHomologyFunctorOfNat._simp_4 | Mathlib.Algebra.Homology.HomotopyCategory.ShiftSequence | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ S₃ : CategoryTheory.ShortComplex C} [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology]
[inst_4 : S₃.HasHomology] (φ₁ : S₁ ⟶ S₂) (φ₂ : S₂ ⟶ S₃),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Sh... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.