name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Std.HashSet.get?_diff_of_not_mem_right | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α} [EquivBEq α] [LawfulHashable α] {k : α},
k ∉ m₂ → (m₁ \ m₂).get? k = m₁.get? k | true |
AddGroupSeminorm.coe_le_coe | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : AddGroup E] {p q : AddGroupSeminorm E}, ⇑p ≤ ⇑q ↔ p ≤ q | true |
Std.DHashMap.Internal.Raw₀.isEmpty_eq_size_eq_zero | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β), (↑m).isEmpty = ((↑m).size == 0) | true |
Lean.LocalContext.mkLetDecl | Lean.LocalContext | Lean.LocalContext →
Lean.FVarId →
Lean.Name → Lean.Expr → Lean.Expr → optParam Bool false → optParam Lean.LocalDeclKind default → Lean.LocalContext | true |
Mathlib.Command.MinImports.minImpsCore | Mathlib.Tactic.MinImports | Lean.Syntax → Lean.Syntax → Lean.Elab.Command.CommandElabM Unit | true |
Int16.reduceAdd._regBuiltin.Int16.reduceAdd.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.780327193._hygCtx._hyg.54 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | false |
CategoryTheory.ShortComplex.opcyclesOpIso_inv_naturality | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) [inst_2 : S₁.HasLeftHomology] [inst_3 : S₂.HasLeftHomology],
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.cyclesMap φ).op S₁.opc... | true |
MulOpposite.instInhabited | Mathlib.Algebra.Opposites | {α : Type u_1} → [Inhabited α] → Inhabited αᵐᵒᵖ | true |
Bundle.TotalSpace.casesOn | Mathlib.Data.Bundle | {B : Type u_1} →
{F : Type u_4} →
{E : B → Type u_5} →
{motive : Bundle.TotalSpace F E → Sort u} →
(t : Bundle.TotalSpace F E) → ((proj : B) → (snd : E proj) → motive ⟨proj, snd⟩) → motive t | false |
ContinuousAlternatingMap.instAddCommGroup._proof_4 | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} {ι : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommGroup N] [inst_5 : Module R N]
[inst_6 : TopologicalSpace N] [inst_7 : IsTopologicalAddGroup N],
autoParam (∀ (n : ℕ) (a : M [⋀^ι]→L[R] N), I... | false |
SkewMonoidAlgebra.instSMulZeroClass._proof_1 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddMonoid k] {S : Type u_3} [inst_1 : SMulZeroClass S k] (a : S), a • 0 = 0 | false |
_private.Lean.Compiler.LCNF.Simp.ConstantFold.0.Lean.Compiler.LCNF.Simp.ConstantFold.Folder.mkBinary.match_1 | Lean.Compiler.LCNF.Simp.ConstantFold | (motive : Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure) → Sort u_1) →
(args : Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) →
((fvarId₁ fvarId₂ : Lean.FVarId) →
motive #[Lean.Compiler.LCNF.Arg.fvar fvarId₁, Lean.Compiler.LCNF.Arg.fvar fvarId₂]) →
((x : Array (Lean.Co... | false |
tendsto_mulIndicator_thickening_mulIndicator_closure | Mathlib.Topology.MetricSpace.ThickenedIndicator | ∀ {α : Type u_1} [inst : PseudoEMetricSpace α] {β : Type u_2} [inst_1 : One β] [inst_2 : TopologicalSpace β] (f : α → β)
(E : Set α),
Filter.Tendsto (fun δ => (Metric.thickening δ E).mulIndicator f) (nhdsWithin 0 (Set.Ioi 0))
(nhds ((closure E).mulIndicator f)) | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Opposites.Pullbacks.0.CategoryTheory.Limits.op_pullbackMap._simp_1 | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.CategoryStruct.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.CategoryStruct.comp g.op f.op = (CategoryTheory.CategoryStruct.comp f g).op | false |
Std.Net.IPAddr.ctorElimType | Std.Net.Addr | {motive : Std.Net.IPAddr → Sort u} → ℕ → Sort (max 1 u) | false |
Aesop.instInhabitedIteration | Aesop.Tree.Data | Inhabited Aesop.Iteration | true |
Std.DTreeMap.Internal.Impl.Const.maxKey?_modify_eq_maxKey? | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
[Std.LawfulEqOrd α], t.WF → ∀ {k : α} {f : β → β}, (Std.DTreeMap.Internal.Impl.Const.modify k f t).maxKey? = t.maxKey? | true |
PointedCone.mem_comap._simp_1 | Mathlib.Geometry.Convex.Cone.Pointed | ∀ {R : Type u_1} {E : Type u_2} {F : Type u_3} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : AddCommMonoid E] [inst_4 : Module R E] [inst_5 : AddCommMonoid F] [inst_6 : Module R F] {f : E →ₗ[R] F}
{C : PointedCone R F} {x : E}, (x ∈ PointedCone.comap f C) = (f x ∈ C) | false |
_private.Mathlib.Analysis.CStarAlgebra.Module.Constructions.0.WithCStarModule.antilipschitzWith_two_equiv_prod_aux | Mathlib.Analysis.CStarAlgebra.Module.Constructions | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] {E : Type u_2} {F : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : Module ℂ E] [inst_4 : SMul A E] [inst_5 : NormedAddCommGroup F]
[inst_6 : Module ℂ F] [inst_7 : SMul A F] [inst_8 : CStarModule A E] [inst_9 : CStarModule A F]
[inst_... | true |
AddGroupNorm.toNormedAddCommGroup | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_5} → [inst : AddCommGroup E] → AddGroupNorm E → NormedAddCommGroup E | true |
Lean.Lsp.Color.ctorIdx | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.Color → ℕ | false |
instRingFreeRing._proof_30 | Mathlib.RingTheory.FreeRing | ∀ (α : Type u_1), autoParam (∀ (x : FreeRing α), instRingFreeRing._aux_28 α 0 x = 1) Monoid.npow_zero._autoParam | false |
CategoryTheory.Limits.isIso_prod | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C}
[inst_1 : CategoryTheory.Limits.HasBinaryProduct W X] [inst_2 : CategoryTheory.Limits.HasBinaryProduct Y Z]
(f : W ⟶ Y) (g : X ⟶ Z) [CategoryTheory.IsIso f] [CategoryTheory.IsIso g],
CategoryTheory.IsIso (CategoryTheory.Limits.prod.map f g) | true |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.computeDistance._proof_7 | Init.Data.String.Pattern.String | ∀ (pat : String.Slice) (table : Array ℕ) (guess : ℕ) (hg : guess < table.size),
table[guess - 1] < guess → guess - 1 < table.size | false |
«_aux_Mathlib_Order_Hom_Basic___macroRules_term_↪o__1» | Mathlib.Order.Hom.Basic | Lean.Macro | false |
LinearOrderedCommGroup.multiplicative_int_orderMonoidIso_of_isLeast_one_lt._proof_1 | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {G : Type u_1} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G], IsOrderedAddMonoid (Additive G) | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic.0.WeierstrassCurve.Jacobian.equation_smul._simp_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | ∀ {R : Type r} [inst : CommRing R] (P : Fin 3 → R) (u : R), (u • P) 0 = u ^ 2 * P 0 | false |
Int.lt_ediv_add_one_mul_self | Init.Data.Int.DivMod.Lemmas | ∀ (a : ℤ) {b : ℤ}, 0 < b → a < (a / b + 1) * b | true |
AlgebraicTopology.alternatingFaceMapComplex_obj_d | Mathlib.AlgebraicTopology.AlternatingFaceMapComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(X : CategoryTheory.SimplicialObject C) (n : ℕ),
((AlgebraicTopology.alternatingFaceMapComplex C).obj X).d (n + 1) n =
AlgebraicTopology.AlternatingFaceMapComplex.objD X n | true |
CategoryTheory.MonoidalCategory.MonoidalRightAction.curriedActionMonoidal_ε_app | Mathlib.CategoryTheory.Monoidal.Action.End | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] (X : D),
(CategoryTheory.Functor.LaxMonoidal.ε (CategoryTheory.MonoidalCateg... | true |
ContDiffMapSupportedIn.coe_toBoundedContinuousFunction | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {n : ℕ∞} {K : TopologicalSpace.Compacts E} (f : ContDiffMapSupportedIn E F n K),
⇑{ toFun := ⇑f, continuous_toFun := ⋯, map_bounded' := ⋯ } = ⇑f | true |
Std.Net.instDecidableEqSocketAddress.decEq._proof_2 | Std.Net.Addr | ∀ (a : Std.Net.SocketAddressV6), Std.Net.SocketAddress.v6 a = Std.Net.SocketAddress.v6 a | false |
Lean.ConstantInfo.opaqueInfo | Lean.Declaration | Lean.OpaqueVal → Lean.ConstantInfo | true |
CategoryTheory.Lax.LaxTrans.instInhabitedHomLaxFunctor | Mathlib.CategoryTheory.Bicategory.Modification.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] → {F G : CategoryTheory.LaxFunctor B C} → {η : F ⟶ G} → Inhabited (η ⟶ η) | true |
Module.Basis.coe_parallelepiped | Mathlib.MeasureTheory.Measure.Haar.OfBasis | ∀ {ι : Type u_1} {E : Type u_3} [inst : Fintype ι] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E]
(b : Module.Basis ι ℝ E), ↑b.parallelepiped = parallelepiped ⇑b | true |
_private.Lean.Elab.PatternVar.0.Lean.Elab.Term.CollectPatternVars.throwInvalidNamedArgs.match_3 | Lean.Elab.PatternVar | (motive : Lean.SourceInfo → Sort u_1) →
(x : Lean.SourceInfo) →
((leading : Substring.Raw) →
(pos : String.Pos.Raw) →
(trailing : Substring.Raw) →
(endPos : String.Pos.Raw) → motive (Lean.SourceInfo.original leading pos trailing endPos)) →
((x : Lean.SourceInfo) → motive x) → m... | false |
CategoryTheory.IsFiltered.filteredClosure.base | Mathlib.CategoryTheory.Filtered.Small | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.IsFilteredOrEmpty C] {α : Type w}
{f : α → C} (x : α), CategoryTheory.IsFiltered.filteredClosure f (f x) | true |
_private.Mathlib.Topology.Algebra.AsymptoticCone.0.asymptoticCone_asymptoticCone._simp_1_2 | Mathlib.Topology.Algebra.AsymptoticCone | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {m : α → Filter β} {p : β → Prop},
(∃ᶠ (x : α) in f, ∃ᶠ (y : β) in m x, p y) = ∃ᶠ (y : β) in f.bind m, p y | false |
Lean.Compiler.LCNF.CodeDecl.dependsOn | Lean.Compiler.LCNF.DependsOn | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.CodeDecl pu → Lean.FVarIdSet → Bool | true |
_private.Mathlib.NumberTheory.Modular.0.ModularGroup.mem_closure_of_one_lt_norm._simp_1_4 | Mathlib.NumberTheory.Modular | ∀ {x : ℂ}, (1 < Complex.normSq x) = (1 < ‖x‖) | false |
Pell.Solution₁.instCommGroup._aux_14 | Mathlib.NumberTheory.Pell | {d : ℤ} → Pell.Solution₁ d → Pell.Solution₁ d → Pell.Solution₁ d | false |
Finset.coe_offDiag | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} (s : Finset α), ↑s.offDiag = (↑s).offDiag | true |
HasCompactSupport.convolutionExists_right_of_continuous_left | Mathlib.Analysis.Convolution | ∀ {𝕜 : Type u𝕜} {G : Type uG} {E : Type uE} {E' : Type uE'} {F : Type uF} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup E'] [inst_2 : NormedAddCommGroup F] {f : G → E} {g : G → E'}
[inst_3 : NontriviallyNormedField 𝕜] [inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜 E'] [inst_6 : NormedSpace 𝕜 ... | true |
Nat.toList_rco_ne_nil_iff | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m...n).toList ≠ [] ↔ m < n | true |
CategoryTheory.NatIso.ofComponents.app | Mathlib.CategoryTheory.NatIso | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor C D} (app' : (X : C) → F.obj X ≅ G.obj X)
(naturality :
∀ {X Y : C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (F.map f) (app' Y).hom =
Categor... | true |
CategoryTheory.Idempotents.Karoubi.coe | Mathlib.CategoryTheory.Idempotents.Karoubi | {C : Type u_1} → [inst : CategoryTheory.Category.{v_1, u_1} C] → CoeTC C (CategoryTheory.Idempotents.Karoubi C) | true |
Batteries.Tactic.Lint.Linter.casesOn | Batteries.Tactic.Lint.Basic | {motive : Batteries.Tactic.Lint.Linter → Sort u} →
(t : Batteries.Tactic.Lint.Linter) →
((test : Lean.Name → Lean.MetaM (Option Lean.MessageData)) →
(noErrorsFound errorsFound : Lean.MessageData) →
(isFast : Bool) →
motive { test := test, noErrorsFound := noErrorsFound, errorsFound :... | false |
Std.Do.ExceptConds.true_and | Std.Do.PostCond | ∀ {ps : Std.Do.PostShape} {x : Std.Do.ExceptConds ps}, (Std.Do.ExceptConds.true ∧ₑ x).entails x | true |
_private.Mathlib.Analysis.Convex.SpecificFunctions.Deriv.0.Nat.iterate.match_1.splitter | Mathlib.Analysis.Convex.SpecificFunctions.Deriv | {α : Sort u_2} →
(motive : ℕ → α → Sort u_1) →
(x : ℕ) → (x_1 : α) → ((a : α) → motive 0 a) → ((k : ℕ) → (a : α) → motive k.succ a) → motive x x_1 | true |
MProd.casesOn | Init.Prelude | {α β : Type u} →
{motive : MProd α β → Sort u_1} → (t : MProd α β) → ((fst : α) → (snd : β) → motive ⟨fst, snd⟩) → motive t | false |
LieAlgebra.Basis.sl2 | Mathlib.Algebra.Lie.Basis | ∀ {ι : Type u_1} {R : Type u_2} {L : Type u_3} [inst : Finite ι] [inst_1 : CommRing R] [inst_2 : LieRing L]
[inst_3 : LieAlgebra R L] (self : LieAlgebra.Basis ι R L) (i : ι), IsSl2Triple (self.h i) (self.e i) (self.f i) | true |
NumberField.mixedEmbedding.polarSpace | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.PolarCoord | (K : Type u_1) → [Field K] → Type u_1 | true |
AlgebraicGeometry.Scheme.IdealSheafData.le_map_iff_comap_le | Mathlib.AlgebraicGeometry.IdealSheaf.Functorial | ∀ {X Y : AlgebraicGeometry.Scheme} {I : X.IdealSheafData} {f : X ⟶ Y} {J : Y.IdealSheafData},
J ≤ I.map f ↔ J.comap f ≤ I | true |
ConcaveOn.bddBelow_convexHull | Mathlib.Analysis.Convex.Jensen | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_4} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : AddCommGroup E] [inst_4 : AddCommGroup β] [inst_5 : LinearOrder β] [IsOrderedAddMonoid β]
[inst_7 : Module 𝕜 E] [inst_8 : Module 𝕜 β] [IsStrictOrderedModule 𝕜 β] {f : E → β} {s t : Set E... | true |
UniformSpace.isClopen_ball_of_isSymm_of_isTrans_of_mem_uniformity | Mathlib.Topology.UniformSpace.Ultra.Basic | ∀ {X : Type u_1} [inst : UniformSpace X] (x : X) {V : SetRel X X} [V.IsSymm] [V.IsTrans],
V ∈ uniformity X → IsClopen (UniformSpace.ball x V) | true |
CategoryTheory.Limits.instHasPullbackUnopOfHasPushoutOpposite | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : Cᵒᵖ} (f : X ⟶ Y) (g : X ⟶ Z)
[CategoryTheory.Limits.HasPushout f g], CategoryTheory.Limits.HasPullback f.unop g.unop | true |
_private.Std.Data.DHashMap.Internal.RawLemmas.0.Std.DHashMap.Internal.Raw₀.Const.insertMany_list_equiv_foldl._simp_1_1 | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m₁ m₂ : Std.DHashMap.Raw α β},
m₁.Equiv m₂ = (Std.DHashMap.Internal.toListModel m₁.buckets).Perm (Std.DHashMap.Internal.toListModel m₂.buckets) | false |
isCompact_of_finite_subcover | Mathlib.Topology.Compactness.Compact | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X},
(∀ {ι : Type u} (U : ι → Set X), (∀ (i : ι), IsOpen (U i)) → s ⊆ ⋃ i, U i → ∃ t, s ⊆ ⋃ i ∈ t, U i) → IsCompact s | true |
le_of_eq_or_lt | Mathlib.Order.Defs.PartialOrder | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a = b ∨ a < b → a ≤ b | true |
Matrix.exp_zsmul | Mathlib.Analysis.Normed.Algebra.MatrixExponential | ∀ {m : Type u_1} {𝔸 : Type u_4} [inst : Fintype m] [inst_1 : DecidableEq m] [inst_2 : NormedCommRing 𝔸]
[NormedAlgebra ℚ 𝔸] [CompleteSpace 𝔸] (z : ℤ) (A : Matrix m m 𝔸), NormedSpace.exp (z • A) = NormedSpace.exp A ^ z | true |
Quiver.Path.recOn | Mathlib.Combinatorics.Quiver.Path | {V : Type u} →
[inst : Quiver V] →
{a : V} →
{motive : (a_1 : V) → Quiver.Path a a_1 → Sort u_1} →
{a_1 : V} →
(t : Quiver.Path a a_1) →
motive a Quiver.Path.nil →
({b c : V} → (a_2 : Quiver.Path a b) → (a_3 : b ⟶ c) → motive b a_2 → motive c (a_2.cons a_3)) →
... | false |
CategoryTheory.Limits.BinaryBicone.ofLimitCone | Mathlib.CategoryTheory.Preadditive.Biproducts | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{X Y : C} →
{t : CategoryTheory.Limits.Cone (CategoryTheory.Limits.pair X Y)} →
CategoryTheory.Limits.IsLimit t → CategoryTheory.Limits.BinaryBicone X Y | true |
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.size_assignments_insert | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | ∀ {n : ℕ} (f : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n)
(c : Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n), (f.insert c).assignments.size = f.assignments.size | true |
_private.Mathlib.NumberTheory.NumberField.Basic.0.NumberField.RingOfIntegers.ker_algebraMap_eq_bot._simp_1_2 | Mathlib.NumberTheory.NumberField.Basic | ∀ {K : Type u_1} [inst : Field K] {x : NumberField.RingOfIntegers K},
((algebraMap (NumberField.RingOfIntegers K) K) x = 0) = (x = 0) | false |
Fin.val_congr | Init.Data.Fin.Basic | ∀ {n : ℕ} {a b : Fin n}, a = b → ↑a = ↑b | true |
ApproximatesLinearOn.toOpenPartialHomeomorph._proof_2 | Mathlib.Analysis.Calculus.InverseFunctionTheorem.ApproximatesLinearOn | ∀ {𝕜 : Type u_3} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_1} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] (f : E → F)
{f' : E ≃L[𝕜] F} (s : Set E) {c : NNReal} [CompleteSpace E],
ApproximatesLinearOn f (↑f') s c → S... | false |
List.findFinIdx?_eq_pmap_findIdx?._simp_1 | Init.Data.List.Find | ∀ {α : Type u_1} {xs : List α} {p : α → Bool} {i : ℕ},
(List.findIdx? p xs = some i) = ∃ (h : i < xs.length), p xs[i] = true ∧ ∀ (j : ℕ) (hji : j < i), ¬p xs[j] = true | false |
Ring.DirectLimit.congr._proof_1 | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_3} [inst : Preorder ι] {G : ι → Type u_1} [inst_1 : (i : ι) → CommRing (G i)]
{f : (i j : ι) → i ≤ j → G i →+* G j} {G' : ι → Type u_2} [inst_2 : (i : ι) → CommRing (G' i)]
{f' : (i j : ι) → i ≤ j → G' i →+* G' j} (e : (i : ι) → G i ≃+* G' i),
(∀ (i j : ι) (h : i ≤ j), (e j).toRingHom.comp (f i j h)... | false |
WeierstrassCurve.Δ_of_isCharTwoJEqZeroNF_of_char_two | Mathlib.AlgebraicGeometry.EllipticCurve.NormalForms | ∀ {R : Type u_1} [inst : CommRing R] (W : WeierstrassCurve R) [W.IsCharTwoJEqZeroNF] [CharP R 2], W.Δ = W.a₃ ^ 4 | true |
NonUnitalCommRing.noConfusionType | Mathlib.Algebra.Ring.Defs | Sort u_1 → {α : Type u} → NonUnitalCommRing α → {α' : Type u} → NonUnitalCommRing α' → Sort u_1 | false |
_private.Mathlib.Data.Finsupp.Multiset.0.Finsupp.orderIsoMultiset._simp_2 | Mathlib.Data.Finsupp.Multiset | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Multiset α}, (s ≤ t) = ∀ (a : α), Multiset.count a s ≤ Multiset.count a t | false |
UInt8.toFin_sub | Init.Data.UInt.Lemmas | ∀ (a b : UInt8), (a - b).toFin = a.toFin - b.toFin | true |
Preord.Hom.noConfusion | Mathlib.Order.Category.Preord | {P : Sort u_1} →
{X Y : Preord} →
{t : X.Hom Y} → {X' Y' : Preord} → {t' : X'.Hom Y'} → X = X' → Y = Y' → t ≍ t' → Preord.Hom.noConfusionType P t t' | false |
_private.Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas.0.Associates.le_singleton_iff._simp_1_2 | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ {M : Type u_1} [inst : CommMonoid M] (a : M) (n : ℕ), Associates.mk a ^ n = Associates.mk (a ^ n) | false |
Int.toList_rco_eq_append | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ}, m < n → (m...n).toList = (m...n - 1).toList ++ [n - 1] | true |
HomotopicalAlgebra.PathObject.IsGood.mk | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C}
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C] {P : HomotopicalAlgebra.PathObject A}
[inst_2 : CategoryTheory.Limits.HasBinaryProduct A A] [inst_3 : HomotopicalAlgebra.CategoryWithFibrations C],
autoParam (HomotopicalAlgebra.Fibration ... | true |
UInt64.ext_iff | Batteries.Data.UInt | ∀ {x y : UInt64}, x = y ↔ x.toNat = y.toNat | true |
fourier_neg' | Mathlib.Analysis.Fourier.AddCircle | ∀ {T : ℝ} {n : ℤ} {x : AddCircle T}, ↑(-(n • x)).toCircle = (starRingEnd ℂ) ((fourier n) x) | true |
Std.Iter.any_filterMap | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β β' : Type w} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id] [inst_2 : Std.IteratorLoop α Id Id]
[Std.LawfulIteratorLoop α Id Id] {it : Std.Iter β} {f : β → Option β'} {p : β' → Bool},
Std.Iter.any p (Std.Iter.filterMap f it) =
Std.Iter.any
(fun x =>
match f x with
| some f... | true |
SimpleGraph.Subgraph.subgraphOfAdj_eq_induce | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} {v w : V} (hvw : G.Adj v w), G.subgraphOfAdj hvw = ⊤.induce {v, w} | true |
OpenPartialHomeomorph.refl_trans | Mathlib.Topology.OpenPartialHomeomorph.Composition | ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
(e : OpenPartialHomeomorph X Y), (OpenPartialHomeomorph.refl X).trans e = e | true |
Path.symm_continuous_family | Mathlib.Topology.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] {ι : Type u_4} [inst_1 : TopologicalSpace ι] {a b : ι → X}
(γ : (t : ι) → Path (a t) (b t)), Continuous ↿γ → Continuous ↿fun t => (γ t).symm | true |
CommSemiring.toBialgebra._proof_4 | Mathlib.RingTheory.Bialgebra.Basic | ∀ (R : Type u_1) [inst : CommSemiring R], CoalgebraStruct.comul 1 = CoalgebraStruct.comul 1 | false |
List.suffix_insert._simp_1 | Mathlib.Data.List.Infix | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (l : List α), (l <:+ List.insert a l) = True | false |
Lean.Grind.AC.SubseqResult.exact.elim | Lean.Meta.Tactic.Grind.AC.Seq | {motive : Lean.Grind.AC.SubseqResult → Sort u} →
(t : Lean.Grind.AC.SubseqResult) → t.ctorIdx = 1 → motive Lean.Grind.AC.SubseqResult.exact → motive t | false |
_private.Lean.Meta.Structure.0.Lean.Meta.instantiateStructDefaultValueFn?.go?._sparseCasesOn_1 | Lean.Meta.Structure | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
(Nat.hasNotBit 64 t.ctorIdx → motive t) → motive t | false |
CategoryTheory.Under.liftCone._proof_1 | Mathlib.CategoryTheory.Limits.Over | ∀ {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} (c : CategoryTheory.Limits.Cone F)
{X : C} (f : X ⟶ c.pt) (j : J),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.Functor.const J).obj (CategoryTheor... | false |
Codisjoint.hnot_le_right | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : CoheytingAlgebra α] {a b : α}, Codisjoint a b → ￢a ≤ b | true |
IsPurelyInseparable.hasExponent_iff' | Mathlib.FieldTheory.PurelyInseparable.Exponent | ∀ (K : Type u_2) (L : Type u_3) [inst : CommRing K] [inst_1 : Ring L] [inst_2 : Algebra K L] (p : ℕ) [ExpChar K p],
IsPurelyInseparable.HasExponent K L ↔ ∃ e, ∀ (a : L), a ^ p ^ e ∈ (algebraMap K L).range | true |
Lean.MonadError.rec | Lean.Exception | {m : Type → Type} →
{motive : Lean.MonadError m → Sort u} →
([toMonadExceptOf : MonadExceptOf Lean.Exception m] →
[toMonadRef : Lean.MonadRef m] →
[toAddErrorMessageContext : Lean.AddErrorMessageContext m] →
motive
{ toMonadExceptOf := toMonadExceptOf, toMonadRef := toM... | false |
CategoryTheory.isIso_of_mono_of_epi | Mathlib.CategoryTheory.Balanced | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Balanced C] {X Y : C} (f : X ⟶ Y)
[CategoryTheory.Mono f] [CategoryTheory.Epi f], CategoryTheory.IsIso f | true |
CategoryTheory.NatIso.unop_whiskerLeft | Mathlib.CategoryTheory.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ} {E : Type u_1} [inst_2 : CategoryTheory.Category.{v_1, u_1} E]
{H : CategoryTheory.Functor Eᵒᵖ Cᵒᵖ} (α : F ≅ G),
CategoryTheory.NatIso.unop (H.isoWhiskerLe... | true |
CategoryTheory.IsMonoidalRightDistrib.preservesBinaryCoproducts_tensorRight | Mathlib.CategoryTheory.Distributive.Monoidal | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {inst_1 : CategoryTheory.MonoidalCategory C}
{inst_2 : CategoryTheory.Limits.HasBinaryCoproducts C} [self : CategoryTheory.IsMonoidalRightDistrib C] (X : C),
CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.Discrete CategoryTheory.Limits.Walking... | true |
_private.Mathlib.Topology.Category.Profinite.Nobeling.Successor.0.Profinite.NobelingProof.union_C0C1_eq._simp_1_3 | Mathlib.Topology.Category.Profinite.Nobeling.Successor | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∪ b) = (x ∈ a ∨ x ∈ b) | false |
Lean.IR.EmitLLVM.RefcountKind.ctorIdx | Lean.Compiler.IR.EmitLLVM | Lean.IR.EmitLLVM.RefcountKind → ℕ | false |
Valuation.IsEquiv.orderMonoidIso_trans | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} {Γ'₀ : Type u_5} {Γ''₀ : Type u_6} [inst : LinearOrderedCommGroupWithZero Γ₀]
[inst_1 : LinearOrderedCommGroupWithZero Γ'₀] [inst_2 : LinearOrderedCommGroupWithZero Γ''₀] [inst_3 : Ring R]
{v : Valuation R Γ₀} {w : Valuation R Γ'₀} {u : Valuation R Γ''₀} (h : v.IsEquiv w) (h' : w.Is... | true |
Std.DTreeMap.Internal.Impl.minView.eq_def | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β) (hl : l.Balanced)
(hr : r.Balanced) (hlr : Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size r.size),
Std.DTreeMap.Internal.Impl.minView k v l r hl hr hlr =
match l, hl, hlr with
| Std.DTreeMap.Internal.Impl.leaf, hl, hl... | true |
CategoryTheory.AddMon.instAddMonObjTensorObj._proof_3 | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {M N : C} [inst_3 : CategoryTheory.AddMonObj M]
[inst_4 : CategoryTheory.AddMonObj N],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategorySt... | false |
BoundedContinuousFunction.instOne | Mathlib.Topology.ContinuousMap.Bounded.Basic | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] → [inst_1 : PseudoMetricSpace β] → [One β] → One (BoundedContinuousFunction α β) | true |
IsometryEquiv.constSMul_symm | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {G : Type v} {X : Type w} [inst : PseudoEMetricSpace X] [inst_1 : Group G] [inst_2 : MulAction G X]
[inst_3 : IsIsometricSMul G X] (c : G), (IsometryEquiv.constSMul c).symm = IsometryEquiv.constSMul c⁻¹ | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.