name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Analysis.InnerProductSpace.NormDet.0.LinearMap.normDet_eq_zero_iff_ker_ne_bot._simp_1_2 | Mathlib.Analysis.InnerProductSpace.NormDet | ∀ {R : Type u_1} [inst : CommSemiring R] {l : Type u_2} {m : Type u_3} {n : Type u_4} [inst_1 : Fintype n]
[inst_2 : DecidableEq n] {M₁ : Type u_5} {M₂ : Type u_6} [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 ... | null | false |
le_sup_sdiff_sup_sdiff._to_dual_2 | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedHeytingAlgebra α] {a b c : α}, b ⊓ ((c ⇨ a) ⊓ (b ⇨ c)) ≤ a | null | false |
Matrix.PosSemidef.nonneg | Mathlib.Analysis.Matrix.Order | ∀ {𝕜 : Type u_1} {n : Type u_2} [inst : RCLike 𝕜] {A : Matrix n n 𝕜}, A.PosSemidef → 0 ≤ A | **Alias** of the reverse direction of `Matrix.nonneg_iff_posSemidef`. | true |
Monoid.CoprodI.Word.empty._proof_1 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)], ∀ l ∈ [], l.snd ≠ 1 | null | false |
Lean.Lsp.MarkupKind.rec | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.MarkupKind → Sort u} →
motive Lean.Lsp.MarkupKind.plaintext → motive Lean.Lsp.MarkupKind.markdown → (t : Lean.Lsp.MarkupKind) → motive t | null | false |
NonUnitalAlgHom.prod._proof_2 | Mathlib.Algebra.Algebra.NonUnitalHom | ∀ {R : Type u_4} [inst : Monoid R] {A : Type u_3} {B : Type u_1} {C : Type u_2} [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : DistribMulAction R A] [inst_3 : NonUnitalNonAssocSemiring B] [inst_4 : NonUnitalNonAssocSemiring C]
[inst_5 : DistribMulAction R B] [inst_6 : DistribMulAction R C] (f : A →ₙₐ[R] B) (g : A... | null | false |
Matroid.IsNonloop.contractElem_indep_iff | Mathlib.Combinatorics.Matroid.Minor.Contract | ∀ {α : Type u_1} {M : Matroid α} {e : α} {I : Set α},
M.IsNonloop e → ((M.contract {e}).Indep I ↔ e ∉ I ∧ M.Indep (insert e I)) | null | true |
IsCoprime.add_mul_left_left_iff | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u} [inst : CommRing R] {x y z : R}, IsCoprime (x + y * z) y ↔ IsCoprime x y | null | true |
IsSuccArchimedean.linearOrder._proof_4 | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : DecidableLE α] (a b : α),
(if a ≤ b then b else a) = if a ≤ b then b else a | null | false |
_private.Mathlib.RingTheory.Valuation.Basic.0.Valuation.map_sub_of_left_eq_zero._simp_1_1 | Mathlib.RingTheory.Valuation.Basic | ∀ {α : Type u_1} {a : α} [inst : PartialOrder α] [inst_1 : Zero α] [IsBotZeroClass α], (0 < a) = (a ≠ 0) | null | false |
normalClosure_def | Mathlib.FieldTheory.Normal.Closure | ∀ (F : Type u_1) (K : Type u_2) (L : Type u_3) [inst : Field F] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra F K] [inst_4 : Algebra F L], IntermediateField.normalClosure F K L = ⨆ f, f.fieldRange | null | true |
Std.Iter.find? | Init.Data.Iterators.Consumers.Loop | {α β : Type w} → [inst : Std.Iterator α Id β] → [Std.IteratorLoop α Id Id] → Std.Iter β → (β → Bool) → Option β | Returns the first output of the iterator for which the predicate `p` returns `true`, or `none` if
no such output is found.
`O(|it|)`. Short-circuits upon encountering the first match. The elements in `it` are examined in
order of iteration.
If the iterator is not finite, this function might run forever. The variant
`... | true |
Nat.one_lt_of_mem_primesBelow | Mathlib.NumberTheory.PrimeCounting | ∀ {p n : ℕ}, p ∈ n.primesBelow → 1 < p | null | true |
_private.Mathlib.Topology.Instances.Real.Lemmas.0.Real.isTopologicalBasis_Ioo_rat.match_1_3 | Mathlib.Topology.Instances.Real.Lemmas | ∀ (a w : ℝ) (motive : (∃ q, a < ↑q ∧ ↑q < w) → Prop) (x : ∃ q, a < ↑q ∧ ↑q < w),
(∀ (p : ℚ) (hap : a < ↑p) (hpu : ↑p < w), motive ⋯) → motive x | null | false |
Condensed.isoLocallyConstantOfIsColimit | Mathlib.Condensed.Discrete.Colimit | (F : CategoryTheory.Functor Profiniteᵒᵖ (Type (u + 1))) →
[CategoryTheory.Limits.PreservesFiniteProducts F] →
((S : Profinite) → CategoryTheory.Limits.IsColimit (F.mapCocone S.asLimitCone.op)) →
(F ≅ Condensed.locallyConstantPresheaf (F.obj (FintypeCat.toProfinite.op.obj (Opposite.op ↧PUnit.{u + 1})))) | A presheaf `F`, which takes a profinite set written as a cofiltered limit to the corresponding
colimit, is isomorphic to the presheaf `LocallyConstant - F(*)`.
| true |
Submodule.isOrtho_iSup_right | Mathlib.Analysis.InnerProductSpace.Orthogonal | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Sort u_4} {U : Submodule 𝕜 E} {V : ι → Submodule 𝕜 E}, U ⟂ iSup V ↔ ∀ (i : ι), U ⟂ V i | null | true |
TensorProduct.homTensorHomMap_comp_map_lcomp | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_4} {N : Type u_5} {P : Type u_6} {Q : Type u_7}
[inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : AddCommMonoid Q]
[inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R P] [inst_8 : Module R Q] {M' : Type u_14}
... | `homTensorHomMap` is natural with respect to precomposition:
```
homTensorHomMap
Hom(M, P) ⊗ Hom(N, Q) ---------------> Hom(M ⊗ N, P ⊗ Q)
| |
| map f.lcomp f'.lcomp | (map f f').lcomp
↓ ↓
Hom(M', ... | true |
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.bound.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (h : Lean.Expr), sizeOf (Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.bound h) = 1 + sizeOf h | null | true |
Std.DTreeMap.Raw.maxKey!_alter_eq_self | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp] [inst_1 : Inhabited α],
t.WF →
∀ {k : α} {f : Option (β k) → Option (β k)},
(t.alter k f).isEmpty = false →
((t.alter k f).maxKey! = k ↔ (f (t.get? k)).isSome = t... | null | true |
_private.Mathlib.Algebra.Order.Monovary.0.monovaryOn_iff_forall_smul_nonneg._simp_1_3 | Mathlib.Algebra.Order.Monovary | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddRightMono α] {a b : α}, (0 ≤ a - b) = (b ≤ a) | null | false |
Std.HashSet.Raw.Equiv.union_right | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ m₃ : Std.HashSet.Raw α} [EquivBEq α] [LawfulHashable α],
m₁.WF → m₂.WF → m₃.WF → m₂.Equiv m₃ → (m₁ ∪ m₂).Equiv (m₁ ∪ m₃) | null | true |
CategoryTheory.Limits.diagonalObjPullbackFstIso_inv_fst_fst | Mathlib.CategoryTheory.Limits.Shapes.Diagonal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C]
{X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.diagonalObjPullbackFstIso f g).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pu... | null | true |
_private.Lean.Meta.Tactic.Split.0.Lean.Meta.splitLocalDecl?.match_1 | Lean.Meta.Tactic.Split | (motive : Lean.MVarId × Lean.MVarId → Sort u_1) →
(x : Lean.MVarId × Lean.MVarId) → ((mvarId₁ mvarId₂ : Lean.MVarId) → motive (mvarId₁, mvarId₂)) → motive x | null | false |
Qq.MaybeDefEq.defEq | Qq.MetaM | {u : Lean.Level} →
{α :
let u := u;
Q(Sort u)} →
{a b : Q(«$α»)} → «$a» =Q «$b» → Qq.MaybeDefEq a b | null | true |
alternatingGroup.normal_kleinFour | Mathlib.GroupTheory.SpecificGroups.Alternating.KleinFour | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α], Nat.card α = 4 → (alternatingGroup.kleinFour α).Normal | null | true |
PointedContMDiffMap.smul_def | Mathlib.Geometry.Manifold.DerivationBundle | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] (x : M) (f : PointedContMDiffMap 𝕜 I M... | null | true |
DomMulAct.instSMulSubtypeAEEqFunMemAddSubgroupLp._proof_1 | Mathlib.MeasureTheory.Function.LpSpace.DomAct.Basic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E], IsTopologicalAddGroup E | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.getLsbD_twoPow._proof_1_4 | Init.Data.BitVec.Lemmas | ∀ (i j w : ℕ), j < i → i = j → False | null | false |
_private.Mathlib.Combinatorics.Matroid.Circuit.0.Matroid.Indep.mem_fundCircuit_iff._simp_1_1 | Mathlib.Combinatorics.Matroid.Circuit | ∀ {α : Type u_1} (M : Matroid α) (e : α) (I : Set α), (e ∈ M.fundCircuit e I) = True | null | false |
Nat.Internal.SOM.Poly.add | Init.Data.Nat.Internal.SOM | Nat.Internal.SOM.Poly → Nat.Internal.SOM.Poly → Nat.Internal.SOM.Poly | null | true |
HomotopicalAlgebra.Precylinder.LeftHomotopy.op._proof_2 | Mathlib.AlgebraicTopology.ModelCategory.RightHomotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {P : HomotopicalAlgebra.Precylinder X}
{f g : X ⟶ Y} (h : P.LeftHomotopy f g), (CategoryTheory.CategoryStruct.comp h.h.op P.op.p₁).unop = g.op.unop | null | false |
Quaternion.dualNumberEquiv._proof_3 | Mathlib.Algebra.DualQuaternion | ∀ {R : Type u_1} [inst : CommRing R] (x x_1 : Quaternion (DualNumber R)),
({ re := TrivSqZeroExt.fst (x * x_1).re, imI := TrivSqZeroExt.fst (x * x_1).imI,
imJ := TrivSqZeroExt.fst (x * x_1).imJ, imK := TrivSqZeroExt.fst (x * x_1).imK },
{ re := TrivSqZeroExt.snd (x * x_1).re, imI := TrivSqZeroExt.snd (x... | null | false |
_private.Mathlib.Algebra.Order.Floor.BigOperators.0.Int.sum_range_add_ediv._proof_1_2 | Mathlib.Algebra.Order.Floor.BigOperators | ∀ (m : ℤ) {n : ℕ} (t : ℕ),
↑t = m % ↑n →
∀ i ∈ Finset.range n,
(m / ↑n + ↑i / ↑n + if ↑n ≤ m % ↑n + ↑i % ↑n then 1 else 0) = m / ↑n + if n - t ≤ i then 1 else 0 | null | false |
norm_commutator_sub_one_le | Mathlib.Analysis.Normed.Field.Basic | ∀ {α : Type u_1} [inst : NormedDivisionRing α] {a b : α},
a ≠ 0 → b ≠ 0 → ‖a * b * a⁻¹ * b⁻¹ - 1‖ ≤ 2 * ‖a‖⁻¹ * ‖b‖⁻¹ * ‖a - 1‖ * ‖b - 1‖ | null | true |
CategoryTheory.ObjectProperty.commShiftLift | Mathlib.CategoryTheory.ObjectProperty.Shift | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
(P : CategoryTheory.ObjectProperty C) →
{A : Type u_2} →
[inst_1 : AddMonoid A] →
[inst_2 : CategoryTheory.HasShift C A] →
{E : Type u_3} →
[inst_3 : CategoryTheory.Category.{v_2, u_3} E] →
... | null | true |
Group.IsPerfect.mk._flat_ctor | Mathlib.GroupTheory.IsPerfect | ∀ {G : Type u_1} [inst : Group G], commutator G = ⊤ → Group.IsPerfect G | null | false |
exists_nhds_split_inv | Mathlib.Topology.Algebra.Group.Neighborhood | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : Group G] [IsTopologicalGroup G] {s : Set G},
s ∈ nhds 1 → ∃ V ∈ nhds 1, ∀ v ∈ V, ∀ w ∈ V, v / w ∈ s | null | true |
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.below | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {motive_1 : Lean.Meta.Grind.Arith.Linear.EqCnstr → Sort u} →
{motive_2 : Lean.Meta.Grind.Arith.Linear.EqCnstrProof → Sort u} →
{motive_3 : Lean.Meta.Grind.Arith.Linear.IneqCnstr → Sort u} →
{motive_4 : Lean.Meta.Grind.Arith.Linear.IneqCnstrProof → Sort u} →
{motive_5 : Lean.Meta.Grind.Arith.Linear.D... | null | false |
Mathlib.Tactic.Rify.ratCast_le._simp_1 | Mathlib.Tactic.Rify | ∀ (a b : ℚ), (a ≤ b) = (↑a ≤ ↑b) | null | false |
Lean.Parser.Term.unreachable.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | null | true |
_private.Init.Data.String.Lemmas.Pattern.Pred.0.String.Slice.Pattern.Model.CharPred.Decidable.instLawfulToBackwardSearcherModelForallCharPropDefaultBackwardSearcherForallBoolDecide._simp_1 | Init.Data.String.Lemmas.Pattern.Pred | ∀ {p : Char → Prop} [inst : DecidablePred p] {s : String.Slice} {pos : s.Pos}
{l : List (String.Slice.Pattern.SearchStep s)},
String.Slice.Pattern.Model.IsValidRevSearchFrom p pos l =
String.Slice.Pattern.Model.IsValidRevSearchFrom (fun x => decide (p x)) pos l | null | false |
PSigma.RevLex.casesOn | Init.WF | ∀ {α : Sort u} {β : Sort v} {r : α → α → Prop} {s : β → β → Prop}
{motive : (a a_1 : (_ : α) ×' β) → PSigma.RevLex r s a a_1 → Prop} {a a_1 : (_ : α) ×' β}
(t : PSigma.RevLex r s a a_1),
(∀ {a₁ a₂ : α} (b : β) (a : r a₁ a₂), motive ⟨a₁, b⟩ ⟨a₂, b⟩ ⋯) →
(∀ (a₁ : α) {b₁ : β} (a₂ : α) {b₂ : β} (a : s b₁ b₂), mot... | null | false |
AddSubgroup.instFiniteIndexTop | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : AddGroup G], ⊤.FiniteIndex | null | true |
Nat.bijective_iff_surjective_and_card | Mathlib.SetTheory.Cardinal.Finite | ∀ {α : Type u_1} {β : Type u_2} [Finite α] (f : α → β),
Function.Bijective f ↔ Function.Surjective f ∧ Nat.card α = Nat.card β | null | true |
CategoryTheory.Functor.effectiveEpiFamily_of_map | Mathlib.CategoryTheory.EffectiveEpi.Preserves | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (F : CategoryTheory.Functor C D) [F.ReflectsEffectiveEpiFamilies]
{α : Type u} {B : C} (X : α → C) (π : (a : α) → X a ⟶ B),
(CategoryTheory.EffectiveEpiFamily (fun a => F.obj (X a)) fun a ... | null | true |
IsSemireal.recOn | Mathlib.Algebra.Ring.Semireal.Defs | {R : Type u_1} →
[inst : Add R] →
[inst_1 : Mul R] →
[inst_2 : One R] →
[inst_3 : Zero R] →
{motive : IsSemireal R → Sort u} →
(t : IsSemireal R) → ((one_add_ne_zero : ∀ {s : R}, IsSumSq s → 1 + s ≠ 0) → motive ⋯) → motive t | null | false |
_private.Lean.Meta.Tactic.SplitIf.0.Lean.Meta.FindSplitImpl.isCandidate?.match_1 | Lean.Meta.Tactic.SplitIf | (motive : Option Lean.Meta.MatcherInfo → Sort u_1) →
(x : Option Lean.Meta.MatcherInfo) →
((info : Lean.Meta.MatcherInfo) → motive (some info)) → ((x : Option Lean.Meta.MatcherInfo) → motive x) → motive x | null | false |
_private.Mathlib.Algebra.Quandle.0.Rack.toEnvelGroup.mapAux.match_1.eq_3 | Mathlib.Algebra.Quandle | ∀ {R : Type u_1} (motive : Rack.PreEnvelGroup R → Sort u_2) (a b : Rack.PreEnvelGroup R)
(h_1 : Unit → motive Rack.PreEnvelGroup.unit) (h_2 : (x : R) → motive (Rack.PreEnvelGroup.incl x))
(h_3 : (a b : Rack.PreEnvelGroup R) → motive (a.mul b)) (h_4 : (a : Rack.PreEnvelGroup R) → motive a.inv),
(match a.mul b with... | null | true |
Std.DHashMap.Const.toList_empty | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v}, Std.DHashMap.Const.toList ∅ = [] | null | true |
HopfAlgCat.Hom.noConfusion | Mathlib.Algebra.Category.HopfAlgCat.Basic | {P : Sort u_1} →
{R : Type u} →
{inst : CommRing R} →
{V W : HopfAlgCat R} →
{t : V.Hom W} →
{R' : Type u} →
{inst' : CommRing R'} →
{V' W' : HopfAlgCat R'} →
{t' : V'.Hom W'} →
R = R' → inst ≍ inst' → V ≍ V' → W ≍ W' → t ≍ t' → H... | null | false |
CategoryTheory.Limits.Cone.extendComp | Mathlib.CategoryTheory.Limits.Cones | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
(s : CategoryTheory.Limits.Cone F) →
{X Y : C} →
(f : X ⟶ Y) → (g : Y ⟶ s.pt) → s.extend (CategoryTheor... | Extending a cone by a composition is the same as extending the cone twice. | true |
Lean.Grind.IntModule.nsmul | Init.Grind.Module.Basic | {M : Type u} → [self : Lean.Grind.IntModule M] → SMul ℕ M | Scalar multiplication by natural numbers. | true |
sign_mul_abs | Mathlib.Basic.Sign.Basic | ∀ {α : Type u} [inst : Ring α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] (x : α), ↑(SignType.sign x) * |x| = x | null | true |
FirstOrder.Language.Equiv.instInhabited | Mathlib.ModelTheory.Basic | {L : FirstOrder.Language} → {M : Type w} → [inst : L.Structure M] → Inhabited (L.Equiv M M) | null | true |
CategoryTheory.Dial.Hom.rec | Mathlib.CategoryTheory.Dialectica.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasFiniteProducts C] →
[inst_2 : CategoryTheory.Limits.HasPullbacks C] →
{X Y : CategoryTheory.Dial C} →
{motive : X.Hom Y → Sort u_1} →
((f : X.src ⟶ Y.src) →
(F : X.src ... | null | false |
Cardinal.isStrongLimit_beth._simp_1 | Mathlib.SetTheory.Cardinal.Aleph | ∀ {o : Ordinal.{u_1}}, (Cardinal.beth o).IsStrongLimit = Order.IsSuccPrelimit o | null | false |
NNReal.rpow_inv_rpow_self | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {y : ℝ}, y ≠ 0 → ∀ (x : NNReal), (x ^ y) ^ (1 / y) = x | null | true |
Aesop.ScriptGenerated.Method.static | Aesop.Stats.Basic | Aesop.ScriptGenerated.Method | null | true |
Std.Time.instReprPlainDateTime.repr | Std.Time.DateTime.PlainDateTime | Std.Time.PlainDateTime → ℕ → Std.Format | null | true |
ChartedSpaceCore.noConfusion | Mathlib.Geometry.Manifold.ChartedSpace | {P : Sort u} →
{H : Type u_4} →
{inst : TopologicalSpace H} →
{M : Type u_5} →
{t : ChartedSpaceCore H M} →
{H' : Type u_4} →
{inst' : TopologicalSpace H'} →
{M' : Type u_5} →
{t' : ChartedSpaceCore H' M'} →
H = H' → inst ≍ inst' ... | null | false |
CategoryTheory.MorphismProperty.CostructuredArrow.isoMk._proof_6 | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {C : Type u_2} {D : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {P : CategoryTheory.MorphismProperty D}
{Q : CategoryTheory.MorphismProperty C} [inst_2 : Q.IsMultiplicative] {F : CategoryTheory.Functor C D} {X : D}
{A B : P.CostructuredArrow Q F X} (f ... | null | false |
_private.Mathlib.RingTheory.RingHom.Locally.0.RingHom.locally_localizationAwayPreserves._simp_1_2 | Mathlib.RingTheory.RingHom.Locally | ∀ {M : Type u_1} [inst : Monoid M] {n : M} {P : Submonoid M}, (Submonoid.powers n ≤ P) = (n ∈ P) | null | false |
CStarMatrix.toCLM._proof_1 | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {m : Type u_1} {n : Type u_3} {A : Type u_2} [inst : Fintype m] [inst_1 : NonUnitalCStarAlgebra A]
(M : CStarMatrix m n A),
Continuous (⇑(WithCStarModule.equivL ℂ).symm ∘ (fun v => Matrix.vecMul v M) ∘ ⇑(WithCStarModule.equivL ℂ)) | null | false |
Orientation.finOrthonormalBasis.congr_simp | Mathlib.Analysis.InnerProductSpace.Orientation | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] {n : ℕ} (hn : 0 < n)
(h : Module.finrank ℝ E = n) (x x_1 : Orientation ℝ E (Fin n)),
x = x_1 → Orientation.finOrthonormalBasis hn h x = Orientation.finOrthonormalBasis hn h x_1 | null | true |
Mathlib.Meta.FunProp.State | Mathlib.Tactic.FunProp.Types | Type | `fun_prop` state | true |
Lean.Meta.Simp.Config.warnExponents._default | Init.MetaTypes | Bool | null | false |
gcd_zero_left' | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : GCDMonoid α] (a : α), Associated (gcd 0 a) a | null | true |
CategoryTheory.ShortComplex.LeftHomologyData.unop_H | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex Cᵒᵖ} (h : S.LeftHomologyData), h.unop.H = Opposite.unop h.H | null | true |
BddOrd.hasForgetToBipointed._proof_1 | Mathlib.Order.Category.BddOrd | ∀ (X : BddOrd),
{ toFun := ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X)), map_fst := ⋯, map_snd := ⋯ } =
CategoryTheory.CategoryStruct.id { X := ↑X.toPartOrd, toProd := (⊥, ⊤) } | null | false |
AddHom.map_add | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : Add M] [inst_1 : Add N] (f : M →ₙ+ N) (a b : M), f (a + b) = f a + f b | null | true |
_private.Aesop.Builder.Default.0.Aesop.RuleBuilder.default.err | Aesop.Builder.Default | String → Aesop.RuleBuilderInput → Aesop.ElabM Aesop.LocalRuleSetMember | null | true |
Lean.Meta.Sym.getMatchWithExtra | Lean.Meta.Sym.Simp.DiscrTree | {α : Type} → Lean.MetavarContext → Lean.Meta.DiscrTree α → Lean.Expr → Array (α × ℕ) | Retrieves all values whose patterns match a prefix of `e`, along with the number of
extra (ignored) arguments.
This is useful for rewriting: if a pattern matches `f x` but `e` is `f x y z`, we can
still apply the rewrite and return `(value, 2)` indicating 2 extra arguments.
| true |
Lean.TraceData._sizeOf_inst | Lean.Message | SizeOf Lean.TraceData | null | false |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.LebesgueDifferentiationThm.0.IntervalIntegrable.ae_hasDerivAt_integral._proof_1_7 | Mathlib.MeasureTheory.Integral.IntervalIntegral.LebesgueDifferentiationThm | ∀ {a b : ℝ} (x : ℝ), x ≠ b → x ∈ Set.Icc a b → x < b | null | false |
CategoryTheory.ProjectiveResolution.liftHomotopyZeroOne_comp | Mathlib.CategoryTheory.Abelian.Projective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {Y Z : C}
{P : CategoryTheory.ProjectiveResolution Y} {Q : CategoryTheory.ProjectiveResolution Z} (f : P.complex ⟶ Q.complex)
(comm : CategoryTheory.CategoryStruct.comp f Q.π = 0),
CategoryTheory.CategoryStruct.comp (Cate... | null | true |
CategoryTheory.functorProdFunctorEquivUnitIso._proof_2 | Mathlib.CategoryTheory.Products.Basic | ∀ (A : Type u_2) [inst : CategoryTheory.Category.{u_4, u_2} A] (B : Type u_1)
[inst_1 : CategoryTheory.Category.{u_3, u_1} B] (C : Type u_5) [inst_2 : CategoryTheory.Category.{u_6, u_5} C]
{X Y : CategoryTheory.Functor A B × CategoryTheory.Functor A C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((Categ... | null | false |
Padic.padicNormE.mul | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (q r : ℚ_[p]), ‖q * r‖ = ‖q‖ * ‖r‖ | null | true |
_private.Lean.Elab.BuiltinTerm.0.Lean.Elab.Term.elabTypeStx._regBuiltin.Lean.Elab.Term.elabTypeStx_1 | Lean.Elab.BuiltinTerm | IO Unit | null | false |
_private.Qq.Macro.0.Qq.Impl.unquoteLCtx.match_4 | Qq.Macro | (motive : Lean.Level → Sort u_1) →
(__x : Lean.Level) → ((u : Lean.Level) → motive u.succ) → ((x : Lean.Level) → motive x) → motive __x | null | false |
Filter.HasCountableBasis.countable | Mathlib.Order.Filter.CountablyGenerated | ∀ {α : Type u_1} {ι : Type u_3} {l : Filter α} {p : ι → Prop} {s : ι → Set α},
l.HasCountableBasis p s → (Set.ofPred p).Countable | The set of `i` that satisfy the predicate `p` is countable. | true |
Multiset.toEnumFinset | Mathlib.Data.Multiset.Fintype | {α : Type u_1} → [DecidableEq α] → Multiset α → Finset (α × ℕ) | Construct a finset whose elements enumerate the elements of the multiset `m`.
The `ℕ` component is used to differentiate between equal elements: if `x` appears `n` times
then `(x, 0)`, ..., and `(x, n-1)` appear in the `Finset`. | true |
_private.Lean.Meta.Tactic.Congr.0.Lean.MVarId.congrImplies?.match_1 | Lean.Meta.Tactic.Congr | (motive : List Lean.MVarId → Sort u_1) →
(__x : List Lean.MVarId) →
((mvarId₁ mvarId₂ : Lean.MVarId) → (tail : List Lean.MVarId) → motive (mvarId₁ :: mvarId₂ :: tail)) →
((x : List Lean.MVarId) → motive x) → motive __x | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getD_map'._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.Mathlib.Analysis.Calculus.LHopital.0.HasDerivAt.lhopital_zero_nhdsGT._proof_1_4 | Mathlib.Analysis.Calculus.LHopital | ∀ {a : ℝ} {g' : ℝ → ℝ} (s₁ s₂ s₃ : Set ℝ),
(∀ y ∈ s₃, g' y ≠ 0) → ∀ (u : ℝ), Set.Ioo a u ⊆ s₁ ∩ s₂ ∩ s₃ → ∀ x ∈ Set.Ioo a u, ¬g' x = 0 | null | false |
String.Slice.Pattern.Model.CharPred.Decidable.instStrictPatternModelForallCharProp | Init.Data.String.Lemmas.Pattern.Pred | ∀ {p : Char → Prop} [inst : DecidablePred p], String.Slice.Pattern.Model.StrictPatternModel p | null | true |
WeierstrassCurve.Affine.nonsingular_add | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Formula | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Affine F} [inst_1 : DecidableEq F] {x₁ x₂ y₁ y₂ : F},
W.Nonsingular x₁ y₁ →
W.Nonsingular x₂ y₂ →
¬(x₁ = x₂ ∧ y₁ = W.negY x₂ y₂) →
W.Nonsingular (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂)) (W.addY x₁ x₂ y₁ (W.slope x₁ x₂ y₁ y₂)) | null | true |
ByteArray.utf8Decode?_utf8Encode_singleton_append | Init.Data.String.Basic | ∀ {l : ByteArray} {c : Char}, ([c].utf8Encode ++ l).utf8Decode? = Option.map (fun x => #[c] ++ x) l.utf8Decode? | null | true |
Polynomial.natDegree_lt_natDegree | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] {p : Polynomial R} {q : Polynomial S},
p ≠ 0 → p.degree < q.degree → p.natDegree < q.natDegree | null | true |
ValuativeExtension.mapValueGroupWithZero_mk | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : Ring B] [inst_2 : ValuativeRel A]
[inst_3 : ValuativeRel B] [inst_4 : Algebra A B] [inst_5 : ValuativeExtension A B] (r : A)
(s : ↥(ValuativeRel.posSubmonoid A)),
(ValuativeExtension.mapValueGroupWithZero A B) (ValuativeRel.ValueGroupWithZero.mk r s) =... | null | true |
Int.ceil_eq_self_iff_mem | Mathlib.Algebra.Order.Floor.Ring | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : FloorRing R] (a : R),
↑⌈a⌉ = a ↔ a ∈ Set.range Int.cast | null | true |
AlgHom.fieldRange | Mathlib.FieldTheory.IntermediateField.Basic | {K : Type u_1} →
{L : Type u_2} →
{L' : Type u_3} →
[inst : Field K] →
[inst_1 : Field L] →
[inst_2 : Field L'] → [inst_3 : Algebra K L] → [inst_4 : Algebra K L'] → (L →ₐ[K] L') → IntermediateField K L' | The range of an algebra homomorphism, as an intermediate field. | true |
Std.DTreeMap.Internal.Impl.Const.getEntryGTD_eq_getD_getEntryGT? | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} [inst : Ord α] {t : Std.DTreeMap.Internal.Impl α fun x => β} {k : α} {fallback : α × β},
Std.DTreeMap.Internal.Impl.Const.getEntryGTD k t fallback =
(Std.DTreeMap.Internal.Impl.Const.getEntryGT? k t).getD fallback | null | true |
MonCat.toCat._proof_2 | Mathlib.CategoryTheory.SingleObj | ∀ {X Y Z : MonCat} (f : X ⟶ Y) (g : Y ⟶ Z),
((CategoryTheory.SingleObj.mapHom ↑X ↑Z) (MonCat.Hom.hom (CategoryTheory.CategoryStruct.comp f g))).toCatHom =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.SingleObj.mapHom ↑X ↑Y) (MonCat.Hom.hom f)).toCatHom
((CategoryTheory.SingleObj.mapHom ↑Y ↑Z) (MonCat... | null | false |
ImportGraph.Shake.Bitset.HighToLow.mk._flat_ctor | ImportGraph.Shake.Basic | ImportGraph.Shake.Bitset → ImportGraph.Shake.Bitset.HighToLow | null | false |
LinearMap.ext_ring_op_iff | Mathlib.Algebra.Module.Equiv.Opposite | ∀ {R : Type u_1} {S : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : AddCommMonoid M]
[inst_3 : Module S M] {σ : Rᵐᵒᵖ →+* S} {f g : R →ₛₗ[σ] M}, f = g ↔ f 1 = g 1 | null | true |
Std.ExtHashMap.instReflBEq | Std.Data.ExtHashMap.Basic | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
[inst_2 : BEq β] [ReflBEq β], ReflBEq (Std.ExtHashMap α β) | null | true |
CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.mk.injEq | Mathlib.AlgebraicTopology.ExtraDegeneracy | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : CategoryTheory.SimplicialObject.Augmented C}
(s' : X.right ⟶ X.left.obj (Opposite.op { len := 0 }))
(s : (n : ℕ) → X.left.obj (Opposite.op { len := n }) ⟶ X.left.obj (Opposite.op { len := n + 1 }))
(s'_comp_ε :
autoParam
(CategoryTheory... | null | true |
FundamentalGroupoidFunctor.prodIso_inv | Mathlib.AlgebraicTopology.FundamentalGroupoid.Product | ∀ (A : TopCat) (B : TopCat),
(FundamentalGroupoidFunctor.prodIso A B).inv =
(FundamentalGroupoidFunctor.projLeft A B).prod' (FundamentalGroupoidFunctor.projRight A B) | null | true |
CategoryTheory.Functor.IsCartesian.map_isHomLift | Mathlib.CategoryTheory.FiberedCategory.Cartesian | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
(p : CategoryTheory.Functor 𝒳 𝒮) {R S : 𝒮} {a b : 𝒳} (f : R ⟶ S) (φ : a ⟶ b) [inst_2 : p.IsCartesian f φ] {a' : 𝒳}
(φ' : a' ⟶ b) [inst_3 : p.IsHomLift f φ'],
p.IsHomLift (CategoryTheory... | null | true |
IsCyclic.monoidHomMulEquivRootsOfUnityOfGenerator._proof_7 | Mathlib.RingTheory.RootsOfUnity.Basic | ∀ {G : Type u_2} [inst : CommGroup G] {g : G} (hg : ∀ (x : G), x ∈ Subgroup.zpowers g) (G' : Type u_1)
[inst_1 : CommGroup G'] (φ : ↥(rootsOfUnity (Nat.card G) G')),
↑((fun φ => ⟨⋯.unit, ⋯⟩) ((fun ζ => monoidHomOfForallMemZpowers hg ⋯) φ)) = ↑φ | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.