name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Limits.isLimitConeOfCoconeUnop._proof_1 | Mathlib.CategoryTheory.Limits.Opposites | ∀ {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] (F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ)
{c : CategoryTheory.Limits.Cocone F.unop} (hc : CategoryTheory.Limits.IsColimit c) (s : CategoryTheory.Limits.Cone F)
(j : Jᵒᵖ),
(CategoryTheory.Cate... | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getKey!_insertManyIfNewUnit_list_of_mem._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
_private.BatteriesRecycling.RBTree.WF.0.RBTree.RBNode.balLeft.match_4.eq_2 | BatteriesRecycling.RBTree.WF | ∀ {α : Type u_1} (motive : RBTree.RBNode α → Sort u_2) (l : RBTree.RBNode α)
(h_1 : (a : RBTree.RBNode α) → (x : α) → (b : RBTree.RBNode α) → motive (RBTree.RBNode.node RBTree.RBColor.red a x b))
(h_2 : (l : RBTree.RBNode α) → motive l),
(∀ (a : RBTree.RBNode α) (x : α) (b : RBTree.RBNode α), l = RBTree.RBNode.no... | null | true |
PythagoreanTriple.mul_isClassified | Mathlib.NumberTheory.PythagoreanTriples | ∀ {x y z : ℤ} (h : PythagoreanTriple x y z) (k : ℤ), h.IsClassified → ⋯.IsClassified | null | true |
Std.Packages.LinearPreorderOfOrdArgs.decidableLT._autoParam | Init.Data.Order.PackageFactories | Lean.Syntax | null | false |
_private.Mathlib.Tactic.TFAE.0.Mathlib.Tactic.TFAE.getTFAEList.match_1 | Mathlib.Tactic.TFAE | (motive : Lean.Expr → Sort u_1) →
(__discr : Lean.Expr) →
((tfae : Lean.Expr) → (l : Q(List Prop)) → motive (tfae.app l)) → ((x : Lean.Expr) → motive x) → motive __discr | null | false |
Pi.isAtom_iff | Mathlib.Order.Atoms | ∀ {ι : Type u_4} {π : ι → Type u} {f : (i : ι) → π i} [inst : (i : ι) → PartialOrder (π i)]
[inst_1 : (i : ι) → OrderBot (π i)], IsAtom f ↔ ∃ i, IsAtom (f i) ∧ ∀ (j : ι), j ≠ i → f j = ⊥ | null | true |
ULift.leftCancelSemigroup.eq_1 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u} [inst : LeftCancelSemigroup α],
ULift.leftCancelSemigroup = Function.Injective.leftCancelSemigroup ⇑Equiv.ulift ⋯ ⋯ | null | true |
_private.Mathlib.MeasureTheory.Function.LpSeminorm.SMul.0.MeasureTheory.eLpNormEssSup_const_smul_le._simp_1_1 | Mathlib.MeasureTheory.Function.LpSeminorm.SMul | ∀ {α : Type u_1} {β : Type u_2} [inst : SeminormedAddGroup α] [inst_1 : SeminormedAddGroup β]
[inst_2 : SMulZeroClass α β] [IsBoundedSMul α β] (r : α) (x : β), (‖r • x‖₊ ≤ ‖r‖₊ * ‖x‖₊) = True | null | false |
AlgebraicGeometry.StructureSheaf.isLocalizedModule_toPushforwardStalkAlgHom_aux | Mathlib.AlgebraicGeometry.Spec | ∀ (R S : CommRingCat) (p : PrimeSpectrum ↑R) [inst : Algebra ↑R ↑S]
(y :
↑(((TopCat.Presheaf.pushforward CommRingCat
(AlgebraicGeometry.Spec.topMap (CommRingCat.ofHom (algebraMap ↑R ↑S)))).obj
(AlgebraicGeometry.Spec.structureSheaf ↑S).obj).stalk
p)),
∃ x, x.2 • y = (Algebrai... | null | true |
_private.Mathlib.NumberTheory.ModularForms.CongruenceSubgroups.0.CongruenceSubgroup.conjGL_coe._simp_1_4 | Mathlib.NumberTheory.ModularForms.CongruenceSubgroups | ∀ {α : Type u_1} {G : Type u_2} [inst : Group G] [inst_1 : Group α] [inst_2 : MulDistribMulAction α G] {a : α}
{S : Subgroup G} {x : G}, (x ∈ a⁻¹ • S) = (a • x ∈ S) | null | false |
UInt32.ne_of_toBitVec_ne | Init.Data.UInt.Lemmas | ∀ {a b : UInt32}, a.toBitVec ≠ b.toBitVec → a ≠ b | null | true |
HasFPowerSeriesOnBall.differentiableOn | Mathlib.Analysis.Calculus.FDeriv.Analytic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type v} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
{p : FormalMultilinearSeries 𝕜 E F} {r : ENNReal} {f : E → F} {x : E} [CompleteSpace F],
HasFPowerSeriesOnBall f ... | null | true |
CategoryTheory.Bicategory.precomp | Mathlib.CategoryTheory.Bicategory.Basic | {B : Type u} →
[inst : CategoryTheory.Bicategory B] → {a b : B} → (c : B) → (a ⟶ b) → CategoryTheory.Functor (b ⟶ c) (a ⟶ c) | Precomposition of a 1-morphism as a functor. | true |
Padic.padicNormE.image | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {q : ℚ_[p]}, q ≠ 0 → ∃ n, ‖q‖ = ↑(↑p ^ (-n)) | null | true |
le_imp_le_of_le_of_le | Mathlib.Order.Basic | ∀ {α : Type u_2} [inst : Preorder α] {a b c d : α}, c ≤ a → b ≤ d → a ≤ b → c ≤ d | monotonicity of `≤` with respect to `→` | true |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.getStackEntries.isIgnoredArg | Mathlib.Lean.Meta.RefinedDiscrTree.Encode | Lean.Expr → Lean.Expr → Lean.BinderInfo → Lean.MetaM Bool | Determine whether the argument should be ignored. | true |
CategoryTheory.Limits.HasPushout | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → {X Y Z : C} → (X ⟶ Y) → (X ⟶ Z) → Prop | Two morphisms `f : X ⟶ Y` and `g : X ⟶ Z` have a pushout if the diagram `span f g` has a
colimit. | true |
_private.Std.Data.String.ToInt.0.String.Slice.isInt_congr._simp_1_1 | Std.Data.String.ToInt | ∀ {s : String.Slice}, s.isInt = s.toInt?.isSome | null | false |
Lean.Grind.AC.Context.rec | Init.Grind.AC | {α : Sort u} →
{motive : Lean.Grind.AC.Context α → Sort u_1} →
((vars : Lean.RArray (PLift α)) → (op : α → α → α) → motive { vars := vars, op := op }) →
(t : Lean.Grind.AC.Context α) → motive t | null | false |
AddCommGrpCat.addCommGroupObj._aux_1 | Mathlib.Algebra.Category.Grp.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_2, u_3} J] →
(F : CategoryTheory.Functor J AddCommGrpCat) → (j : J) → Add ((F.comp (CategoryTheory.forget AddCommGrpCat)).obj j) | null | false |
Algebra.TensorProduct.algebraMap_def | Mathlib.RingTheory.TensorProduct.Basic | ∀ {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : Semiring B] [inst_4 : Algebra R B] [inst_5 : CommSemiring S] [inst_6 : Algebra S A]
[inst_7 : SMulCommClass R S A],
algebraMap S (TensorProduct R A B) = Algebra.TensorProduct.in... | null | true |
Mathlib.Tactic.TermCongr.mkIffForExpectedType | Mathlib.Tactic.TermCongr | Option Lean.Expr → Lean.MetaM Lean.Expr | Ensures the expected type is an iff. Returns the iff.
This expression satisfies `Lean.Expr.iff?`. | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastCpopLayerTarget.w | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Cpop | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} → {outWidth : ℕ} → Std.Tactic.BVDecide.BVExpr.bitblast.blastCpopLayerTarget aig outWidth → ℕ | null | true |
SchwartzMap.ctorIdx | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | {E : Type u_5} →
{F : Type u_6} →
{inst : NormedAddCommGroup E} →
{inst_1 : NormedSpace ℝ E} → {inst_2 : NormedAddCommGroup F} → {inst_3 : NormedSpace ℝ F} → SchwartzMap E F → ℕ | null | false |
Std.Http.Protocol.H1.Reader.messageCount | Std.Http.Protocol.H1.Reader | {dir : Std.Http.Protocol.H1.Direction} → Std.Http.Protocol.H1.Reader dir → ℕ | Count of messages that this connection has already parsed.
| true |
_private.Mathlib.Algebra.ContinuedFractions.TerminatedStable.0.GenContFract.contsAux.match_1.splitter | Mathlib.Algebra.ContinuedFractions.TerminatedStable | {K : Type u_1} →
(motive : Option (GenContFract.Pair K) → Sort u_2) →
(x : Option (GenContFract.Pair K)) →
(Unit → motive none) → ((gp : GenContFract.Pair K) → motive (some gp)) → motive x | null | true |
instCompleteLatticeUniformSpace._proof_6 | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type u_1} (a x x_1 : UniformSpace α), a ≤ x → a ≤ x_1 → UniformSpace.uniformity ≤ uniformity α | null | false |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_364 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α)
(h_5 : 2 ≤ List.count w_1 [g a, g (g a)]),
(List.findIdxs (fun x => decide (x = w_1))
[g a, g (g a)])[List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w_1 [g a, g (g a)] 1)] +
1 ≤
List.findIdx (fun x => decide ... | null | false |
CategoryTheory.Pretopology.gi | Mathlib.CategoryTheory.Sites.Pretopology | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasPullbacks C] →
GaloisInsertion CategoryTheory.Pretopology.toGrothendieck CategoryTheory.GrothendieckTopology.toPretopology | We have a Galois insertion from pretopologies to Grothendieck topologies. | true |
Std.HashSet.filter_equiv_self_iff | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashSet α} [EquivBEq α] [LawfulHashable α] {f : α → Bool},
(Std.HashSet.filter f m).Equiv m ↔ ∀ (k : α) (h : k ∈ m), f (m.get k h) = true | null | true |
Subgroup.normalCore_le | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G), H.normalCore ≤ H | null | true |
CategoryTheory.Limits.instHasCokernelFromSubtype | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {K : Type}
[inst_2 : Finite K] [inst_3 : CategoryTheory.Limits.HasFiniteBiproducts C] (f : K → C) (p : K → Prop),
CategoryTheory.Limits.HasCokernel (CategoryTheory.Limits.biproduct.fromSubtype f p) | null | true |
Equiv.ofRightInverseOfCardLE_apply | Mathlib.Data.Fintype.EquivFin | ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β] (hαβ : Fintype.card α ≤ Fintype.card β)
(f : α → β) (g : β → α) (h : Function.RightInverse g f) (a : α), (Equiv.ofRightInverseOfCardLE hαβ f g h) a = f a | null | true |
lt_of_mul_lt_mul_of_nonneg_right | Mathlib.Algebra.Order.GroupWithZero.Defs | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Zero α] [inst_2 : Preorder α] {a b c : α} [MulPosReflectLT α],
b * a < c * a → 0 ≤ a → b < c | **Alias** of `lt_of_mul_lt_mul_right`. | true |
NonUnitalSubalgebra.instModule._proof_1 | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A],
IsScalarTower R R A | null | false |
PiTensorProduct.map₂_tprod_tprod | Mathlib.LinearAlgebra.PiTensorProduct | ∀ {ι : Type u_1} {R : Type u_4} [inst : CommSemiring R] {s : ι → Type u_7} [inst_1 : (i : ι) → AddCommMonoid (s i)]
[inst_2 : (i : ι) → Module R (s i)] {t : ι → Type u_11} {t' : ι → Type u_12} [inst_3 : (i : ι) → AddCommMonoid (t i)]
[inst_4 : (i : ι) → Module R (t i)] [inst_5 : (i : ι) → AddCommMonoid (t' i)] [ins... | null | true |
CategoryTheory.subcanonical_typesGrothendieckTopology | Mathlib.CategoryTheory.Sites.Types | CategoryTheory.typesGrothendieckTopology.Subcanonical | null | true |
CategoryTheory.Limits.CompleteLattice.finiteLimitCone_isLimit_lift | Mathlib.CategoryTheory.Limits.Lattice | ∀ {α : Type u} {J : Type w} [inst : CategoryTheory.SmallCategory J] [inst_1 : CategoryTheory.FinCategory J]
[inst_2 : SemilatticeInf α] [inst_3 : OrderTop α] (F : CategoryTheory.Functor J α) (s : CategoryTheory.Limits.Cone F),
(CategoryTheory.Limits.CompleteLattice.finiteLimitCone F).isLimit.lift s = CategoryTheory... | null | true |
List.countP_cons_of_neg | Init.Data.List.Count | ∀ {α : Type u_1} {p : α → Bool} {a : α} {l : List α}, ¬p a = true → List.countP p (a :: l) = List.countP p l | null | true |
_private.Mathlib.Topology.UniformSpace.Cauchy.0.isComplete_iff_ultrafilter'._simp_1_1 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} {s : Set α} {f : Filter α}, (f ≤ Filter.principal s) = (s ∈ f) | null | false |
CauSeq.coe_smul._simp_1 | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α]
[inst_3 : Ring β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] {G : Type u_3} [inst_5 : SMul G β]
[inst_6 : IsScalarTower G β β] (a : G) (f : CauSeq β abv), a • ↑f = ↑(a • f) | null | false |
Std.TreeMap.maxKey_le_maxKey_insert | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α} {v : β}
{he : t.isEmpty = false}, (cmp (t.maxKey he) ((t.insert k v).maxKey ⋯)).isLE = true | null | true |
StrongDual.extendRCLikeₗ._proof_7 | Mathlib.Analysis.RCLike.Extend | ContinuousConstSMul ℝ ℝ | null | false |
Aesop.RuleBuilderOptions.mk | Aesop.Builder.Basic | Option (Array Lean.Name) →
Option Aesop.IndexingMode →
Option (Array Aesop.CasesPattern) →
Option Lean.Term →
Option Lean.Meta.TransparencyMode → Option Lean.Meta.TransparencyMode → Aesop.RuleBuilderOptions | null | true |
MeasureTheory.setLIntegral_congr_fun | Mathlib.MeasureTheory.Integral.Lebesgue.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → ENNReal} {s : Set α},
MeasurableSet s → Set.EqOn f g s → ∫⁻ (x : α) in s, f x ∂μ = ∫⁻ (x : α) in s, g x ∂μ | null | true |
_private.Lean.Meta.Tactic.Simp.SimpTheorems.0.Lean.Meta.preprocess | Lean.Meta.Tactic.Simp.SimpTheorems | Lean.Expr → Lean.Expr → Bool → Bool → Lean.MetaM (List (Lean.Expr × Lean.Expr)) | null | true |
CategoryTheory.Limits.Cowedge.ext._auto_1 | Mathlib.CategoryTheory.Limits.Shapes.End | Lean.Syntax | null | false |
OrderedFinpartition.compAlongOrderedFinpartitionL_apply | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type u_4}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {n : ℕ} (c : OrderedFinpartition n)
... | null | true |
TensorProduct.directSum._proof_11 | Mathlib.LinearAlgebra.DirectSum.TensorProduct | ∀ (R : Type u_6) [inst : CommSemiring R] (S : Type u_5) [inst_1 : Semiring S] [inst_2 : Algebra R S] {ι₁ : Type u_1}
{ι₂ : Type u_3} [inst_3 : DecidableEq ι₁] [inst_4 : DecidableEq ι₂] (M₁ : ι₁ → Type u_2) (M₂ : ι₂ → Type u_4)
[inst_5 : (i₁ : ι₁) → AddCommMonoid (M₁ i₁)] [inst_6 : (i₂ : ι₂) → AddCommMonoid (M₂ i₂)]... | null | false |
Fin.succAbove_ne_zero_zero | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} [inst : NeZero n] {a : Fin (n + 1)}, a ≠ 0 → a.succAbove 0 = 0 | null | true |
CategoryTheory.Limits.biconeIsBilimitOfColimitCoconeOfIsColimit._proof_1 | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Preadditive C] {J : Type u_1}
{f : J → C} {t : CategoryTheory.Limits.Cocone (CategoryTheory.Discrete.functor f)}
(ht : CategoryTheory.Limits.IsColimit t) (j : CategoryTheory.Discrete J),
CategoryTheory.CategoryStruct.comp (t.ι... | null | false |
Std.Iter.Total.ctorIdx | Init.Data.Iterators.Consumers.Total | {α β : Type w} → Std.Iter.Total β → ℕ | null | false |
AddMonoidAlgebra.supportedEquivFinsupp._proof_11 | Mathlib.Algebra.MonoidAlgebra.Module | ∀ {R : Type u_3} {M : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : Module R S]
(s : Set M) (x : ↥(Finsupp.supported S R s)),
⟨(↑⟨AddMonoidAlgebra.ofCoeff ↑x, ⋯⟩).coeff, ⋯⟩ = ⟨(↑⟨AddMonoidAlgebra.ofCoeff ↑x, ⋯⟩).coeff, ⋯⟩ | null | false |
isLocalMax_of_deriv | Mathlib.Analysis.Calculus.DerivativeTest | ∀ {f : ℝ → ℝ} {b : ℝ},
ContinuousAt f b →
(∀ᶠ (x : ℝ) in nhdsWithin b {b}ᶜ, DifferentiableAt ℝ f x) →
(∀ᶠ (x : ℝ) in nhdsWithin b (Set.Iio b), 0 ≤ deriv f x) →
(∀ᶠ (x : ℝ) in nhdsWithin b (Set.Ioi b), deriv f x ≤ 0) → IsLocalMax f b | The First Derivative test, maximum version. | true |
BoundedContinuousFunction.instAddZeroClass | Mathlib.Topology.ContinuousMap.Bounded.Basic | {α : Type u} →
{R : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : PseudoMetricSpace R] →
[inst_2 : AddZeroClass R] → [BoundedAdd R] → [ContinuousAdd R] → AddZeroClass (BoundedContinuousFunction α R) | null | true |
instPartialOrderEReal._proof_8 | Mathlib.Data.EReal.Basic | ∀ (a b : EReal), a ≤ b → b ≤ a → a = b | null | false |
LieModule.maxTrivLinearMapEquivLieModuleHom._proof_10 | Mathlib.Algebra.Lie.Abelian | ∀ {R : Type u_3} {L : Type u_4} {M : Type u_1} {N : Type u_2} [inst : CommRing R] [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]
[ins... | null | false |
SubringClass.toNonAssocRing | Mathlib.Algebra.Ring.Subring.Defs | {R : Type u} →
{S : Type v} → [inst : NonAssocRing R] → [inst_1 : SetLike S R] → [hSR : SubringClass S R] → (s : S) → NonAssocRing ↥s | A subring of a non-unital ring inherits a non-unital ring structure | true |
_private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basic.0.RootPairing.GeckConstruction.ωConj._simp_4 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basic | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | null | false |
LinearEquiv.finTwoArrow_apply | Mathlib.LinearAlgebra.Pi | ∀ (R : Type u) (M : Type v) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
⇑(LinearEquiv.finTwoArrow R M) = fun f => (f 0, f 1) | null | true |
NNRat.cast_lt_natCast._simp_1 | Mathlib.Data.Rat.Cast.Order | ∀ {K : Type u_5} [inst : Semifield K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] {m : ℚ≥0} {n : ℕ},
(↑m < ↑n) = (m < ↑n) | null | false |
MulChar.ofUnitHom.eq_1 | Mathlib.NumberTheory.MulChar.Basic | ∀ {R : Type u_1} [inst : CommMonoid R] {R' : Type u_2} [inst_1 : CommMonoidWithZero R'] (f : Rˣ →* R'ˣ),
MulChar.ofUnitHom f =
{ toFun := fun x => if hx : IsUnit x then ↑(f hx.unit) else 0, map_one' := ⋯, map_mul' := ⋯, map_nonunit' := ⋯ } | null | true |
CStarMatrix.map_map | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_5} {B : Type u_6} {C : Type u_7} {M : Matrix m n A} {f : A → B} {g : B → C},
(M.map f).map g = M.map (g ∘ f) | null | true |
Lean.Grind.ToInt.Zero.casesOn | Init.Grind.ToInt | {α : Type u} →
[inst : Zero α] →
{I : Lean.Grind.IntInterval} →
[inst_1 : Lean.Grind.ToInt α I] →
{motive : Lean.Grind.ToInt.Zero α I → Sort u_1} →
(t : Lean.Grind.ToInt.Zero α I) → ((toInt_zero : ↑0 = 0) → motive ⋯) → motive t | null | false |
AddLocalization.le._proof_1 | Mathlib.GroupTheory.MonoidLocalization.Order | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [IsOrderedCancelAddMonoid α] {s : AddSubmonoid α}
{a₁ b₁ : α} {a₂ b₂ : ↥s} {c₁ d₁ : α} {c₂ d₂ : ↥s},
(AddLocalization.r s) (a₁, a₂) (b₁, b₂) →
(AddLocalization.r s) (c₁, c₂) (d₁, d₂) → (↑c₂ + a₁ ≤ ↑a₂ + c₁) = (↑d₂ + b₁ ≤ ↑b₂ + d₁) | null | false |
ModelPi | Mathlib.Geometry.Manifold.ChartedSpace | {ι : Type u_5} → (ι → Type u_6) → Type (max u_5 u_6) | Same thing as `∀ i, H i`. We introduce it for technical reasons,
see note [Manifold type tags]. | true |
CategoryTheory.Square.commSq | Mathlib.CategoryTheory.Square | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C),
CategoryTheory.CommSq sq.f₁₂ sq.f₁₃ sq.f₂₄ sq.f₃₄ | null | true |
_private.Mathlib.Tactic.Simproc.Factors.0.Nat.primeFactorsList_ofNat.match_3 | Mathlib.Tactic.Simproc.Factors | (motive :
(u : Lean.Level) →
(α : Q(Sort u)) →
(e : Q(«$α»)) →
Lean.Meta.SimpM (Lean.Meta.Simp.StepQ e) → Lean.Meta.SimpM (Lean.Meta.Simp.StepQ e) → Sort u_1) →
(u : Lean.Level) →
(α : Q(Sort u)) →
(e : Q(«$α»)) →
(__alt __alt_1 : Lean.Meta.SimpM (Lean.Meta.Simp.StepQ e))... | null | false |
Std.ExtTreeMap.contains_eq_isSome_getElem? | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {a : α},
t.contains a = t[a]?.isSome | null | true |
LieSubalgebra.coe_sInf | Mathlib.Algebra.Lie.Subalgebra | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(S : Set (LieSubalgebra R L)), ↑(sInf S) = ⋂ s ∈ S, ↑s | null | true |
_private.Lean.Elab.Tactic.Grind.Sym.0.Lean.Elab.Tactic.Grind.evalSymSimp | Lean.Elab.Tactic.Grind.Sym | Lean.Elab.Tactic.Grind.GrindTactic | null | true |
_private.Mathlib.Tactic.TermCongr.0.Mathlib.Tactic.TermCongr.CongrResult.mk'.toEqPf | Mathlib.Tactic.TermCongr | Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr | Given a `pf` of an `Iff`, `Eq`, or `HEq`, return a proof of `Eq`.
If `pf` is not obviously any of these, weakly try inserting `propext` to make an `Iff`
and otherwise unify the type with `Eq`. | true |
OrderAddMonoidHom.comp | Mathlib.Algebra.Order.Hom.Monoid | {α : Type u_2} →
{β : Type u_3} →
{γ : Type u_4} →
[inst : Preorder α] →
[inst_1 : Preorder β] →
[inst_2 : Preorder γ] →
[inst_3 : AddZeroClass α] →
[inst_4 : AddZeroClass β] → [inst_5 : AddZeroClass γ] → (β →+o γ) → (α →+o β) → α →+o γ | Composition of `OrderAddMonoidHom`s as an `OrderAddMonoidHom` | true |
_private.Mathlib.Tactic.Widget.LibraryRewrite.0.Mathlib.Tactic.LibraryRewrite.mkRewrite.match_1 | Mathlib.Tactic.Widget.LibraryRewrite | (motive : Option Lean.Syntax → Sort u_1) →
(x : Option Lean.Syntax) → ((x : Lean.Syntax) → motive (some x)) → (Unit → motive none) → motive x | null | false |
Int8.toInt_ofNat' | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, (Int8.ofNat n).toInt = (↑n).bmod Int8.size | null | true |
Aesop.ForwardHypData.noConfusion | Aesop.RuleTac.Forward.Basic | {P : Sort u} → {t t' : Aesop.ForwardHypData} → t = t' → Aesop.ForwardHypData.noConfusionType P t t' | null | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape.0.CategoryTheory.TransfiniteCompositionOfShape.map._simp_3 | Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | null | false |
AugmentedSimplexCategory.equivAugmentedCosimplicialObject_functor_map_left | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C]
{X Y : CategoryTheory.Functor (CategoryTheory.WithInitial SimplexCategory) C} (η : X ⟶ Y),
(AugmentedSimplexCategory.equivAugmentedCosimplicialObject.functor.map η).left = η.app CategoryTheory.WithInitial.star | null | true |
OrderHom.coe_antisymmetrization | Mathlib.Order.Antisymmetrization | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (f : α →o β),
⇑f.antisymmetrization = Quotient.map' ⇑f ⋯ | null | true |
Lean.ModuleSetup.mk.sizeOf_spec | Lean.Setup | ∀ (name : Lean.Name) (package? : Option Lean.PkgId) (isModule : Bool) (imports? : Option (Array Lean.Import))
(importArts : Lean.NameMap Lean.ImportArtifacts) (dynlibs : Array System.FilePath) (plugins : Array Lean.Plugin)
(options : Lean.LeanOptions),
sizeOf
{ name := name, package? := package?, isModule :... | null | true |
isCancelMul_iff | Mathlib.Algebra.Group.Defs | ∀ (G : Type u) [inst : Mul G], IsCancelMul G ↔ IsLeftCancelMul G ∧ IsRightCancelMul G | null | true |
Lean.Lsp.SignatureHelpTriggerKind.contentChange.elim | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SignatureHelpTriggerKind → Sort u} →
(t : Lean.Lsp.SignatureHelpTriggerKind) →
t.ctorIdx = 2 → motive Lean.Lsp.SignatureHelpTriggerKind.contentChange → motive t | null | false |
_private.Mathlib.RingTheory.Kaehler.Basic.0.KaehlerDifferential.kerTotal_mkQ_single_mul._simp_1_1 | Mathlib.RingTheory.Kaehler.Basic | ∀ {α : Type u_1} {M : Type u_5} {R : Type u_11} [inst : Zero M] [inst_1 : SMulZeroClass R M] (c : R) (a : α) (b : M),
(fun₀ | a => c • b) = c • fun₀ | a => b | null | false |
_private.Mathlib.GroupTheory.CoprodI.0.Monoid.CoprodI.Word.mem_rcons_iff._proof_1_13 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] [inst_1 : (i : ι) → DecidableEq (M i)] {i j : ι}
(p : Monoid.CoprodI.Word.Pair M i) (m : M j),
⟨j, m⟩ ∈
(if h : p.head = 1 then p.tail
else { toList := ⟨i, p.head⟩ :: p.tail.toList, ne_one := ⋯, chain_ne := ⋯ }).toList ↔
⟨j, m⟩ ∈ ... | null | false |
_private.Lean.Meta.Sym.Simp.Theorems.0.Lean.Meta.Sym.Simp.isPerm.match_1 | Lean.Meta.Sym.Simp.Theorems | (motive : Except Unit (Unit × Array (Option ℕ)) → Sort u_1) →
(x : Except Unit (Unit × Array (Option ℕ))) →
((a : Unit × Array (Option ℕ)) → motive (Except.ok a)) →
((x : Except Unit (Unit × Array (Option ℕ))) → motive x) → motive x | null | false |
Matrix.linearIndependent_rows_of_invertible | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {m : Type u} [inst : DecidableEq m] {K : Type u_3} [inst_1 : Field K] [inst_2 : Fintype m] (A : Matrix m m K)
[Invertible A], LinearIndependent K A.row | null | true |
CategoryTheory.ShortComplex.SnakeInput.functorP_obj | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C), CategoryTheory.ShortComplex.SnakeInput.functorP.obj S = S.P | null | true |
HNNExtension.NormalWord.noConfusion | Mathlib.GroupTheory.HNNExtension | {P : Sort u} →
{G : Type u_1} →
{inst : Group G} →
{A B : Subgroup G} →
{d : HNNExtension.NormalWord.TransversalPair G A B} →
{t : HNNExtension.NormalWord d} →
{G' : Type u_1} →
{inst' : Group G'} →
{A' B' : Subgroup G'} →
{d' : H... | null | false |
CategoryTheory.Limits.BinaryBicone.instIsSplitEpiSnd | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{P Q : C} (c : CategoryTheory.Limits.BinaryBicone P Q), CategoryTheory.IsSplitEpi c.snd | null | true |
Lean.Grind.instOfNatInt16SintOfNatNat | Init.GrindInstances.ToInt | Lean.Grind.ToInt.OfNat Int16 (Lean.Grind.IntInterval.sint 16) | null | true |
CategoryTheory.Functor.CorepresentableBy.isoCoreprX | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{F : CategoryTheory.Functor C (Type v)} →
[hF : F.IsCorepresentable] → {Y : C} → F.CorepresentableBy Y → (Y ≅ F.coreprX) | Any corepresenting object for a corepresentable functor `F` is isomorphic to `coreprX F`. | true |
Matrix.toLinOfInv._proof_1 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_3} [inst : CommSemiring R] {m : Type u_4} {n : Type u_5} [inst_1 : Fintype n] [inst_2 : DecidableEq n]
{M₁ : Type u_1} {M₂ : Type u_2} [inst_3 : AddCommMonoid M₁] [inst_4 : AddCommMonoid M₂] [inst_5 : Module R M₁]
[inst_6 : Module R M₂] (v₁ : Module.Basis n R M₁) (v₂ : Module.Basis m R M₂) [inst_7 : F... | null | false |
Lean.Expr.ReplaceLevelImpl.State._sizeOf_inst | Lean.Util.ReplaceLevel | SizeOf Lean.Expr.ReplaceLevelImpl.State | null | false |
List.Sublist.findIdx?_isSome | Init.Data.List.Find | ∀ {α : Type u_1} {p : α → Bool} {l₁ l₂ : List α},
l₁.Sublist l₂ → (List.findIdx? p l₁).isSome = true → (List.findIdx? p l₂).isSome = true | null | true |
Nat.bit_lt_bit | Mathlib.Data.Nat.Bits | ∀ {m n : ℕ} (a b : Bool), m < n → Nat.bit a m < Nat.bit b n | null | true |
_private.Mathlib.Data.Finset.Dedup.0.Multiset.toFinset_subset._simp_1_1 | Mathlib.Data.Finset.Dedup | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂ | null | false |
CategoryTheory.SimplicialThickening.Path.rec | Mathlib.AlgebraicTopology.SimplicialNerve | {J : Type u_1} →
[inst : LinearOrder J] →
{i j : J} →
{motive : CategoryTheory.SimplicialThickening.Path i j → Sort u} →
((I : Set J) →
(left : i ∈ I) →
(right : j ∈ I) →
(left_le : ∀ k ∈ I, i ≤ k) →
(le_right : ∀ k ∈ I, k ≤ j) →
... | null | false |
OpenPartialHomeomorph.mapsTo_symm | Mathlib.Topology.OpenPartialHomeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
(e : OpenPartialHomeomorph X Y), Set.MapsTo (↑e.symm) e.target e.source | null | true |
Matrix.uniqueAlgEquiv | Mathlib.LinearAlgebra.Matrix.Unique | {m : Type u_1} →
{A : Type u_3} →
{R : Type u_4} →
[inst : Unique m] →
[inst_1 : Semiring A] → [inst_2 : CommSemiring R] → [inst_3 : Algebra R A] → Matrix m m A ≃ₐ[R] A | `M₁(A)` is equivalent to `A` as an `R`-algebra. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.